diff --git "a/python_libs_pandas.txt" "b/python_libs_pandas.txt"
new file mode 100644--- /dev/null
+++ "b/python_libs_pandas.txt"
@@ -0,0 +1,78561 @@
+# File: pandas-main/generate_pxi.py
+import argparse
+import os
+from Cython import Tempita
+
+def process_tempita(pxifile, outfile) -> None:
+    with open(pxifile, encoding='utf-8') as f:
+        tmpl = f.read()
+    pyxcontent = Tempita.sub(tmpl)
+    with open(outfile, 'w', encoding='utf-8') as f:
+        f.write(pyxcontent)
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('infile', type=str, help='Path to the input file')
+    parser.add_argument('-o', '--outdir', type=str, help='Path to the output directory')
+    args = parser.parse_args()
+    if not args.infile.endswith('.in'):
+        raise ValueError(f'Unexpected extension: {args.infile}')
+    outdir_abs = os.path.join(os.getcwd(), args.outdir)
+    outfile = os.path.join(outdir_abs, os.path.splitext(os.path.split(args.infile)[1])[0])
+    process_tempita(args.infile, outfile)
+main()
+
+# File: pandas-main/generate_version.py
+import argparse
+import os
+import sys
+import versioneer
+sys.path.insert(0, '')
+
+def write_version_info(path) -> None:
+    version = None
+    git_version = None
+    try:
+        import _version_meson
+        version = _version_meson.__version__
+        git_version = _version_meson.__git_version__
+    except ImportError:
+        version = versioneer.get_version()
+        git_version = versioneer.get_versions()['full-revisionid']
+    if os.environ.get('MESON_DIST_ROOT'):
+        path = os.path.join(os.environ.get('MESON_DIST_ROOT'), path)
+    with open(path, 'w', encoding='utf-8') as file:
+        file.write(f'__version__="{version}"\n')
+        file.write(f'__git_version__="{git_version}"\n')
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-o', '--outfile', type=str, help='Path to write version info to', required=False)
+    parser.add_argument('--print', default=False, action='store_true', help='Whether to print out the version', required=False)
+    args = parser.parse_args()
+    if args.outfile:
+        if not args.outfile.endswith('.py'):
+            raise ValueError(f'Output file must be a Python file. Got: {args.outfile} as filename instead')
+        write_version_info(args.outfile)
+    if args.print:
+        try:
+            import _version_meson
+            version = _version_meson.__version__
+        except ImportError:
+            version = versioneer.get_version()
+        print(version)
+main()
+
+# File: pandas-main/pandas/__init__.py
+from __future__ import annotations
+__docformat__ = 'restructuredtext'
+_hard_dependencies = ('numpy', 'dateutil')
+_missing_dependencies = []
+for _dependency in _hard_dependencies:
+    try:
+        __import__(_dependency)
+    except ImportError as _e:
+        _missing_dependencies.append(f'{_dependency}: {_e}')
+if _missing_dependencies:
+    raise ImportError('Unable to import required dependencies:\n' + '\n'.join(_missing_dependencies))
+del _hard_dependencies, _dependency, _missing_dependencies
+try:
+    from pandas.compat import is_numpy_dev as _is_numpy_dev
+except ImportError as _err:
+    _module = _err.name
+    raise ImportError(f"C extension: {_module} not built. If you want to import pandas from the source directory, you may need to run 'python -m pip install -ve . --no-build-isolation -Ceditable-verbose=true' to build the C extensions first.") from _err
+from pandas._config import get_option, set_option, reset_option, describe_option, option_context, options
+import pandas.core.config_init
+from pandas.core.api import ArrowDtype, Int8Dtype, Int16Dtype, Int32Dtype, Int64Dtype, UInt8Dtype, UInt16Dtype, UInt32Dtype, UInt64Dtype, Float32Dtype, Float64Dtype, CategoricalDtype, PeriodDtype, IntervalDtype, DatetimeTZDtype, StringDtype, BooleanDtype, NA, isna, isnull, notna, notnull, Index, CategoricalIndex, RangeIndex, MultiIndex, IntervalIndex, TimedeltaIndex, DatetimeIndex, PeriodIndex, IndexSlice, NaT, Period, period_range, Timedelta, timedelta_range, Timestamp, date_range, bdate_range, Interval, interval_range, DateOffset, to_numeric, to_datetime, to_timedelta, Flags, Grouper, factorize, unique, NamedAgg, array, Categorical, set_eng_float_format, Series, DataFrame
+from pandas.core.dtypes.dtypes import SparseDtype
+from pandas.tseries.api import infer_freq
+from pandas.tseries import offsets
+from pandas.core.computation.api import eval
+from pandas.core.reshape.api import concat, lreshape, melt, wide_to_long, merge, merge_asof, merge_ordered, crosstab, pivot, pivot_table, get_dummies, from_dummies, cut, qcut
+from pandas import api, arrays, errors, io, plotting, tseries
+from pandas import testing
+from pandas.util._print_versions import show_versions
+from pandas.io.api import ExcelFile, ExcelWriter, read_excel, read_csv, read_fwf, read_table, read_pickle, to_pickle, HDFStore, read_hdf, read_sql, read_sql_query, read_sql_table, read_clipboard, read_parquet, read_orc, read_feather, read_html, read_xml, read_json, read_stata, read_sas, read_spss
+from pandas.io.json._normalize import json_normalize
+from pandas.util._tester import test
+_built_with_meson = False
+try:
+    from pandas._version_meson import __version__, __git_version__
+    _built_with_meson = True
+except ImportError:
+    from pandas._version import get_versions
+    v = get_versions()
+    __version__ = v.get('closest-tag', v['version'])
+    __git_version__ = v.get('full-revisionid')
+    del get_versions, v
+__doc__ = '\npandas - a powerful data analysis and manipulation library for Python\n=====================================================================\n\n**pandas** is a Python package providing fast, flexible, and expressive data\nstructures designed to make working with "relational" or "labeled" data both\neasy and intuitive. It aims to be the fundamental high-level building block for\ndoing practical, **real world** data analysis in Python. Additionally, it has\nthe broader goal of becoming **the most powerful and flexible open source data\nanalysis / manipulation tool available in any language**. It is already well on\nits way toward this goal.\n\nMain Features\n-------------\nHere are just a few of the things that pandas does well:\n\n  - Easy handling of missing data in floating point as well as non-floating\n    point data.\n  - Size mutability: columns can be inserted and deleted from DataFrame and\n    higher dimensional objects\n  - Automatic and explicit data alignment: objects can be explicitly aligned\n    to a set of labels, or the user can simply ignore the labels and let\n    `Series`, `DataFrame`, etc. automatically align the data for you in\n    computations.\n  - Powerful, flexible group by functionality to perform split-apply-combine\n    operations on data sets, for both aggregating and transforming data.\n  - Make it easy to convert ragged, differently-indexed data in other Python\n    and NumPy data structures into DataFrame objects.\n  - Intelligent label-based slicing, fancy indexing, and subsetting of large\n    data sets.\n  - Intuitive merging and joining data sets.\n  - Flexible reshaping and pivoting of data sets.\n  - Hierarchical labeling of axes (possible to have multiple labels per tick).\n  - Robust IO tools for loading data from flat files (CSV and delimited),\n    Excel files, databases, and saving/loading data from the ultrafast HDF5\n    format.\n  - Time series-specific functionality: date range generation and frequency\n    conversion, moving window statistics, date shifting and lagging.\n'
+__all__ = ['ArrowDtype', 'BooleanDtype', 'Categorical', 'CategoricalDtype', 'CategoricalIndex', 'DataFrame', 'DateOffset', 'DatetimeIndex', 'DatetimeTZDtype', 'ExcelFile', 'ExcelWriter', 'Flags', 'Float32Dtype', 'Float64Dtype', 'Grouper', 'HDFStore', 'Index', 'IndexSlice', 'Int16Dtype', 'Int32Dtype', 'Int64Dtype', 'Int8Dtype', 'Interval', 'IntervalDtype', 'IntervalIndex', 'MultiIndex', 'NA', 'NaT', 'NamedAgg', 'Period', 'PeriodDtype', 'PeriodIndex', 'RangeIndex', 'Series', 'SparseDtype', 'StringDtype', 'Timedelta', 'TimedeltaIndex', 'Timestamp', 'UInt16Dtype', 'UInt32Dtype', 'UInt64Dtype', 'UInt8Dtype', 'api', 'array', 'arrays', 'bdate_range', 'concat', 'crosstab', 'cut', 'date_range', 'describe_option', 'errors', 'eval', 'factorize', 'get_dummies', 'from_dummies', 'get_option', 'infer_freq', 'interval_range', 'io', 'isna', 'isnull', 'json_normalize', 'lreshape', 'melt', 'merge', 'merge_asof', 'merge_ordered', 'notna', 'notnull', 'offsets', 'option_context', 'options', 'period_range', 'pivot', 'pivot_table', 'plotting', 'qcut', 'read_clipboard', 'read_csv', 'read_excel', 'read_feather', 'read_fwf', 'read_hdf', 'read_html', 'read_json', 'read_orc', 'read_parquet', 'read_pickle', 'read_sas', 'read_spss', 'read_sql', 'read_sql_query', 'read_sql_table', 'read_stata', 'read_table', 'read_xml', 'reset_option', 'set_eng_float_format', 'set_option', 'show_versions', 'test', 'testing', 'timedelta_range', 'to_datetime', 'to_numeric', 'to_pickle', 'to_timedelta', 'tseries', 'unique', 'wide_to_long']
+
+# File: pandas-main/pandas/_config/__init__.py
+""""""
+__all__ = ['config', 'detect_console_encoding', 'get_option', 'set_option', 'reset_option', 'describe_option', 'option_context', 'options']
+from pandas._config import config
+from pandas._config import dates
+from pandas._config.config import _global_config, describe_option, get_option, option_context, options, reset_option, set_option
+from pandas._config.display import detect_console_encoding
+
+def using_string_dtype() -> bool:
+    _mode_options = _global_config['future']
+    return _mode_options['infer_string']
+
+# File: pandas-main/pandas/_config/config.py
+""""""
+from __future__ import annotations
+from contextlib import contextmanager
+import re
+from typing import TYPE_CHECKING, Any, NamedTuple, cast
+import warnings
+from pandas._typing import F
+from pandas.util._exceptions import find_stack_level
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator, Sequence
+
+class DeprecatedOption(NamedTuple):
+    key: str
+    msg: str | None
+    rkey: str | None
+    removal_ver: str | None
+
+class RegisteredOption(NamedTuple):
+    key: str
+    defval: Any
+    doc: str
+    validator: Callable[[object], Any] | None
+    cb: Callable[[str], Any] | None
+_deprecated_options: dict[str, DeprecatedOption] = {}
+_registered_options: dict[str, RegisteredOption] = {}
+_global_config: dict[str, Any] = {}
+_reserved_keys: list[str] = ['all']
+
+class OptionError(AttributeError, KeyError):
+
+def _get_single_key(pat: str) -> str:
+    keys = _select_options(pat)
+    if len(keys) == 0:
+        _warn_if_deprecated(pat)
+        raise OptionError(f'No such keys(s): {pat!r}')
+    if len(keys) > 1:
+        raise OptionError('Pattern matched multiple keys')
+    key = keys[0]
+    _warn_if_deprecated(key)
+    key = _translate_key(key)
+    return key
+
+def get_option(pat: str) -> Any:
+    key = _get_single_key(pat)
+    (root, k) = _get_root(key)
+    return root[k]
+
+def set_option(*args) -> None:
+    nargs = len(args)
+    if not nargs or nargs % 2 != 0:
+        raise ValueError('Must provide an even number of non-keyword arguments')
+    for (k, v) in zip(args[::2], args[1::2]):
+        key = _get_single_key(k)
+        opt = _get_registered_option(key)
+        if opt and opt.validator:
+            opt.validator(v)
+        (root, k_root) = _get_root(key)
+        root[k_root] = v
+        if opt.cb:
+            opt.cb(key)
+
+def describe_option(pat: str='', _print_desc: bool=True) -> str | None:
+    keys = _select_options(pat)
+    if len(keys) == 0:
+        raise OptionError(f'No such keys(s) for pat={pat!r}')
+    s = '\n'.join([_build_option_description(k) for k in keys])
+    if _print_desc:
+        print(s)
+        return None
+    return s
+
+def reset_option(pat: str) -> None:
+    keys = _select_options(pat)
+    if len(keys) == 0:
+        raise OptionError(f'No such keys(s) for pat={pat!r}')
+    if len(keys) > 1 and len(pat) < 4 and (pat != 'all'):
+        raise ValueError('You must specify at least 4 characters when resetting multiple keys, use the special keyword "all" to reset all the options to their default value')
+    for k in keys:
+        set_option(k, _registered_options[k].defval)
+
+def get_default_val(pat: str):
+    key = _get_single_key(pat)
+    return _get_registered_option(key).defval
+
+class DictWrapper:
+    d: dict[str, Any]
+
+    def __init__(self, d: dict[str, Any], prefix: str='') -> None:
+        object.__setattr__(self, 'd', d)
+        object.__setattr__(self, 'prefix', prefix)
+
+    def __setattr__(self, key: str, val: Any) -> None:
+        prefix = object.__getattribute__(self, 'prefix')
+        if prefix:
+            prefix += '.'
+        prefix += key
+        if key in self.d and (not isinstance(self.d[key], dict)):
+            set_option(prefix, val)
+        else:
+            raise OptionError('You can only set the value of existing options')
+
+    def __getattr__(self, key: str):
+        prefix = object.__getattribute__(self, 'prefix')
+        if prefix:
+            prefix += '.'
+        prefix += key
+        try:
+            v = object.__getattribute__(self, 'd')[key]
+        except KeyError as err:
+            raise OptionError('No such option') from err
+        if isinstance(v, dict):
+            return DictWrapper(v, prefix)
+        else:
+            return get_option(prefix)
+
+    def __dir__(self) -> list[str]:
+        return list(self.d.keys())
+options = DictWrapper(_global_config)
+
+@contextmanager
+def option_context(*args) -> Generator[None, None, None]:
+    if len(args) % 2 != 0 or len(args) < 2:
+        raise ValueError('Provide an even amount of arguments as option_context(pat, val, pat, val...).')
+    ops = tuple(zip(args[::2], args[1::2]))
+    try:
+        undo = tuple(((pat, get_option(pat)) for (pat, val) in ops))
+        for (pat, val) in ops:
+            set_option(pat, val)
+        yield
+    finally:
+        for (pat, val) in undo:
+            set_option(pat, val)
+
+def register_option(key: str, defval: object, doc: str='', validator: Callable[[object], Any] | None=None, cb: Callable[[str], Any] | None=None) -> None:
+    import keyword
+    import tokenize
+    key = key.lower()
+    if key in _registered_options:
+        raise OptionError(f"Option '{key}' has already been registered")
+    if key in _reserved_keys:
+        raise OptionError(f"Option '{key}' is a reserved key")
+    if validator:
+        validator(defval)
+    path = key.split('.')
+    for k in path:
+        if not re.match('^' + tokenize.Name + '$', k):
+            raise ValueError(f'{k} is not a valid identifier')
+        if keyword.iskeyword(k):
+            raise ValueError(f'{k} is a python keyword')
+    cursor = _global_config
+    msg = "Path prefix to option '{option}' is already an option"
+    for (i, p) in enumerate(path[:-1]):
+        if not isinstance(cursor, dict):
+            raise OptionError(msg.format(option='.'.join(path[:i])))
+        if p not in cursor:
+            cursor[p] = {}
+        cursor = cursor[p]
+    if not isinstance(cursor, dict):
+        raise OptionError(msg.format(option='.'.join(path[:-1])))
+    cursor[path[-1]] = defval
+    _registered_options[key] = RegisteredOption(key=key, defval=defval, doc=doc, validator=validator, cb=cb)
+
+def deprecate_option(key: str, msg: str | None=None, rkey: str | None=None, removal_ver: str | None=None) -> None:
+    key = key.lower()
+    if key in _deprecated_options:
+        raise OptionError(f"Option '{key}' has already been defined as deprecated.")
+    _deprecated_options[key] = DeprecatedOption(key, msg, rkey, removal_ver)
+
+def _select_options(pat: str) -> list[str]:
+    if pat in _registered_options:
+        return [pat]
+    keys = sorted(_registered_options.keys())
+    if pat == 'all':
+        return keys
+    return [k for k in keys if re.search(pat, k, re.I)]
+
+def _get_root(key: str) -> tuple[dict[str, Any], str]:
+    path = key.split('.')
+    cursor = _global_config
+    for p in path[:-1]:
+        cursor = cursor[p]
+    return (cursor, path[-1])
+
+def _get_deprecated_option(key: str):
+    try:
+        d = _deprecated_options[key]
+    except KeyError:
+        return None
+    else:
+        return d
+
+def _get_registered_option(key: str):
+    return _registered_options.get(key)
+
+def _translate_key(key: str) -> str:
+    d = _get_deprecated_option(key)
+    if d:
+        return d.rkey or key
+    else:
+        return key
+
+def _warn_if_deprecated(key: str) -> bool:
+    d = _get_deprecated_option(key)
+    if d:
+        if d.msg:
+            warnings.warn(d.msg, FutureWarning, stacklevel=find_stack_level())
+        else:
+            msg = f"'{key}' is deprecated"
+            if d.removal_ver:
+                msg += f' and will be removed in {d.removal_ver}'
+            if d.rkey:
+                msg += f", please use '{d.rkey}' instead."
+            else:
+                msg += ', please refrain from using it.'
+            warnings.warn(msg, FutureWarning, stacklevel=find_stack_level())
+        return True
+    return False
+
+def _build_option_description(k: str) -> str:
+    o = _get_registered_option(k)
+    d = _get_deprecated_option(k)
+    s = f'{k} '
+    if o.doc:
+        s += '\n'.join(o.doc.strip().split('\n'))
+    else:
+        s += 'No description available.'
+    if o:
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', FutureWarning)
+            warnings.simplefilter('ignore', DeprecationWarning)
+            s += f'\n    [default: {o.defval}] [currently: {get_option(k)}]'
+    if d:
+        rkey = d.rkey or ''
+        s += '\n    (Deprecated'
+        s += f', use `{rkey}` instead.'
+        s += ')'
+    return s
+
+@contextmanager
+def config_prefix(prefix: str) -> Generator[None, None, None]:
+    global register_option, get_option, set_option
+
+    def wrap(func: F) -> F:
+
+        def inner(key: str, *args, **kwds):
+            pkey = f'{prefix}.{key}'
+            return func(pkey, *args, **kwds)
+        return cast(F, inner)
+    _register_option = register_option
+    _get_option = get_option
+    _set_option = set_option
+    set_option = wrap(set_option)
+    get_option = wrap(get_option)
+    register_option = wrap(register_option)
+    try:
+        yield
+    finally:
+        set_option = _set_option
+        get_option = _get_option
+        register_option = _register_option
+
+def is_type_factory(_type: type[Any]) -> Callable[[Any], None]:
+
+    def inner(x) -> None:
+        if type(x) != _type:
+            raise ValueError(f"Value must have type '{_type}'")
+    return inner
+
+def is_instance_factory(_type: type | tuple[type, ...]) -> Callable[[Any], None]:
+    if isinstance(_type, tuple):
+        type_repr = '|'.join(map(str, _type))
+    else:
+        type_repr = f"'{_type}'"
+
+    def inner(x) -> None:
+        if not isinstance(x, _type):
+            raise ValueError(f'Value must be an instance of {type_repr}')
+    return inner
+
+def is_one_of_factory(legal_values: Sequence) -> Callable[[Any], None]:
+    callables = [c for c in legal_values if callable(c)]
+    legal_values = [c for c in legal_values if not callable(c)]
+
+    def inner(x) -> None:
+        if x not in legal_values:
+            if not any((c(x) for c in callables)):
+                uvals = [str(lval) for lval in legal_values]
+                pp_values = '|'.join(uvals)
+                msg = f'Value must be one of {pp_values}'
+                if len(callables):
+                    msg += ' or a callable'
+                raise ValueError(msg)
+    return inner
+
+def is_nonnegative_int(value: object) -> None:
+    if value is None:
+        return
+    elif isinstance(value, int):
+        if value >= 0:
+            return
+    msg = 'Value must be a nonnegative integer or None'
+    raise ValueError(msg)
+is_int = is_type_factory(int)
+is_bool = is_type_factory(bool)
+is_float = is_type_factory(float)
+is_str = is_type_factory(str)
+is_text = is_instance_factory((str, bytes))
+
+def is_callable(obj: object) -> bool:
+    if not callable(obj):
+        raise ValueError('Value must be a callable')
+    return True
+
+# File: pandas-main/pandas/_config/dates.py
+""""""
+from __future__ import annotations
+from pandas._config import config as cf
+pc_date_dayfirst_doc = '\n: boolean\n    When True, prints and parses dates with the day first, eg 20/01/2005\n'
+pc_date_yearfirst_doc = '\n: boolean\n    When True, prints and parses dates with the year first, eg 2005/01/20\n'
+with cf.config_prefix('display'):
+    cf.register_option('date_dayfirst', False, pc_date_dayfirst_doc, validator=cf.is_bool)
+    cf.register_option('date_yearfirst', False, pc_date_yearfirst_doc, validator=cf.is_bool)
+
+# File: pandas-main/pandas/_config/display.py
+""""""
+from __future__ import annotations
+import locale
+import sys
+from pandas._config import config as cf
+_initial_defencoding: str | None = None
+
+def detect_console_encoding() -> str:
+    global _initial_defencoding
+    encoding = None
+    try:
+        encoding = sys.stdout.encoding or sys.stdin.encoding
+    except (AttributeError, OSError):
+        pass
+    if not encoding or 'ascii' in encoding.lower():
+        try:
+            encoding = locale.getpreferredencoding()
+        except locale.Error:
+            pass
+    if not encoding or 'ascii' in encoding.lower():
+        encoding = sys.getdefaultencoding()
+    if not _initial_defencoding:
+        _initial_defencoding = sys.getdefaultencoding()
+    return encoding
+pc_encoding_doc = '\n: str/unicode\n    Defaults to the detected encoding of the console.\n    Specifies the encoding to be used for strings returned by to_string,\n    these are generally strings meant to be displayed on the console.\n'
+with cf.config_prefix('display'):
+    cf.register_option('encoding', detect_console_encoding(), pc_encoding_doc, validator=cf.is_text)
+
+# File: pandas-main/pandas/_config/localization.py
+""""""
+from __future__ import annotations
+from contextlib import contextmanager
+import locale
+import platform
+import re
+import subprocess
+from typing import TYPE_CHECKING, cast
+from pandas._config.config import options
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+@contextmanager
+def set_locale(new_locale: str | tuple[str, str], lc_var: int=locale.LC_ALL) -> Generator[str | tuple[str, str], None, None]:
+    current_locale = locale.setlocale(lc_var)
+    try:
+        locale.setlocale(lc_var, new_locale)
+        (normalized_code, normalized_encoding) = locale.getlocale()
+        if normalized_code is not None and normalized_encoding is not None:
+            yield f'{normalized_code}.{normalized_encoding}'
+        else:
+            yield new_locale
+    finally:
+        locale.setlocale(lc_var, current_locale)
+
+def can_set_locale(lc: str, lc_var: int=locale.LC_ALL) -> bool:
+    try:
+        with set_locale(lc, lc_var=lc_var):
+            pass
+    except (ValueError, locale.Error):
+        return False
+    else:
+        return True
+
+def _valid_locales(locales: list[str] | str, normalize: bool) -> list[str]:
+    return [loc for loc in (locale.normalize(loc.strip()) if normalize else loc.strip() for loc in locales) if can_set_locale(loc)]
+
+def get_locales(prefix: str | None=None, normalize: bool=True) -> list[str]:
+    if platform.system() in ('Linux', 'Darwin'):
+        raw_locales = subprocess.check_output(['locale', '-a'])
+    else:
+        return []
+    try:
+        split_raw_locales = raw_locales.split(b'\n')
+        out_locales = []
+        for x in split_raw_locales:
+            try:
+                out_locales.append(str(x, encoding=cast(str, options.display.encoding)))
+            except UnicodeError:
+                out_locales.append(str(x, encoding='windows-1252'))
+    except TypeError:
+        pass
+    if prefix is None:
+        return _valid_locales(out_locales, normalize)
+    pattern = re.compile(f'{prefix}.*')
+    found = pattern.findall('\n'.join(out_locales))
+    return _valid_locales(found, normalize)
+
+# File: pandas-main/pandas/_libs/__init__.py
+__all__ = ['NaT', 'NaTType', 'OutOfBoundsDatetime', 'Period', 'Timedelta', 'Timestamp', 'iNaT', 'Interval']
+import pandas._libs.pandas_parser
+import pandas._libs.pandas_datetime
+from pandas._libs.interval import Interval
+from pandas._libs.tslibs import NaT, NaTType, OutOfBoundsDatetime, Period, Timedelta, Timestamp, iNaT
+
+# File: pandas-main/pandas/_libs/tslibs/__init__.py
+__all__ = ['dtypes', 'localize_pydatetime', 'NaT', 'NaTType', 'iNaT', 'nat_strings', 'OutOfBoundsDatetime', 'OutOfBoundsTimedelta', 'IncompatibleFrequency', 'Period', 'Resolution', 'Timedelta', 'normalize_i8_timestamps', 'is_date_array_normalized', 'dt64arr_to_periodarr', 'delta_to_nanoseconds', 'ints_to_pydatetime', 'ints_to_pytimedelta', 'get_resolution', 'Timestamp', 'tz_convert_from_utc_single', 'tz_convert_from_utc', 'to_offset', 'Tick', 'BaseOffset', 'tz_compare', 'is_unitless', 'astype_overflowsafe', 'get_unit_from_dtype', 'periods_per_day', 'periods_per_second', 'guess_datetime_format', 'add_overflowsafe', 'get_supported_dtype', 'is_supported_dtype']
+from pandas._libs.tslibs import dtypes
+from pandas._libs.tslibs.conversion import localize_pydatetime
+from pandas._libs.tslibs.dtypes import Resolution, periods_per_day, periods_per_second
+from pandas._libs.tslibs.nattype import NaT, NaTType, iNaT, nat_strings
+from pandas._libs.tslibs.np_datetime import OutOfBoundsDatetime, OutOfBoundsTimedelta, add_overflowsafe, astype_overflowsafe, get_supported_dtype, is_supported_dtype, is_unitless, py_get_unit_from_dtype as get_unit_from_dtype
+from pandas._libs.tslibs.offsets import BaseOffset, Tick, to_offset
+from pandas._libs.tslibs.parsing import guess_datetime_format
+from pandas._libs.tslibs.period import IncompatibleFrequency, Period
+from pandas._libs.tslibs.timedeltas import Timedelta, delta_to_nanoseconds, ints_to_pytimedelta
+from pandas._libs.tslibs.timestamps import Timestamp
+from pandas._libs.tslibs.timezones import tz_compare
+from pandas._libs.tslibs.tzconversion import tz_convert_from_utc_single
+from pandas._libs.tslibs.vectorized import dt64arr_to_periodarr, get_resolution, ints_to_pydatetime, is_date_array_normalized, normalize_i8_timestamps, tz_convert_from_utc
+
+# File: pandas-main/pandas/_typing.py
+from __future__ import annotations
+from collections.abc import Callable, Hashable, Iterator, Mapping, MutableMapping, Sequence
+from datetime import date, datetime, timedelta, tzinfo
+from os import PathLike
+import sys
+from typing import TYPE_CHECKING, Any, Literal, Optional, Protocol, Type as type_t, TypeVar, Union, overload
+import numpy as np
+if TYPE_CHECKING:
+    import numpy.typing as npt
+    from pandas._libs import NaTType, Period, Timedelta, Timestamp
+    from pandas._libs.tslibs import BaseOffset
+    from pandas.core.dtypes.dtypes import ExtensionDtype
+    from pandas import DatetimeIndex, Interval, PeriodIndex, TimedeltaIndex
+    from pandas.arrays import DatetimeArray, TimedeltaArray
+    from pandas.core.arrays.base import ExtensionArray
+    from pandas.core.frame import DataFrame
+    from pandas.core.generic import NDFrame
+    from pandas.core.groupby.generic import DataFrameGroupBy, GroupBy, SeriesGroupBy
+    from pandas.core.indexes.base import Index
+    from pandas.core.internals import BlockManager, SingleBlockManager
+    from pandas.core.resample import Resampler
+    from pandas.core.series import Series
+    from pandas.core.window.rolling import BaseWindow
+    from pandas.io.formats.format import EngFormatter
+    from pandas.tseries.holiday import AbstractHolidayCalendar
+    ScalarLike_co = Union[int, float, complex, str, bytes, np.generic]
+    NumpyValueArrayLike = Union[ScalarLike_co, npt.ArrayLike]
+    NumpySorter = Optional[npt._ArrayLikeInt_co]
+    from typing import ParamSpec, SupportsIndex
+    from typing import Concatenate
+    from typing import TypeGuard
+    P = ParamSpec('P')
+    if sys.version_info >= (3, 11):
+        from typing import Self
+        from typing import Unpack
+    else:
+        from typing_extensions import Self
+        from typing_extensions import Unpack
+else:
+    npt: Any = None
+    ParamSpec: Any = None
+    Self: Any = None
+    TypeGuard: Any = None
+    Concatenate: Any = None
+    Unpack: Any = None
+HashableT = TypeVar('HashableT', bound=Hashable)
+HashableT2 = TypeVar('HashableT2', bound=Hashable)
+MutableMappingT = TypeVar('MutableMappingT', bound=MutableMapping)
+ArrayLike = Union['ExtensionArray', np.ndarray]
+ArrayLikeT = TypeVar('ArrayLikeT', 'ExtensionArray', np.ndarray)
+AnyArrayLike = Union[ArrayLike, 'Index', 'Series']
+TimeArrayLike = Union['DatetimeArray', 'TimedeltaArray']
+_T_co = TypeVar('_T_co', covariant=True)
+
+class SequenceNotStr(Protocol[_T_co]):
+
+    @overload
+    def __getitem__(self, index: SupportsIndex, /) -> _T_co:
+        ...
+
+    @overload
+    def __getitem__(self, index: slice, /) -> Sequence[_T_co]:
+        ...
+
+    def __contains__(self, value: object, /) -> bool:
+        ...
+
+    def __len__(self) -> int:
+        ...
+
+    def __iter__(self) -> Iterator[_T_co]:
+        ...
+
+    def index(self, value: Any, start: int=..., stop: int=..., /) -> int:
+        ...
+
+    def count(self, value: Any, /) -> int:
+        ...
+
+    def __reversed__(self) -> Iterator[_T_co]:
+        ...
+ListLike = Union[AnyArrayLike, SequenceNotStr, range]
+PythonScalar = Union[str, float, bool]
+DatetimeLikeScalar = Union['Period', 'Timestamp', 'Timedelta']
+PandasScalar = Union['Period', 'Timestamp', 'Timedelta', 'Interval']
+Scalar = Union[PythonScalar, PandasScalar, np.datetime64, np.timedelta64, date]
+IntStrT = TypeVar('IntStrT', bound=Union[int, str])
+TimestampConvertibleTypes = Union['Timestamp', date, np.datetime64, np.int64, float, str]
+TimestampNonexistent = Union[Literal['shift_forward', 'shift_backward', 'NaT', 'raise'], timedelta]
+TimedeltaConvertibleTypes = Union['Timedelta', timedelta, np.timedelta64, np.int64, float, str]
+Timezone = Union[str, tzinfo]
+ToTimestampHow = Literal['s', 'e', 'start', 'end']
+NDFrameT = TypeVar('NDFrameT', bound='NDFrame')
+IndexT = TypeVar('IndexT', bound='Index')
+FreqIndexT = TypeVar('FreqIndexT', 'DatetimeIndex', 'PeriodIndex', 'TimedeltaIndex')
+NumpyIndexT = TypeVar('NumpyIndexT', np.ndarray, 'Index')
+AxisInt = int
+Axis = Union[AxisInt, Literal['index', 'columns', 'rows']]
+IndexLabel = Union[Hashable, Sequence[Hashable]]
+Level = Hashable
+Shape = tuple[int, ...]
+Suffixes = Sequence[Optional[str]]
+Ordered = Optional[bool]
+JSONSerializable = Optional[Union[PythonScalar, list, dict]]
+Frequency = Union[str, 'BaseOffset']
+Axes = ListLike
+RandomState = Union[int, np.ndarray, np.random.Generator, np.random.BitGenerator, np.random.RandomState]
+NpDtype = Union[str, np.dtype, type_t[Union[str, complex, bool, object]]]
+Dtype = Union['ExtensionDtype', NpDtype]
+AstypeArg = Union['ExtensionDtype', 'npt.DTypeLike']
+DtypeArg = Union[Dtype, Mapping[Hashable, Dtype]]
+DtypeObj = Union[np.dtype, 'ExtensionDtype']
+ConvertersArg = dict[Hashable, Callable[[Dtype], Dtype]]
+ParseDatesArg = Union[bool, list[Hashable], list[list[Hashable]], dict[Hashable, list[Hashable]]]
+Renamer = Union[Mapping[Any, Hashable], Callable[[Any], Hashable]]
+T = TypeVar('T')
+FuncType = Callable[..., Any]
+F = TypeVar('F', bound=FuncType)
+TypeT = TypeVar('TypeT', bound=type)
+ValueKeyFunc = Optional[Callable[['Series'], Union['Series', AnyArrayLike]]]
+IndexKeyFunc = Optional[Callable[['Index'], Union['Index', AnyArrayLike]]]
+AggFuncTypeBase = Union[Callable, str]
+AggFuncTypeDict = MutableMapping[Hashable, Union[AggFuncTypeBase, list[AggFuncTypeBase]]]
+AggFuncType = Union[AggFuncTypeBase, list[AggFuncTypeBase], AggFuncTypeDict]
+AggObjType = Union['Series', 'DataFrame', 'GroupBy', 'SeriesGroupBy', 'DataFrameGroupBy', 'BaseWindow', 'Resampler']
+PythonFuncType = Callable[[Any], Any]
+AnyStr_co = TypeVar('AnyStr_co', str, bytes, covariant=True)
+AnyStr_contra = TypeVar('AnyStr_contra', str, bytes, contravariant=True)
+
+class BaseBuffer(Protocol):
+
+    @property
+    def mode(self) -> str:
+        ...
+
+    def seek(self, __offset: int, __whence: int=...) -> int:
+        ...
+
+    def seekable(self) -> bool:
+        ...
+
+    def tell(self) -> int:
+        ...
+
+class ReadBuffer(BaseBuffer, Protocol[AnyStr_co]):
+
+    def read(self, __n: int=...) -> AnyStr_co:
+        ...
+
+class WriteBuffer(BaseBuffer, Protocol[AnyStr_contra]):
+
+    def write(self, __b: AnyStr_contra) -> Any:
+        ...
+
+    def flush(self) -> Any:
+        ...
+
+class ReadPickleBuffer(ReadBuffer[bytes], Protocol):
+
+    def readline(self) -> bytes:
+        ...
+
+class WriteExcelBuffer(WriteBuffer[bytes], Protocol):
+
+    def truncate(self, size: int | None=..., /) -> int:
+        ...
+
+class ReadCsvBuffer(ReadBuffer[AnyStr_co], Protocol):
+
+    def __iter__(self) -> Iterator[AnyStr_co]:
+        ...
+
+    def fileno(self) -> int:
+        ...
+
+    def readline(self) -> AnyStr_co:
+        ...
+
+    @property
+    def closed(self) -> bool:
+        ...
+FilePath = Union[str, 'PathLike[str]']
+StorageOptions = Optional[dict[str, Any]]
+CompressionDict = dict[str, Any]
+CompressionOptions = Optional[Union[Literal['infer', 'gzip', 'bz2', 'zip', 'xz', 'zstd', 'tar'], CompressionDict]]
+FormattersType = Union[list[Callable], tuple[Callable, ...], Mapping[Union[str, int], Callable]]
+ColspaceType = Mapping[Hashable, Union[str, int]]
+FloatFormatType = Union[str, Callable, 'EngFormatter']
+ColspaceArgType = Union[str, int, Sequence[Union[str, int]], Mapping[Hashable, Union[str, int]]]
+FillnaOptions = Literal['backfill', 'bfill', 'ffill', 'pad']
+InterpolateOptions = Literal['linear', 'time', 'index', 'values', 'nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'barycentric', 'polynomial', 'krogh', 'piecewise_polynomial', 'spline', 'pchip', 'akima', 'cubicspline', 'from_derivatives']
+Manager = Union['BlockManager', 'SingleBlockManager']
+ScalarIndexer = Union[int, np.integer]
+SequenceIndexer = Union[slice, list[int], np.ndarray]
+PositionalIndexer = Union[ScalarIndexer, SequenceIndexer]
+PositionalIndexerTuple = tuple[PositionalIndexer, PositionalIndexer]
+PositionalIndexer2D = Union[PositionalIndexer, PositionalIndexerTuple]
+if TYPE_CHECKING:
+    TakeIndexer = Union[Sequence[int], Sequence[np.integer], npt.NDArray[np.integer]]
+else:
+    TakeIndexer = Any
+IgnoreRaise = Literal['ignore', 'raise']
+WindowingRankType = Literal['average', 'min', 'max']
+CSVEngine = Literal['c', 'python', 'pyarrow', 'python-fwf']
+JSONEngine = Literal['ujson', 'pyarrow']
+XMLParsers = Literal['lxml', 'etree']
+HTMLFlavors = Literal['lxml', 'html5lib', 'bs4']
+IntervalLeftRight = Literal['left', 'right']
+IntervalClosedType = Union[IntervalLeftRight, Literal['both', 'neither']]
+DatetimeNaTType = Union[datetime, 'NaTType']
+DateTimeErrorChoices = Literal['raise', 'coerce']
+SortKind = Literal['quicksort', 'mergesort', 'heapsort', 'stable']
+NaPosition = Literal['first', 'last']
+NsmallestNlargestKeep = Literal['first', 'last', 'all']
+QuantileInterpolation = Literal['linear', 'lower', 'higher', 'midpoint', 'nearest']
+PlottingOrientation = Literal['horizontal', 'vertical']
+AnyAll = Literal['any', 'all']
+MergeHow = Literal['left', 'right', 'inner', 'outer', 'cross']
+MergeValidate = Literal['one_to_one', '1:1', 'one_to_many', '1:m', 'many_to_one', 'm:1', 'many_to_many', 'm:m']
+JoinHow = Literal['left', 'right', 'inner', 'outer']
+JoinValidate = Literal['one_to_one', '1:1', 'one_to_many', '1:m', 'many_to_one', 'm:1', 'many_to_many', 'm:m']
+ReindexMethod = Union[FillnaOptions, Literal['nearest']]
+MatplotlibColor = Union[str, Sequence[float]]
+TimeGrouperOrigin = Union['Timestamp', Literal['epoch', 'start', 'start_day', 'end', 'end_day']]
+TimeAmbiguous = Union[Literal['infer', 'NaT', 'raise'], 'npt.NDArray[np.bool_]']
+TimeNonexistent = Union[Literal['shift_forward', 'shift_backward', 'NaT', 'raise'], timedelta]
+DropKeep = Literal['first', 'last', False]
+CorrelationMethod = Union[Literal['pearson', 'kendall', 'spearman'], Callable[[np.ndarray, np.ndarray], float]]
+AlignJoin = Literal['outer', 'inner', 'left', 'right']
+DtypeBackend = Literal['pyarrow', 'numpy_nullable']
+TimeUnit = Literal['s', 'ms', 'us', 'ns']
+OpenFileErrors = Literal['strict', 'ignore', 'replace', 'surrogateescape', 'xmlcharrefreplace', 'backslashreplace', 'namereplace']
+UpdateJoin = Literal['left']
+NaAction = Literal['ignore']
+FromDictOrient = Literal['columns', 'index', 'tight']
+ToStataByteorder = Literal['>', '<', 'little', 'big']
+ExcelWriterIfSheetExists = Literal['error', 'new', 'replace', 'overlay']
+ExcelWriterMergeCells = Union[bool, Literal['columns']]
+OffsetCalendar = Union[np.busdaycalendar, 'AbstractHolidayCalendar']
+UsecolsArgType = Union[SequenceNotStr[Hashable], range, AnyArrayLike, Callable[[HashableT], bool], None]
+SequenceT = TypeVar('SequenceT', bound=Sequence[Hashable])
+SliceType = Optional[Hashable]
+
+# File: pandas-main/pandas/_version.py
+""""""
+from collections.abc import Callable
+import errno
+import functools
+import os
+import re
+import subprocess
+import sys
+
+def get_keywords():
+    git_refnames = ' (HEAD -> main)'
+    git_full = '3e8ac12d1dacc2308b2f4c2869fa7bc2079bd323'
+    git_date = '2024-09-15 22:00:26 +0200'
+    keywords = {'refnames': git_refnames, 'full': git_full, 'date': git_date}
+    return keywords
+
+class VersioneerConfig:
+
+def get_config():
+    cfg = VersioneerConfig()
+    cfg.VCS = 'git'
+    cfg.style = 'pep440'
+    cfg.tag_prefix = 'v'
+    cfg.parentdir_prefix = 'pandas-'
+    cfg.versionfile_source = 'pandas/_version.py'
+    cfg.verbose = False
+    return cfg
+
+class NotThisMethod(Exception):
+LONG_VERSION_PY: dict[str, str] = {}
+HANDLERS: dict[str, dict[str, Callable]] = {}
+
+def register_vcs_handler(vcs, method):
+
+    def decorate(f):
+        if vcs not in HANDLERS:
+            HANDLERS[vcs] = {}
+        HANDLERS[vcs][method] = f
+        return f
+    return decorate
+
+def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None):
+    assert isinstance(commands, list)
+    process = None
+    popen_kwargs = {}
+    if sys.platform == 'win32':
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        popen_kwargs['startupinfo'] = startupinfo
+    for command in commands:
+        dispcmd = str([command] + args)
+        try:
+            process = subprocess.Popen([command] + args, cwd=cwd, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE if hide_stderr else None, **popen_kwargs)
+            break
+        except OSError:
+            e = sys.exc_info()[1]
+            if e.errno == errno.ENOENT:
+                continue
+            if verbose:
+                print(f'unable to run {dispcmd}')
+                print(e)
+            return (None, None)
+    else:
+        if verbose:
+            print(f'unable to find command, tried {commands}')
+        return (None, None)
+    stdout = process.communicate()[0].strip().decode()
+    if process.returncode != 0:
+        if verbose:
+            print(f'unable to run {dispcmd} (error)')
+            print(f'stdout was {stdout}')
+        return (None, process.returncode)
+    return (stdout, process.returncode)
+
+def versions_from_parentdir(parentdir_prefix, root, verbose):
+    rootdirs = []
+    for _ in range(3):
+        dirname = os.path.basename(root)
+        if dirname.startswith(parentdir_prefix):
+            return {'version': dirname[len(parentdir_prefix):], 'full-revisionid': None, 'dirty': False, 'error': None, 'date': None}
+        rootdirs.append(root)
+        root = os.path.dirname(root)
+    if verbose:
+        print(f'Tried directories {rootdirs!s}             but none started with prefix {parentdir_prefix}')
+    raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
+
+@register_vcs_handler('git', 'get_keywords')
+def git_get_keywords(versionfile_abs):
+    keywords = {}
+    try:
+        with open(versionfile_abs, encoding='utf-8') as fobj:
+            for line in fobj:
+                if line.strip().startswith('git_refnames ='):
+                    mo = re.search('=\\s*"(.*)"', line)
+                    if mo:
+                        keywords['refnames'] = mo.group(1)
+                if line.strip().startswith('git_full ='):
+                    mo = re.search('=\\s*"(.*)"', line)
+                    if mo:
+                        keywords['full'] = mo.group(1)
+                if line.strip().startswith('git_date ='):
+                    mo = re.search('=\\s*"(.*)"', line)
+                    if mo:
+                        keywords['date'] = mo.group(1)
+    except OSError:
+        pass
+    return keywords
+
+@register_vcs_handler('git', 'keywords')
+def git_versions_from_keywords(keywords, tag_prefix, verbose):
+    if 'refnames' not in keywords:
+        raise NotThisMethod('Short version file found')
+    date = keywords.get('date')
+    if date is not None:
+        date = date.splitlines()[-1]
+        date = date.strip().replace(' ', 'T', 1).replace(' ', '', 1)
+    refnames = keywords['refnames'].strip()
+    if refnames.startswith('$Format'):
+        if verbose:
+            print('keywords are unexpanded, not using')
+        raise NotThisMethod('unexpanded keywords, not a git-archive tarball')
+    refs = {r.strip() for r in refnames.strip('()').split(',')}
+    TAG = 'tag: '
+    tags = {r[len(TAG):] for r in refs if r.startswith(TAG)}
+    if not tags:
+        tags = {r for r in refs if re.search('\\d', r)}
+        if verbose:
+            print(f"discarding '{','.join(refs - tags)}', no digits")
+    if verbose:
+        print(f"likely tags: {','.join(sorted(tags))}")
+    for ref in sorted(tags):
+        if ref.startswith(tag_prefix):
+            r = ref[len(tag_prefix):]
+            if not re.match('\\d', r):
+                continue
+            if verbose:
+                print(f'picking {r}')
+            return {'version': r, 'full-revisionid': keywords['full'].strip(), 'dirty': False, 'error': None, 'date': date}
+    if verbose:
+        print('no suitable tags, using unknown + full revision id')
+    return {'version': '0+unknown', 'full-revisionid': keywords['full'].strip(), 'dirty': False, 'error': 'no suitable tags', 'date': None}
+
+@register_vcs_handler('git', 'pieces_from_vcs')
+def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
+    GITS = ['git']
+    if sys.platform == 'win32':
+        GITS = ['git.cmd', 'git.exe']
+    env = os.environ.copy()
+    env.pop('GIT_DIR', None)
+    runner = functools.partial(runner, env=env)
+    (_, rc) = runner(GITS, ['rev-parse', '--git-dir'], cwd=root, hide_stderr=not verbose)
+    if rc != 0:
+        if verbose:
+            print(f'Directory {root} not under git control')
+        raise NotThisMethod("'git rev-parse --git-dir' returned error")
+    (describe_out, rc) = runner(GITS, ['describe', '--tags', '--dirty', '--always', '--long', '--match', f'{tag_prefix}[[:digit:]]*'], cwd=root)
+    if describe_out is None:
+        raise NotThisMethod("'git describe' failed")
+    describe_out = describe_out.strip()
+    (full_out, rc) = runner(GITS, ['rev-parse', 'HEAD'], cwd=root)
+    if full_out is None:
+        raise NotThisMethod("'git rev-parse' failed")
+    full_out = full_out.strip()
+    pieces = {}
+    pieces['long'] = full_out
+    pieces['short'] = full_out[:7]
+    pieces['error'] = None
+    (branch_name, rc) = runner(GITS, ['rev-parse', '--abbrev-ref', 'HEAD'], cwd=root)
+    if rc != 0 or branch_name is None:
+        raise NotThisMethod("'git rev-parse --abbrev-ref' returned error")
+    branch_name = branch_name.strip()
+    if branch_name == 'HEAD':
+        (branches, rc) = runner(GITS, ['branch', '--contains'], cwd=root)
+        if rc != 0 or branches is None:
+            raise NotThisMethod("'git branch --contains' returned error")
+        branches = branches.split('\n')
+        if '(' in branches[0]:
+            branches.pop(0)
+        branches = [branch[2:] for branch in branches]
+        if 'master' in branches:
+            branch_name = 'master'
+        elif not branches:
+            branch_name = None
+        else:
+            branch_name = branches[0]
+    pieces['branch'] = branch_name
+    git_describe = describe_out
+    dirty = git_describe.endswith('-dirty')
+    pieces['dirty'] = dirty
+    if dirty:
+        git_describe = git_describe[:git_describe.rindex('-dirty')]
+    if '-' in git_describe:
+        mo = re.search('^(.+)-(\\d+)-g([0-9a-f]+)$', git_describe)
+        if not mo:
+            pieces['error'] = f"unable to parse git-describe output: '{describe_out}'"
+            return pieces
+        full_tag = mo.group(1)
+        if not full_tag.startswith(tag_prefix):
+            if verbose:
+                fmt = "tag '%s' doesn't start with prefix '%s'"
+                print(fmt % (full_tag, tag_prefix))
+            pieces['error'] = f"tag '{full_tag}' doesn't start with prefix '{tag_prefix}'"
+            return pieces
+        pieces['closest-tag'] = full_tag[len(tag_prefix):]
+        pieces['distance'] = int(mo.group(2))
+        pieces['short'] = mo.group(3)
+    else:
+        pieces['closest-tag'] = None
+        (out, rc) = runner(GITS, ['rev-list', 'HEAD', '--left-right'], cwd=root)
+        pieces['distance'] = len(out.split())
+    date = runner(GITS, ['show', '-s', '--format=%ci', 'HEAD'], cwd=root)[0].strip()
+    date = date.splitlines()[-1]
+    pieces['date'] = date.strip().replace(' ', 'T', 1).replace(' ', '', 1)
+    return pieces
+
+def plus_or_dot(pieces) -> str:
+    if '+' in pieces.get('closest-tag', ''):
+        return '.'
+    return '+'
+
+def render_pep440(pieces):
+    if pieces['closest-tag']:
+        rendered = pieces['closest-tag']
+        if pieces['distance'] or pieces['dirty']:
+            rendered += plus_or_dot(pieces)
+            rendered += f"{pieces['distance']}.g{pieces['short']}"
+            if pieces['dirty']:
+                rendered += '.dirty'
+    else:
+        rendered = f"0+untagged.{pieces['distance']}.g{pieces['short']}"
+        if pieces['dirty']:
+            rendered += '.dirty'
+    return rendered
+
+def render_pep440_branch(pieces):
+    if pieces['closest-tag']:
+        rendered = pieces['closest-tag']
+        if pieces['distance'] or pieces['dirty']:
+            if pieces['branch'] != 'master':
+                rendered += '.dev0'
+            rendered += plus_or_dot(pieces)
+            rendered += f"{pieces['distance']}.g{pieces['short']}"
+            if pieces['dirty']:
+                rendered += '.dirty'
+    else:
+        rendered = '0'
+        if pieces['branch'] != 'master':
+            rendered += '.dev0'
+        rendered += f"+untagged.{pieces['distance']}.g{pieces['short']}"
+        if pieces['dirty']:
+            rendered += '.dirty'
+    return rendered
+
+def pep440_split_post(ver):
+    vc = str.split(ver, '.post')
+    return (vc[0], int(vc[1] or 0) if len(vc) == 2 else None)
+
+def render_pep440_pre(pieces):
+    if pieces['closest-tag']:
+        if pieces['distance']:
+            (tag_version, post_version) = pep440_split_post(pieces['closest-tag'])
+            rendered = tag_version
+            if post_version is not None:
+                rendered += f".post{post_version + 1}.dev{pieces['distance']}"
+            else:
+                rendered += f".post0.dev{pieces['distance']}"
+        else:
+            rendered = pieces['closest-tag']
+    else:
+        rendered = f"0.post0.dev{pieces['distance']}"
+    return rendered
+
+def render_pep440_post(pieces):
+    if pieces['closest-tag']:
+        rendered = pieces['closest-tag']
+        if pieces['distance'] or pieces['dirty']:
+            rendered += f".post{pieces['distance']}"
+            if pieces['dirty']:
+                rendered += '.dev0'
+            rendered += plus_or_dot(pieces)
+            rendered += f"g{pieces['short']}"
+    else:
+        rendered = f"0.post{pieces['distance']}"
+        if pieces['dirty']:
+            rendered += '.dev0'
+        rendered += f"+g{pieces['short']}"
+    return rendered
+
+def render_pep440_post_branch(pieces):
+    if pieces['closest-tag']:
+        rendered = pieces['closest-tag']
+        if pieces['distance'] or pieces['dirty']:
+            rendered += f".post{pieces['distance']}"
+            if pieces['branch'] != 'master':
+                rendered += '.dev0'
+            rendered += plus_or_dot(pieces)
+            rendered += f"g{pieces['short']}"
+            if pieces['dirty']:
+                rendered += '.dirty'
+    else:
+        rendered = f"0.post{pieces['distance']}"
+        if pieces['branch'] != 'master':
+            rendered += '.dev0'
+        rendered += f"+g{pieces['short']}"
+        if pieces['dirty']:
+            rendered += '.dirty'
+    return rendered
+
+def render_pep440_old(pieces):
+    if pieces['closest-tag']:
+        rendered = pieces['closest-tag']
+        if pieces['distance'] or pieces['dirty']:
+            rendered += f"0.post{pieces['distance']}"
+            if pieces['dirty']:
+                rendered += '.dev0'
+    else:
+        rendered = f"0.post{pieces['distance']}"
+        if pieces['dirty']:
+            rendered += '.dev0'
+    return rendered
+
+def render_git_describe(pieces):
+    if pieces['closest-tag']:
+        rendered = pieces['closest-tag']
+        if pieces['distance']:
+            rendered += f"-{pieces['distance']}-g{pieces['short']}"
+    else:
+        rendered = pieces['short']
+    if pieces['dirty']:
+        rendered += '-dirty'
+    return rendered
+
+def render_git_describe_long(pieces):
+    if pieces['closest-tag']:
+        rendered = pieces['closest-tag']
+        rendered += f"-{pieces['distance']}-g{pieces['short']}"
+    else:
+        rendered = pieces['short']
+    if pieces['dirty']:
+        rendered += '-dirty'
+    return rendered
+
+def render(pieces, style):
+    if pieces['error']:
+        return {'version': 'unknown', 'full-revisionid': pieces.get('long'), 'dirty': None, 'error': pieces['error'], 'date': None}
+    if not style or style == 'default':
+        style = 'pep440'
+    if style == 'pep440':
+        rendered = render_pep440(pieces)
+    elif style == 'pep440-branch':
+        rendered = render_pep440_branch(pieces)
+    elif style == 'pep440-pre':
+        rendered = render_pep440_pre(pieces)
+    elif style == 'pep440-post':
+        rendered = render_pep440_post(pieces)
+    elif style == 'pep440-post-branch':
+        rendered = render_pep440_post_branch(pieces)
+    elif style == 'pep440-old':
+        rendered = render_pep440_old(pieces)
+    elif style == 'git-describe':
+        rendered = render_git_describe(pieces)
+    elif style == 'git-describe-long':
+        rendered = render_git_describe_long(pieces)
+    else:
+        raise ValueError(f"unknown style '{style}'")
+    return {'version': rendered, 'full-revisionid': pieces['long'], 'dirty': pieces['dirty'], 'error': None, 'date': pieces.get('date')}
+
+def get_versions():
+    cfg = get_config()
+    verbose = cfg.verbose
+    try:
+        return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, verbose)
+    except NotThisMethod:
+        pass
+    try:
+        root = os.path.realpath(__file__)
+        for _ in cfg.versionfile_source.split('/'):
+            root = os.path.dirname(root)
+    except NameError:
+        return {'version': '0+unknown', 'full-revisionid': None, 'dirty': None, 'error': 'unable to find root of source tree', 'date': None}
+    try:
+        pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)
+        return render(pieces, cfg.style)
+    except NotThisMethod:
+        pass
+    try:
+        if cfg.parentdir_prefix:
+            return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)
+    except NotThisMethod:
+        pass
+    return {'version': '0+unknown', 'full-revisionid': None, 'dirty': None, 'error': 'unable to compute version', 'date': None}
+
+# File: pandas-main/pandas/api/__init__.py
+""""""
+from pandas.api import extensions, indexers, interchange, types, typing
+__all__ = ['interchange', 'extensions', 'indexers', 'types', 'typing']
+
+# File: pandas-main/pandas/api/extensions/__init__.py
+""""""
+from pandas._libs.lib import no_default
+from pandas.core.dtypes.base import ExtensionDtype, register_extension_dtype
+from pandas.core.accessor import register_dataframe_accessor, register_index_accessor, register_series_accessor
+from pandas.core.algorithms import take
+from pandas.core.arrays import ExtensionArray, ExtensionScalarOpsMixin
+__all__ = ['no_default', 'ExtensionDtype', 'register_extension_dtype', 'register_dataframe_accessor', 'register_index_accessor', 'register_series_accessor', 'take', 'ExtensionArray', 'ExtensionScalarOpsMixin']
+
+# File: pandas-main/pandas/api/indexers/__init__.py
+""""""
+from pandas.core.indexers import check_array_indexer
+from pandas.core.indexers.objects import BaseIndexer, FixedForwardWindowIndexer, VariableOffsetWindowIndexer
+__all__ = ['check_array_indexer', 'BaseIndexer', 'FixedForwardWindowIndexer', 'VariableOffsetWindowIndexer']
+
+# File: pandas-main/pandas/api/internals.py
+import numpy as np
+from pandas._typing import ArrayLike
+from pandas import DataFrame, Index
+from pandas.core.internals.api import _make_block
+from pandas.core.internals.managers import BlockManager as _BlockManager
+
+def create_dataframe_from_blocks(blocks: list[tuple[ArrayLike, np.ndarray]], index: Index, columns: Index) -> DataFrame:
+    block_objs = [_make_block(*block) for block in blocks]
+    axes = [columns, index]
+    mgr = _BlockManager(block_objs, axes)
+    return DataFrame._from_mgr(mgr, mgr.axes)
+
+# File: pandas-main/pandas/api/types/__init__.py
+""""""
+from pandas._libs.lib import infer_dtype
+from pandas.core.dtypes.api import *
+from pandas.core.dtypes.concat import union_categoricals
+from pandas.core.dtypes.dtypes import CategoricalDtype, DatetimeTZDtype, IntervalDtype, PeriodDtype
+__all__ = ['infer_dtype', 'union_categoricals', 'CategoricalDtype', 'DatetimeTZDtype', 'IntervalDtype', 'PeriodDtype']
+
+# File: pandas-main/pandas/api/typing/__init__.py
+""""""
+from pandas._libs import NaTType
+from pandas._libs.missing import NAType
+from pandas.core.groupby import DataFrameGroupBy, SeriesGroupBy
+from pandas.core.indexes.frozen import FrozenList
+from pandas.core.resample import DatetimeIndexResamplerGroupby, PeriodIndexResamplerGroupby, Resampler, TimedeltaIndexResamplerGroupby, TimeGrouper
+from pandas.core.window import Expanding, ExpandingGroupby, ExponentialMovingWindow, ExponentialMovingWindowGroupby, Rolling, RollingGroupby, Window
+from pandas.io.json._json import JsonReader
+from pandas.io.sas.sasreader import SASReader
+from pandas.io.stata import StataReader
+__all__ = ['DataFrameGroupBy', 'DatetimeIndexResamplerGroupby', 'Expanding', 'ExpandingGroupby', 'ExponentialMovingWindow', 'ExponentialMovingWindowGroupby', 'FrozenList', 'JsonReader', 'NaTType', 'NAType', 'PeriodIndexResamplerGroupby', 'Resampler', 'Rolling', 'RollingGroupby', 'SeriesGroupBy', 'StataReader', 'SASReader', 'TimedeltaIndexResamplerGroupby', 'TimeGrouper', 'Window']
+
+# File: pandas-main/pandas/arrays/__init__.py
+""""""
+from pandas.core.arrays import ArrowExtensionArray, ArrowStringArray, BooleanArray, Categorical, DatetimeArray, FloatingArray, IntegerArray, IntervalArray, NumpyExtensionArray, PeriodArray, SparseArray, StringArray, TimedeltaArray
+__all__ = ['ArrowExtensionArray', 'ArrowStringArray', 'BooleanArray', 'Categorical', 'DatetimeArray', 'FloatingArray', 'IntegerArray', 'IntervalArray', 'NumpyExtensionArray', 'PeriodArray', 'SparseArray', 'StringArray', 'TimedeltaArray']
+
+# File: pandas-main/pandas/compat/__init__.py
+""""""
+from __future__ import annotations
+import os
+import platform
+import sys
+from typing import TYPE_CHECKING
+from pandas.compat._constants import IS64, ISMUSL, PY311, PY312, PYPY, WASM
+from pandas.compat.numpy import is_numpy_dev
+from pandas.compat.pyarrow import HAS_PYARROW, pa_version_under10p1, pa_version_under11p0, pa_version_under13p0, pa_version_under14p0, pa_version_under14p1, pa_version_under16p0, pa_version_under17p0, pa_version_under18p0
+if TYPE_CHECKING:
+    from pandas._typing import F
+
+def set_function_name(f: F, name: str, cls: type) -> F:
+    f.__name__ = name
+    f.__qualname__ = f'{cls.__name__}.{name}'
+    f.__module__ = cls.__module__
+    return f
+
+def is_platform_little_endian() -> bool:
+    return sys.byteorder == 'little'
+
+def is_platform_windows() -> bool:
+    return sys.platform in ['win32', 'cygwin']
+
+def is_platform_linux() -> bool:
+    return sys.platform == 'linux'
+
+def is_platform_mac() -> bool:
+    return sys.platform == 'darwin'
+
+def is_platform_arm() -> bool:
+    return platform.machine() in ('arm64', 'aarch64') or platform.machine().startswith('armv')
+
+def is_platform_power() -> bool:
+    return platform.machine() in ('ppc64', 'ppc64le')
+
+def is_platform_riscv64() -> bool:
+    return platform.machine() == 'riscv64'
+
+def is_ci_environment() -> bool:
+    return os.environ.get('PANDAS_CI', '0') == '1'
+__all__ = ['is_numpy_dev', 'pa_version_under10p1', 'pa_version_under11p0', 'pa_version_under13p0', 'pa_version_under14p0', 'pa_version_under14p1', 'pa_version_under16p0', 'pa_version_under17p0', 'pa_version_under18p0', 'HAS_PYARROW', 'IS64', 'ISMUSL', 'PY311', 'PY312', 'PYPY', 'WASM']
+
+# File: pandas-main/pandas/compat/_constants.py
+""""""
+from __future__ import annotations
+import platform
+import sys
+import sysconfig
+IS64 = sys.maxsize > 2 ** 32
+PY311 = sys.version_info >= (3, 11)
+PY312 = sys.version_info >= (3, 12)
+PYPY = platform.python_implementation() == 'PyPy'
+WASM = sys.platform == 'emscripten' or platform.machine() in ['wasm32', 'wasm64']
+ISMUSL = 'musl' in (sysconfig.get_config_var('HOST_GNU_TYPE') or '')
+REF_COUNT = 2 if PY311 else 3
+__all__ = ['IS64', 'ISMUSL', 'PY311', 'PY312', 'PYPY', 'WASM']
+
+# File: pandas-main/pandas/compat/_optional.py
+from __future__ import annotations
+import importlib
+import sys
+from typing import TYPE_CHECKING, Literal, overload
+import warnings
+from pandas.util._exceptions import find_stack_level
+from pandas.util.version import Version
+if TYPE_CHECKING:
+    import types
+VERSIONS = {'adbc-driver-postgresql': '0.10.0', 'adbc-driver-sqlite': '0.8.0', 'bs4': '4.11.2', 'blosc': '1.21.3', 'bottleneck': '1.3.6', 'fastparquet': '2023.10.0', 'fsspec': '2022.11.0', 'html5lib': '1.1', 'hypothesis': '6.84.0', 'gcsfs': '2022.11.0', 'jinja2': '3.1.2', 'lxml.etree': '4.9.2', 'matplotlib': '3.6.3', 'numba': '0.56.4', 'numexpr': '2.8.4', 'odfpy': '1.4.1', 'openpyxl': '3.1.0', 'psycopg2': '2.9.6', 'pymysql': '1.0.2', 'pyarrow': '10.0.1', 'pyreadstat': '1.2.0', 'pytest': '7.3.2', 'python-calamine': '0.1.7', 'pytz': '2023.4', 'pyxlsb': '1.0.10', 's3fs': '2022.11.0', 'scipy': '1.10.0', 'sqlalchemy': '2.0.0', 'tables': '3.8.0', 'tabulate': '0.9.0', 'xarray': '2022.12.0', 'xlrd': '2.0.1', 'xlsxwriter': '3.0.5', 'zstandard': '0.19.0', 'tzdata': '2022.7', 'qtpy': '2.3.0', 'pyqt5': '5.15.9'}
+INSTALL_MAPPING = {'bs4': 'beautifulsoup4', 'bottleneck': 'Bottleneck', 'jinja2': 'Jinja2', 'lxml.etree': 'lxml', 'odf': 'odfpy', 'python_calamine': 'python-calamine', 'sqlalchemy': 'SQLAlchemy', 'tables': 'pytables'}
+
+def get_version(module: types.ModuleType) -> str:
+    version = getattr(module, '__version__', None)
+    if version is None:
+        raise ImportError(f"Can't determine version for {module.__name__}")
+    if module.__name__ == 'psycopg2':
+        version = version.split()[0]
+    return version
+
+@overload
+def import_optional_dependency(name: str, extra: str=..., min_version: str | None=..., *, errors: Literal['raise']=...) -> types.ModuleType:
+    ...
+
+@overload
+def import_optional_dependency(name: str, extra: str=..., min_version: str | None=..., *, errors: Literal['warn', 'ignore']) -> types.ModuleType | None:
+    ...
+
+def import_optional_dependency(name: str, extra: str='', min_version: str | None=None, *, errors: Literal['raise', 'warn', 'ignore']='raise') -> types.ModuleType | None:
+    assert errors in {'warn', 'raise', 'ignore'}
+    package_name = INSTALL_MAPPING.get(name)
+    install_name = package_name if package_name is not None else name
+    msg = f"Missing optional dependency '{install_name}'. {extra} Use pip or conda to install {install_name}."
+    try:
+        module = importlib.import_module(name)
+    except ImportError as err:
+        if errors == 'raise':
+            raise ImportError(msg) from err
+        return None
+    parent = name.split('.')[0]
+    if parent != name:
+        install_name = parent
+        module_to_get = sys.modules[install_name]
+    else:
+        module_to_get = module
+    minimum_version = min_version if min_version is not None else VERSIONS.get(parent)
+    if minimum_version:
+        version = get_version(module_to_get)
+        if version and Version(version) < Version(minimum_version):
+            msg = f"Pandas requires version '{minimum_version}' or newer of '{parent}' (version '{version}' currently installed)."
+            if errors == 'warn':
+                warnings.warn(msg, UserWarning, stacklevel=find_stack_level())
+                return None
+            elif errors == 'raise':
+                raise ImportError(msg)
+            else:
+                return None
+    return module
+
+# File: pandas-main/pandas/compat/numpy/__init__.py
+""""""
+import warnings
+import numpy as np
+from pandas.util.version import Version
+_np_version = np.__version__
+_nlv = Version(_np_version)
+np_version_gte1p24 = _nlv >= Version('1.24')
+np_version_gte1p24p3 = _nlv >= Version('1.24.3')
+np_version_gte1p25 = _nlv >= Version('1.25')
+np_version_gt2 = _nlv >= Version('2.0.0')
+is_numpy_dev = _nlv.dev is not None
+_min_numpy_ver = '1.23.5'
+if _nlv < Version(_min_numpy_ver):
+    raise ImportError(f'this version of pandas is incompatible with numpy < {_min_numpy_ver}\nyour numpy version is {_np_version}.\nPlease upgrade numpy to >= {_min_numpy_ver} to use this pandas version')
+np_long: type
+np_ulong: type
+if np_version_gt2:
+    try:
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', '.*In the future `np\\.long` will be defined as.*', FutureWarning)
+            np_long = np.long
+            np_ulong = np.ulong
+    except AttributeError:
+        np_long = np.int_
+        np_ulong = np.uint
+else:
+    np_long = np.int_
+    np_ulong = np.uint
+__all__ = ['np', '_np_version', 'is_numpy_dev']
+
+# File: pandas-main/pandas/compat/numpy/function.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, TypeVar, cast, overload
+import numpy as np
+from numpy import ndarray
+from pandas._libs.lib import is_bool, is_integer
+from pandas.errors import UnsupportedFunctionCall
+from pandas.util._validators import validate_args, validate_args_and_kwargs, validate_kwargs
+if TYPE_CHECKING:
+    from pandas._typing import Axis, AxisInt
+    AxisNoneT = TypeVar('AxisNoneT', Axis, None)
+
+class CompatValidator:
+
+    def __init__(self, defaults, fname=None, method: str | None=None, max_fname_arg_count=None) -> None:
+        self.fname = fname
+        self.method = method
+        self.defaults = defaults
+        self.max_fname_arg_count = max_fname_arg_count
+
+    def __call__(self, args, kwargs, fname=None, max_fname_arg_count=None, method: str | None=None) -> None:
+        if not args and (not kwargs):
+            return None
+        fname = self.fname if fname is None else fname
+        max_fname_arg_count = self.max_fname_arg_count if max_fname_arg_count is None else max_fname_arg_count
+        method = self.method if method is None else method
+        if method == 'args':
+            validate_args(fname, args, max_fname_arg_count, self.defaults)
+        elif method == 'kwargs':
+            validate_kwargs(fname, kwargs, self.defaults)
+        elif method == 'both':
+            validate_args_and_kwargs(fname, args, kwargs, max_fname_arg_count, self.defaults)
+        else:
+            raise ValueError(f"invalid validation method '{method}'")
+ARGMINMAX_DEFAULTS = {'out': None}
+validate_argmin = CompatValidator(ARGMINMAX_DEFAULTS, fname='argmin', method='both', max_fname_arg_count=1)
+validate_argmax = CompatValidator(ARGMINMAX_DEFAULTS, fname='argmax', method='both', max_fname_arg_count=1)
+
+def process_skipna(skipna: bool | ndarray | None, args) -> tuple[bool, Any]:
+    if isinstance(skipna, ndarray) or skipna is None:
+        args = (skipna,) + args
+        skipna = True
+    return (skipna, args)
+
+def validate_argmin_with_skipna(skipna: bool | ndarray | None, args, kwargs) -> bool:
+    (skipna, args) = process_skipna(skipna, args)
+    validate_argmin(args, kwargs)
+    return skipna
+
+def validate_argmax_with_skipna(skipna: bool | ndarray | None, args, kwargs) -> bool:
+    (skipna, args) = process_skipna(skipna, args)
+    validate_argmax(args, kwargs)
+    return skipna
+ARGSORT_DEFAULTS: dict[str, int | str | None] = {}
+ARGSORT_DEFAULTS['axis'] = -1
+ARGSORT_DEFAULTS['kind'] = 'quicksort'
+ARGSORT_DEFAULTS['order'] = None
+ARGSORT_DEFAULTS['kind'] = None
+ARGSORT_DEFAULTS['stable'] = None
+validate_argsort = CompatValidator(ARGSORT_DEFAULTS, fname='argsort', max_fname_arg_count=0, method='both')
+ARGSORT_DEFAULTS_KIND: dict[str, int | None] = {}
+ARGSORT_DEFAULTS_KIND['axis'] = -1
+ARGSORT_DEFAULTS_KIND['order'] = None
+ARGSORT_DEFAULTS_KIND['stable'] = None
+validate_argsort_kind = CompatValidator(ARGSORT_DEFAULTS_KIND, fname='argsort', max_fname_arg_count=0, method='both')
+
+def validate_argsort_with_ascending(ascending: bool | int | None, args, kwargs) -> bool:
+    if is_integer(ascending) or ascending is None:
+        args = (ascending,) + args
+        ascending = True
+    validate_argsort_kind(args, kwargs, max_fname_arg_count=3)
+    ascending = cast(bool, ascending)
+    return ascending
+CLIP_DEFAULTS: dict[str, Any] = {'out': None}
+validate_clip = CompatValidator(CLIP_DEFAULTS, fname='clip', method='both', max_fname_arg_count=3)
+
+@overload
+def validate_clip_with_axis(axis: ndarray, args, kwargs) -> None:
+    ...
+
+@overload
+def validate_clip_with_axis(axis: AxisNoneT, args, kwargs) -> AxisNoneT:
+    ...
+
+def validate_clip_with_axis(axis: ndarray | AxisNoneT, args, kwargs) -> AxisNoneT | None:
+    if isinstance(axis, ndarray):
+        args = (axis,) + args
+        axis = None
+    validate_clip(args, kwargs)
+    return axis
+CUM_FUNC_DEFAULTS: dict[str, Any] = {}
+CUM_FUNC_DEFAULTS['dtype'] = None
+CUM_FUNC_DEFAULTS['out'] = None
+validate_cum_func = CompatValidator(CUM_FUNC_DEFAULTS, method='both', max_fname_arg_count=1)
+validate_cumsum = CompatValidator(CUM_FUNC_DEFAULTS, fname='cumsum', method='both', max_fname_arg_count=1)
+
+def validate_cum_func_with_skipna(skipna: bool, args, kwargs, name) -> bool:
+    if not is_bool(skipna):
+        args = (skipna,) + args
+        skipna = True
+    elif isinstance(skipna, np.bool_):
+        skipna = bool(skipna)
+    validate_cum_func(args, kwargs, fname=name)
+    return skipna
+ALLANY_DEFAULTS: dict[str, bool | None] = {}
+ALLANY_DEFAULTS['dtype'] = None
+ALLANY_DEFAULTS['out'] = None
+ALLANY_DEFAULTS['keepdims'] = False
+ALLANY_DEFAULTS['axis'] = None
+validate_all = CompatValidator(ALLANY_DEFAULTS, fname='all', method='both', max_fname_arg_count=1)
+validate_any = CompatValidator(ALLANY_DEFAULTS, fname='any', method='both', max_fname_arg_count=1)
+LOGICAL_FUNC_DEFAULTS = {'out': None, 'keepdims': False}
+validate_logical_func = CompatValidator(LOGICAL_FUNC_DEFAULTS, method='kwargs')
+MINMAX_DEFAULTS = {'axis': None, 'dtype': None, 'out': None, 'keepdims': False}
+validate_min = CompatValidator(MINMAX_DEFAULTS, fname='min', method='both', max_fname_arg_count=1)
+validate_max = CompatValidator(MINMAX_DEFAULTS, fname='max', method='both', max_fname_arg_count=1)
+REPEAT_DEFAULTS: dict[str, Any] = {'axis': None}
+validate_repeat = CompatValidator(REPEAT_DEFAULTS, fname='repeat', method='both', max_fname_arg_count=1)
+ROUND_DEFAULTS: dict[str, Any] = {'out': None}
+validate_round = CompatValidator(ROUND_DEFAULTS, fname='round', method='both', max_fname_arg_count=1)
+STAT_FUNC_DEFAULTS: dict[str, Any | None] = {}
+STAT_FUNC_DEFAULTS['dtype'] = None
+STAT_FUNC_DEFAULTS['out'] = None
+SUM_DEFAULTS = STAT_FUNC_DEFAULTS.copy()
+SUM_DEFAULTS['axis'] = None
+SUM_DEFAULTS['keepdims'] = False
+SUM_DEFAULTS['initial'] = None
+PROD_DEFAULTS = SUM_DEFAULTS.copy()
+MEAN_DEFAULTS = SUM_DEFAULTS.copy()
+MEDIAN_DEFAULTS = STAT_FUNC_DEFAULTS.copy()
+MEDIAN_DEFAULTS['overwrite_input'] = False
+MEDIAN_DEFAULTS['keepdims'] = False
+STAT_FUNC_DEFAULTS['keepdims'] = False
+validate_stat_func = CompatValidator(STAT_FUNC_DEFAULTS, method='kwargs')
+validate_sum = CompatValidator(SUM_DEFAULTS, fname='sum', method='both', max_fname_arg_count=1)
+validate_prod = CompatValidator(PROD_DEFAULTS, fname='prod', method='both', max_fname_arg_count=1)
+validate_mean = CompatValidator(MEAN_DEFAULTS, fname='mean', method='both', max_fname_arg_count=1)
+validate_median = CompatValidator(MEDIAN_DEFAULTS, fname='median', method='both', max_fname_arg_count=1)
+STAT_DDOF_FUNC_DEFAULTS: dict[str, bool | None] = {}
+STAT_DDOF_FUNC_DEFAULTS['dtype'] = None
+STAT_DDOF_FUNC_DEFAULTS['out'] = None
+STAT_DDOF_FUNC_DEFAULTS['keepdims'] = False
+validate_stat_ddof_func = CompatValidator(STAT_DDOF_FUNC_DEFAULTS, method='kwargs')
+TAKE_DEFAULTS: dict[str, str | None] = {}
+TAKE_DEFAULTS['out'] = None
+TAKE_DEFAULTS['mode'] = 'raise'
+validate_take = CompatValidator(TAKE_DEFAULTS, fname='take', method='kwargs')
+TRANSPOSE_DEFAULTS = {'axes': None}
+validate_transpose = CompatValidator(TRANSPOSE_DEFAULTS, fname='transpose', method='both', max_fname_arg_count=0)
+
+def validate_groupby_func(name: str, args, kwargs, allowed=None) -> None:
+    if allowed is None:
+        allowed = []
+    kwargs = set(kwargs) - set(allowed)
+    if len(args) + len(kwargs) > 0:
+        raise UnsupportedFunctionCall(f'numpy operations are not valid with groupby. Use .groupby(...).{name}() instead')
+
+def validate_minmax_axis(axis: AxisInt | None, ndim: int=1) -> None:
+    if axis is None:
+        return
+    if axis >= ndim or (axis < 0 and ndim + axis < 0):
+        raise ValueError(f'`axis` must be fewer than the number of dimensions ({ndim})')
+_validation_funcs = {'median': validate_median, 'mean': validate_mean, 'min': validate_min, 'max': validate_max, 'sum': validate_sum, 'prod': validate_prod}
+
+def validate_func(fname, args, kwargs) -> None:
+    if fname not in _validation_funcs:
+        return validate_stat_func(args, kwargs, fname=fname)
+    validation_func = _validation_funcs[fname]
+    return validation_func(args, kwargs)
+
+# File: pandas-main/pandas/compat/pickle_compat.py
+""""""
+from __future__ import annotations
+import contextlib
+import io
+import pickle
+from typing import TYPE_CHECKING, Any
+import numpy as np
+from pandas._libs.arrays import NDArrayBacked
+from pandas._libs.tslibs import BaseOffset
+from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray
+from pandas.core.internals import BlockManager
+if TYPE_CHECKING:
+    from collections.abc import Generator
+_class_locations_map = {('pandas.core.internals.blocks', 'new_block'): ('pandas._libs.internals', '_unpickle_block'), ('pandas._libs.tslibs.nattype', '__nat_unpickle'): ('pandas._libs.tslibs.nattype', '_nat_unpickle'), ('pandas.core.indexes.numeric', 'Int64Index'): ('pandas.core.indexes.base', 'Index'), ('pandas.core.indexes.numeric', 'UInt64Index'): ('pandas.core.indexes.base', 'Index'), ('pandas.core.indexes.numeric', 'Float64Index'): ('pandas.core.indexes.base', 'Index'), ('pandas.core.arrays.sparse.dtype', 'SparseDtype'): ('pandas.core.dtypes.dtypes', 'SparseDtype')}
+
+class Unpickler(pickle._Unpickler):
+
+    def find_class(self, module: str, name: str) -> Any:
+        key = (module, name)
+        (module, name) = _class_locations_map.get(key, key)
+        return super().find_class(module, name)
+    dispatch = pickle._Unpickler.dispatch.copy()
+
+    def load_reduce(self) -> None:
+        stack = self.stack
+        args = stack.pop()
+        func = stack[-1]
+        try:
+            stack[-1] = func(*args)
+        except TypeError:
+            if args and isinstance(args[0], type) and issubclass(args[0], BaseOffset):
+                cls = args[0]
+                stack[-1] = cls.__new__(*args)
+                return
+            elif args and issubclass(args[0], PeriodArray):
+                cls = args[0]
+                stack[-1] = NDArrayBacked.__new__(*args)
+                return
+            raise
+    dispatch[pickle.REDUCE[0]] = load_reduce
+
+    def load_newobj(self) -> None:
+        args = self.stack.pop()
+        cls = self.stack.pop()
+        if issubclass(cls, DatetimeArray) and (not args):
+            arr = np.array([], dtype='M8[ns]')
+            obj = cls.__new__(cls, arr, arr.dtype)
+        elif issubclass(cls, TimedeltaArray) and (not args):
+            arr = np.array([], dtype='m8[ns]')
+            obj = cls.__new__(cls, arr, arr.dtype)
+        elif cls is BlockManager and (not args):
+            obj = cls.__new__(cls, (), [], False)
+        else:
+            obj = cls.__new__(cls, *args)
+        self.append(obj)
+    dispatch[pickle.NEWOBJ[0]] = load_newobj
+
+def loads(bytes_object: bytes, *, fix_imports: bool=True, encoding: str='ASCII', errors: str='strict') -> Any:
+    fd = io.BytesIO(bytes_object)
+    return Unpickler(fd, fix_imports=fix_imports, encoding=encoding, errors=errors).load()
+
+@contextlib.contextmanager
+def patch_pickle() -> Generator[None, None, None]:
+    orig_loads = pickle.loads
+    try:
+        setattr(pickle, 'loads', loads)
+        yield
+    finally:
+        setattr(pickle, 'loads', orig_loads)
+
+# File: pandas-main/pandas/compat/pyarrow.py
+""""""
+from __future__ import annotations
+from pandas.util.version import Version
+try:
+    import pyarrow as pa
+    _palv = Version(Version(pa.__version__).base_version)
+    pa_version_under10p1 = _palv < Version('10.0.1')
+    pa_version_under11p0 = _palv < Version('11.0.0')
+    pa_version_under12p0 = _palv < Version('12.0.0')
+    pa_version_under13p0 = _palv < Version('13.0.0')
+    pa_version_under14p0 = _palv < Version('14.0.0')
+    pa_version_under14p1 = _palv < Version('14.0.1')
+    pa_version_under15p0 = _palv < Version('15.0.0')
+    pa_version_under16p0 = _palv < Version('16.0.0')
+    pa_version_under17p0 = _palv < Version('17.0.0')
+    pa_version_under18p0 = _palv < Version('18.0.0')
+    HAS_PYARROW = True
+except ImportError:
+    pa_version_under10p1 = True
+    pa_version_under11p0 = True
+    pa_version_under12p0 = True
+    pa_version_under13p0 = True
+    pa_version_under14p0 = True
+    pa_version_under14p1 = True
+    pa_version_under15p0 = True
+    pa_version_under16p0 = True
+    pa_version_under17p0 = True
+    pa_version_under18p0 = True
+    HAS_PYARROW = False
+
+# File: pandas-main/pandas/core/_numba/executor.py
+from __future__ import annotations
+import functools
+from typing import TYPE_CHECKING, Any
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import Scalar
+import numpy as np
+from pandas.compat._optional import import_optional_dependency
+from pandas.core.util.numba_ import jit_user_function
+
+@functools.cache
+def generate_apply_looper(func, nopython=True, nogil=True, parallel=False):
+    if TYPE_CHECKING:
+        import numba
+    else:
+        numba = import_optional_dependency('numba')
+    nb_compat_func = jit_user_function(func)
+
+    @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+    def nb_looper(values, axis, *args):
+        if axis == 0:
+            first_elem = values[:, 0]
+            dim0 = values.shape[1]
+        else:
+            first_elem = values[0]
+            dim0 = values.shape[0]
+        res0 = nb_compat_func(first_elem, *args)
+        buf_shape = (dim0,) + np.atleast_1d(np.asarray(res0)).shape
+        if axis == 0:
+            buf_shape = buf_shape[::-1]
+        buff = np.empty(buf_shape)
+        if axis == 1:
+            buff[0] = res0
+            for i in numba.prange(1, values.shape[0]):
+                buff[i] = nb_compat_func(values[i], *args)
+        else:
+            buff[:, 0] = res0
+            for j in numba.prange(1, values.shape[1]):
+                buff[:, j] = nb_compat_func(values[:, j], *args)
+        return buff
+    return nb_looper
+
+@functools.cache
+def make_looper(func, result_dtype, is_grouped_kernel, nopython, nogil, parallel):
+    if TYPE_CHECKING:
+        import numba
+    else:
+        numba = import_optional_dependency('numba')
+    if is_grouped_kernel:
+
+        @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+        def column_looper(values: np.ndarray, labels: np.ndarray, ngroups: int, min_periods: int, *args):
+            result = np.empty((values.shape[0], ngroups), dtype=result_dtype)
+            na_positions = {}
+            for i in numba.prange(values.shape[0]):
+                (output, na_pos) = func(values[i], result_dtype, labels, ngroups, min_periods, *args)
+                result[i] = output
+                if len(na_pos) > 0:
+                    na_positions[i] = np.array(na_pos)
+            return (result, na_positions)
+    else:
+
+        @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+        def column_looper(values: np.ndarray, start: np.ndarray, end: np.ndarray, min_periods: int, *args):
+            result = np.empty((values.shape[0], len(start)), dtype=result_dtype)
+            na_positions = {}
+            for i in numba.prange(values.shape[0]):
+                (output, na_pos) = func(values[i], result_dtype, start, end, min_periods, *args)
+                result[i] = output
+                if len(na_pos) > 0:
+                    na_positions[i] = np.array(na_pos)
+            return (result, na_positions)
+    return column_looper
+default_dtype_mapping: dict[np.dtype, Any] = {np.dtype('int8'): np.int64, np.dtype('int16'): np.int64, np.dtype('int32'): np.int64, np.dtype('int64'): np.int64, np.dtype('uint8'): np.uint64, np.dtype('uint16'): np.uint64, np.dtype('uint32'): np.uint64, np.dtype('uint64'): np.uint64, np.dtype('float32'): np.float64, np.dtype('float64'): np.float64, np.dtype('complex64'): np.complex128, np.dtype('complex128'): np.complex128}
+float_dtype_mapping: dict[np.dtype, Any] = {np.dtype('int8'): np.float64, np.dtype('int16'): np.float64, np.dtype('int32'): np.float64, np.dtype('int64'): np.float64, np.dtype('uint8'): np.float64, np.dtype('uint16'): np.float64, np.dtype('uint32'): np.float64, np.dtype('uint64'): np.float64, np.dtype('float32'): np.float64, np.dtype('float64'): np.float64, np.dtype('complex64'): np.float64, np.dtype('complex128'): np.float64}
+identity_dtype_mapping: dict[np.dtype, Any] = {np.dtype('int8'): np.int8, np.dtype('int16'): np.int16, np.dtype('int32'): np.int32, np.dtype('int64'): np.int64, np.dtype('uint8'): np.uint8, np.dtype('uint16'): np.uint16, np.dtype('uint32'): np.uint32, np.dtype('uint64'): np.uint64, np.dtype('float32'): np.float32, np.dtype('float64'): np.float64, np.dtype('complex64'): np.complex64, np.dtype('complex128'): np.complex128}
+
+def generate_shared_aggregator(func: Callable[..., Scalar], dtype_mapping: dict[np.dtype, np.dtype], is_grouped_kernel: bool, nopython: bool, nogil: bool, parallel: bool):
+
+    def looper_wrapper(values, start=None, end=None, labels=None, ngroups=None, min_periods: int=0, **kwargs):
+        result_dtype = dtype_mapping[values.dtype]
+        column_looper = make_looper(func, result_dtype, is_grouped_kernel, nopython, nogil, parallel)
+        if is_grouped_kernel:
+            (result, na_positions) = column_looper(values, labels, ngroups, min_periods, *kwargs.values())
+        else:
+            (result, na_positions) = column_looper(values, start, end, min_periods, *kwargs.values())
+        if result.dtype.kind == 'i':
+            for na_pos in na_positions.values():
+                if len(na_pos) > 0:
+                    result = result.astype('float64')
+                    break
+        for (i, na_pos) in na_positions.items():
+            if len(na_pos) > 0:
+                result[i, na_pos] = np.nan
+        return result
+    return looper_wrapper
+
+# File: pandas-main/pandas/core/_numba/extensions.py
+""""""
+from __future__ import annotations
+from contextlib import contextmanager
+import operator
+from typing import TYPE_CHECKING
+import numba
+from numba import types
+from numba.core import cgutils
+from numba.core.datamodel import models
+from numba.core.extending import NativeValue, box, lower_builtin, make_attribute_wrapper, overload, overload_attribute, overload_method, register_model, type_callable, typeof_impl, unbox
+from numba.core.imputils import impl_ret_borrowed
+import numpy as np
+from pandas._libs import lib
+from pandas.core.indexes.base import Index
+from pandas.core.indexing import _iLocIndexer
+from pandas.core.internals import SingleBlockManager
+from pandas.core.series import Series
+if TYPE_CHECKING:
+    from pandas._typing import Self
+
+@contextmanager
+def set_numba_data(index: Index):
+    numba_data = index._data
+    if numba_data.dtype == object:
+        if not lib.is_string_array(numba_data):
+            raise ValueError('The numba engine only supports using string or numeric column names')
+        numba_data = numba_data.astype('U')
+    try:
+        index._numba_data = numba_data
+        yield index
+    finally:
+        del index._numba_data
+
+class IndexType(types.Type):
+
+    def __init__(self, dtype, layout, pyclass: any) -> None:
+        self.pyclass = pyclass
+        name = f'index({dtype}, {layout})'
+        self.dtype = dtype
+        self.layout = layout
+        super().__init__(name)
+
+    @property
+    def key(self):
+        return (self.pyclass, self.dtype, self.layout)
+
+    @property
+    def as_array(self):
+        return types.Array(self.dtype, 1, self.layout)
+
+    def copy(self, dtype=None, ndim: int=1, layout=None) -> Self:
+        assert ndim == 1
+        if dtype is None:
+            dtype = self.dtype
+        layout = layout or self.layout
+        return type(self)(dtype, layout, self.pyclass)
+
+class SeriesType(types.Type):
+
+    def __init__(self, dtype, index, namety) -> None:
+        assert isinstance(index, IndexType)
+        self.dtype = dtype
+        self.index = index
+        self.values = types.Array(self.dtype, 1, 'C')
+        self.namety = namety
+        name = f'series({dtype}, {index}, {namety})'
+        super().__init__(name)
+
+    @property
+    def key(self):
+        return (self.dtype, self.index, self.namety)
+
+    @property
+    def as_array(self):
+        return self.values
+
+    def copy(self, dtype=None, ndim: int=1, layout: str='C') -> Self:
+        assert ndim == 1
+        assert layout == 'C'
+        if dtype is None:
+            dtype = self.dtype
+        return type(self)(dtype, self.index, self.namety)
+
+@typeof_impl.register(Index)
+def typeof_index(val, c) -> IndexType:
+    arrty = typeof_impl(val._numba_data, c)
+    assert arrty.ndim == 1
+    return IndexType(arrty.dtype, arrty.layout, type(val))
+
+@typeof_impl.register(Series)
+def typeof_series(val, c) -> SeriesType:
+    index = typeof_impl(val.index, c)
+    arrty = typeof_impl(val.values, c)
+    namety = typeof_impl(val.name, c)
+    assert arrty.ndim == 1
+    assert arrty.layout == 'C'
+    return SeriesType(arrty.dtype, index, namety)
+
+@type_callable(Series)
+def type_series_constructor(context):
+
+    def typer(data, index, name=None):
+        if isinstance(index, IndexType) and isinstance(data, types.Array):
+            assert data.ndim == 1
+            if name is None:
+                name = types.intp
+            return SeriesType(data.dtype, index, name)
+    return typer
+
+@type_callable(Index)
+def type_index_constructor(context):
+
+    def typer(data, hashmap=None):
+        if isinstance(data, types.Array):
+            assert data.layout == 'C'
+            assert data.ndim == 1
+            assert hashmap is None or isinstance(hashmap, types.DictType)
+            return IndexType(data.dtype, layout=data.layout, pyclass=Index)
+    return typer
+
+@register_model(IndexType)
+class IndexModel(models.StructModel):
+
+    def __init__(self, dmm, fe_type) -> None:
+        members = [('data', fe_type.as_array), ('hashmap', types.DictType(fe_type.dtype, types.intp)), ('parent', types.pyobject)]
+        models.StructModel.__init__(self, dmm, fe_type, members)
+
+@register_model(SeriesType)
+class SeriesModel(models.StructModel):
+
+    def __init__(self, dmm, fe_type) -> None:
+        members = [('index', fe_type.index), ('values', fe_type.as_array), ('name', fe_type.namety)]
+        models.StructModel.__init__(self, dmm, fe_type, members)
+make_attribute_wrapper(IndexType, 'data', '_data')
+make_attribute_wrapper(IndexType, 'hashmap', 'hashmap')
+make_attribute_wrapper(SeriesType, 'index', 'index')
+make_attribute_wrapper(SeriesType, 'values', 'values')
+make_attribute_wrapper(SeriesType, 'name', 'name')
+
+@lower_builtin(Series, types.Array, IndexType)
+def pdseries_constructor(context, builder, sig, args):
+    (data, index) = args
+    series = cgutils.create_struct_proxy(sig.return_type)(context, builder)
+    series.index = index
+    series.values = data
+    series.name = context.get_constant(types.intp, 0)
+    return impl_ret_borrowed(context, builder, sig.return_type, series._getvalue())
+
+@lower_builtin(Series, types.Array, IndexType, types.intp)
+@lower_builtin(Series, types.Array, IndexType, types.float64)
+@lower_builtin(Series, types.Array, IndexType, types.unicode_type)
+def pdseries_constructor_with_name(context, builder, sig, args):
+    (data, index, name) = args
+    series = cgutils.create_struct_proxy(sig.return_type)(context, builder)
+    series.index = index
+    series.values = data
+    series.name = name
+    return impl_ret_borrowed(context, builder, sig.return_type, series._getvalue())
+
+@lower_builtin(Index, types.Array, types.DictType, types.pyobject)
+def index_constructor_2arg(context, builder, sig, args):
+    (data, hashmap, parent) = args
+    index = cgutils.create_struct_proxy(sig.return_type)(context, builder)
+    index.data = data
+    index.hashmap = hashmap
+    index.parent = parent
+    return impl_ret_borrowed(context, builder, sig.return_type, index._getvalue())
+
+@lower_builtin(Index, types.Array, types.DictType)
+def index_constructor_2arg_parent(context, builder, sig, args):
+    (data, hashmap) = args
+    index = cgutils.create_struct_proxy(sig.return_type)(context, builder)
+    index.data = data
+    index.hashmap = hashmap
+    return impl_ret_borrowed(context, builder, sig.return_type, index._getvalue())
+
+@lower_builtin(Index, types.Array)
+def index_constructor_1arg(context, builder, sig, args):
+    from numba.typed import Dict
+    key_type = sig.return_type.dtype
+    value_type = types.intp
+
+    def index_impl(data):
+        return Index(data, Dict.empty(key_type, value_type))
+    return context.compile_internal(builder, index_impl, sig, args)
+
+def maybe_cast_str(x):
+    pass
+
+@overload(maybe_cast_str)
+def maybe_cast_str_impl(x):
+    if isinstance(x, types.UnicodeCharSeq):
+        return lambda x: str(x)
+    else:
+        return lambda x: x
+
+@unbox(IndexType)
+def unbox_index(typ, obj, c):
+    data_obj = c.pyapi.object_getattr_string(obj, '_numba_data')
+    index = cgutils.create_struct_proxy(typ)(c.context, c.builder)
+    index.data = c.unbox(typ.as_array, data_obj).value
+    typed_dict_obj = c.pyapi.unserialize(c.pyapi.serialize_object(numba.typed.Dict))
+    arr_type_obj = c.pyapi.unserialize(c.pyapi.serialize_object(typ.dtype))
+    intp_type_obj = c.pyapi.unserialize(c.pyapi.serialize_object(types.intp))
+    hashmap_obj = c.pyapi.call_method(typed_dict_obj, 'empty', (arr_type_obj, intp_type_obj))
+    index.hashmap = c.unbox(types.DictType(typ.dtype, types.intp), hashmap_obj).value
+    index.parent = obj
+    c.pyapi.decref(data_obj)
+    c.pyapi.decref(arr_type_obj)
+    c.pyapi.decref(intp_type_obj)
+    c.pyapi.decref(typed_dict_obj)
+    return NativeValue(index._getvalue())
+
+@unbox(SeriesType)
+def unbox_series(typ, obj, c):
+    index_obj = c.pyapi.object_getattr_string(obj, 'index')
+    values_obj = c.pyapi.object_getattr_string(obj, 'values')
+    name_obj = c.pyapi.object_getattr_string(obj, 'name')
+    series = cgutils.create_struct_proxy(typ)(c.context, c.builder)
+    series.index = c.unbox(typ.index, index_obj).value
+    series.values = c.unbox(typ.values, values_obj).value
+    series.name = c.unbox(typ.namety, name_obj).value
+    c.pyapi.decref(index_obj)
+    c.pyapi.decref(values_obj)
+    c.pyapi.decref(name_obj)
+    return NativeValue(series._getvalue())
+
+@box(IndexType)
+def box_index(typ, val, c):
+    index = cgutils.create_struct_proxy(typ)(c.context, c.builder, value=val)
+    res = cgutils.alloca_once_value(c.builder, index.parent)
+    with c.builder.if_else(cgutils.is_not_null(c.builder, index.parent)) as (has_parent, otherwise):
+        with has_parent:
+            c.pyapi.incref(index.parent)
+        with otherwise:
+            class_obj = c.pyapi.unserialize(c.pyapi.serialize_object(Index))
+            array_obj = c.box(typ.as_array, index.data)
+            if isinstance(typ.dtype, types.UnicodeCharSeq):
+                object_str_obj = c.pyapi.unserialize(c.pyapi.serialize_object('object'))
+                array_obj = c.pyapi.call_method(array_obj, 'astype', (object_str_obj,))
+                c.pyapi.decref(object_str_obj)
+            index_obj = c.pyapi.call_method(class_obj, '_simple_new', (array_obj,))
+            index.parent = index_obj
+            c.builder.store(index_obj, res)
+            c.pyapi.decref(class_obj)
+            c.pyapi.decref(array_obj)
+    return c.builder.load(res)
+
+@box(SeriesType)
+def box_series(typ, val, c):
+    series = cgutils.create_struct_proxy(typ)(c.context, c.builder, value=val)
+    series_const_obj = c.pyapi.unserialize(c.pyapi.serialize_object(Series._from_mgr))
+    mgr_const_obj = c.pyapi.unserialize(c.pyapi.serialize_object(SingleBlockManager.from_array))
+    index_obj = c.box(typ.index, series.index)
+    array_obj = c.box(typ.as_array, series.values)
+    name_obj = c.box(typ.namety, series.name)
+    mgr_obj = c.pyapi.call_function_objargs(mgr_const_obj, (array_obj, index_obj))
+    mgr_axes_obj = c.pyapi.object_getattr_string(mgr_obj, 'axes')
+    series_obj = c.pyapi.call_function_objargs(series_const_obj, (mgr_obj, mgr_axes_obj))
+    c.pyapi.object_setattr_string(series_obj, '_name', name_obj)
+    c.pyapi.decref(series_const_obj)
+    c.pyapi.decref(mgr_axes_obj)
+    c.pyapi.decref(mgr_obj)
+    c.pyapi.decref(mgr_const_obj)
+    c.pyapi.decref(index_obj)
+    c.pyapi.decref(array_obj)
+    c.pyapi.decref(name_obj)
+    return series_obj
+
+def generate_series_reduction(ser_reduction, ser_method):
+
+    @overload_method(SeriesType, ser_reduction)
+    def series_reduction(series):
+
+        def series_reduction_impl(series):
+            return ser_method(series.values)
+        return series_reduction_impl
+    return series_reduction
+
+def generate_series_binop(binop):
+
+    @overload(binop)
+    def series_binop(series1, value):
+        if isinstance(series1, SeriesType):
+            if isinstance(value, SeriesType):
+
+                def series_binop_impl(series1, series2):
+                    return Series(binop(series1.values, series2.values), series1.index, series1.name)
+                return series_binop_impl
+            else:
+
+                def series_binop_impl(series1, value):
+                    return Series(binop(series1.values, value), series1.index, series1.name)
+                return series_binop_impl
+    return series_binop
+series_reductions = [('sum', np.sum), ('mean', np.mean), ('min', np.min), ('max', np.max)]
+for (reduction, reduction_method) in series_reductions:
+    generate_series_reduction(reduction, reduction_method)
+series_binops = [operator.add, operator.sub, operator.mul, operator.truediv]
+for ser_binop in series_binops:
+    generate_series_binop(ser_binop)
+
+@overload_method(IndexType, 'get_loc')
+def index_get_loc(index, item):
+
+    def index_get_loc_impl(index, item):
+        if len(index.hashmap) == 0:
+            for (i, val) in enumerate(index._data):
+                index.hashmap[val] = i
+        return index.hashmap[item]
+    return index_get_loc_impl
+
+@overload(operator.getitem)
+def series_indexing(series, item):
+    if isinstance(series, SeriesType):
+
+        def series_getitem(series, item):
+            loc = series.index.get_loc(item)
+            return series.iloc[loc]
+        return series_getitem
+
+@overload(operator.getitem)
+def index_indexing(index, idx):
+    if isinstance(index, IndexType):
+
+        def index_getitem(index, idx):
+            return index._data[idx]
+        return index_getitem
+
+class IlocType(types.Type):
+
+    def __init__(self, obj_type) -> None:
+        self.obj_type = obj_type
+        name = f'iLocIndexer({obj_type})'
+        super().__init__(name=name)
+
+    @property
+    def key(self):
+        return self.obj_type
+
+@typeof_impl.register(_iLocIndexer)
+def typeof_iloc(val, c) -> IlocType:
+    objtype = typeof_impl(val.obj, c)
+    return IlocType(objtype)
+
+@type_callable(_iLocIndexer)
+def type_iloc_constructor(context):
+
+    def typer(obj):
+        if isinstance(obj, SeriesType):
+            return IlocType(obj)
+    return typer
+
+@lower_builtin(_iLocIndexer, SeriesType)
+def iloc_constructor(context, builder, sig, args):
+    (obj,) = args
+    iloc_indexer = cgutils.create_struct_proxy(sig.return_type)(context, builder)
+    iloc_indexer.obj = obj
+    return impl_ret_borrowed(context, builder, sig.return_type, iloc_indexer._getvalue())
+
+@register_model(IlocType)
+class ILocModel(models.StructModel):
+
+    def __init__(self, dmm, fe_type) -> None:
+        members = [('obj', fe_type.obj_type)]
+        models.StructModel.__init__(self, dmm, fe_type, members)
+make_attribute_wrapper(IlocType, 'obj', 'obj')
+
+@overload_attribute(SeriesType, 'iloc')
+def series_iloc(series):
+
+    def get(series):
+        return _iLocIndexer(series)
+    return get
+
+@overload(operator.getitem)
+def iloc_getitem(iloc_indexer, i):
+    if isinstance(iloc_indexer, IlocType):
+
+        def getitem_impl(iloc_indexer, i):
+            return iloc_indexer.obj.values[i]
+        return getitem_impl
+
+# File: pandas-main/pandas/core/_numba/kernels/__init__.py
+from pandas.core._numba.kernels.mean_ import grouped_mean, sliding_mean
+from pandas.core._numba.kernels.min_max_ import grouped_min_max, sliding_min_max
+from pandas.core._numba.kernels.sum_ import grouped_sum, sliding_sum
+from pandas.core._numba.kernels.var_ import grouped_var, sliding_var
+__all__ = ['sliding_mean', 'grouped_mean', 'sliding_sum', 'grouped_sum', 'sliding_var', 'grouped_var', 'sliding_min_max', 'grouped_min_max']
+
+# File: pandas-main/pandas/core/_numba/kernels/mean_.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numba
+import numpy as np
+from pandas.core._numba.kernels.shared import is_monotonic_increasing
+from pandas.core._numba.kernels.sum_ import grouped_kahan_sum
+if TYPE_CHECKING:
+    from pandas._typing import npt
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def add_mean(val: float, nobs: int, sum_x: float, neg_ct: int, compensation: float, num_consecutive_same_value: int, prev_value: float) -> tuple[int, float, int, float, int, float]:
+    if not np.isnan(val):
+        nobs += 1
+        y = val - compensation
+        t = sum_x + y
+        compensation = t - sum_x - y
+        sum_x = t
+        if val < 0:
+            neg_ct += 1
+        if val == prev_value:
+            num_consecutive_same_value += 1
+        else:
+            num_consecutive_same_value = 1
+        prev_value = val
+    return (nobs, sum_x, neg_ct, compensation, num_consecutive_same_value, prev_value)
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def remove_mean(val: float, nobs: int, sum_x: float, neg_ct: int, compensation: float) -> tuple[int, float, int, float]:
+    if not np.isnan(val):
+        nobs -= 1
+        y = -val - compensation
+        t = sum_x + y
+        compensation = t - sum_x - y
+        sum_x = t
+        if val < 0:
+            neg_ct -= 1
+    return (nobs, sum_x, neg_ct, compensation)
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def sliding_mean(values: np.ndarray, result_dtype: np.dtype, start: np.ndarray, end: np.ndarray, min_periods: int) -> tuple[np.ndarray, list[int]]:
+    N = len(start)
+    nobs = 0
+    sum_x = 0.0
+    neg_ct = 0
+    compensation_add = 0.0
+    compensation_remove = 0.0
+    is_monotonic_increasing_bounds = is_monotonic_increasing(start) and is_monotonic_increasing(end)
+    output = np.empty(N, dtype=result_dtype)
+    for i in range(N):
+        s = start[i]
+        e = end[i]
+        if i == 0 or not is_monotonic_increasing_bounds:
+            prev_value = values[s]
+            num_consecutive_same_value = 0
+            for j in range(s, e):
+                val = values[j]
+                (nobs, sum_x, neg_ct, compensation_add, num_consecutive_same_value, prev_value) = add_mean(val, nobs, sum_x, neg_ct, compensation_add, num_consecutive_same_value, prev_value)
+        else:
+            for j in range(start[i - 1], s):
+                val = values[j]
+                (nobs, sum_x, neg_ct, compensation_remove) = remove_mean(val, nobs, sum_x, neg_ct, compensation_remove)
+            for j in range(end[i - 1], e):
+                val = values[j]
+                (nobs, sum_x, neg_ct, compensation_add, num_consecutive_same_value, prev_value) = add_mean(val, nobs, sum_x, neg_ct, compensation_add, num_consecutive_same_value, prev_value)
+        if nobs >= min_periods and nobs > 0:
+            result = sum_x / nobs
+            if num_consecutive_same_value >= nobs:
+                result = prev_value
+            elif neg_ct == 0 and result < 0:
+                result = 0
+            elif neg_ct == nobs and result > 0:
+                result = 0
+        else:
+            result = np.nan
+        output[i] = result
+        if not is_monotonic_increasing_bounds:
+            nobs = 0
+            sum_x = 0.0
+            neg_ct = 0
+            compensation_remove = 0.0
+    na_pos = [0 for i in range(0)]
+    return (output, na_pos)
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def grouped_mean(values: np.ndarray, result_dtype: np.dtype, labels: npt.NDArray[np.intp], ngroups: int, min_periods: int) -> tuple[np.ndarray, list[int]]:
+    (output, nobs_arr, comp_arr, consecutive_counts, prev_vals) = grouped_kahan_sum(values, result_dtype, labels, ngroups)
+    for lab in range(ngroups):
+        nobs = nobs_arr[lab]
+        num_consecutive_same_value = consecutive_counts[lab]
+        prev_value = prev_vals[lab]
+        sum_x = output[lab]
+        if nobs >= min_periods:
+            if num_consecutive_same_value >= nobs:
+                result = prev_value * nobs
+            else:
+                result = sum_x
+        else:
+            result = np.nan
+        result /= nobs
+        output[lab] = result
+    na_pos = [0 for i in range(0)]
+    return (output, na_pos)
+
+# File: pandas-main/pandas/core/_numba/kernels/min_max_.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numba
+import numpy as np
+if TYPE_CHECKING:
+    from pandas._typing import npt
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def sliding_min_max(values: np.ndarray, result_dtype: np.dtype, start: np.ndarray, end: np.ndarray, min_periods: int, is_max: bool) -> tuple[np.ndarray, list[int]]:
+    N = len(start)
+    nobs = 0
+    output = np.empty(N, dtype=result_dtype)
+    na_pos = []
+    Q: list = []
+    W: list = []
+    for i in range(N):
+        curr_win_size = end[i] - start[i]
+        if i == 0:
+            st = start[i]
+        else:
+            st = end[i - 1]
+        for k in range(st, end[i]):
+            ai = values[k]
+            if not np.isnan(ai):
+                nobs += 1
+            elif is_max:
+                ai = -np.inf
+            else:
+                ai = np.inf
+            if is_max:
+                while Q and (ai >= values[Q[-1]] or values[Q[-1]] != values[Q[-1]]):
+                    Q.pop()
+            else:
+                while Q and (ai <= values[Q[-1]] or values[Q[-1]] != values[Q[-1]]):
+                    Q.pop()
+            Q.append(k)
+            W.append(k)
+        while Q and Q[0] <= start[i] - 1:
+            Q.pop(0)
+        while W and W[0] <= start[i] - 1:
+            if not np.isnan(values[W[0]]):
+                nobs -= 1
+            W.pop(0)
+        if Q and curr_win_size > 0 and (nobs >= min_periods):
+            output[i] = values[Q[0]]
+        elif values.dtype.kind != 'i':
+            output[i] = np.nan
+        else:
+            na_pos.append(i)
+    return (output, na_pos)
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def grouped_min_max(values: np.ndarray, result_dtype: np.dtype, labels: npt.NDArray[np.intp], ngroups: int, min_periods: int, is_max: bool) -> tuple[np.ndarray, list[int]]:
+    N = len(labels)
+    nobs = np.zeros(ngroups, dtype=np.int64)
+    na_pos = []
+    output = np.empty(ngroups, dtype=result_dtype)
+    for i in range(N):
+        lab = labels[i]
+        val = values[i]
+        if lab < 0:
+            continue
+        if values.dtype.kind == 'i' or not np.isnan(val):
+            nobs[lab] += 1
+        else:
+            continue
+        if nobs[lab] == 1:
+            output[lab] = val
+            continue
+        if is_max:
+            if val > output[lab]:
+                output[lab] = val
+        elif val < output[lab]:
+            output[lab] = val
+    for (lab, count) in enumerate(nobs):
+        if count < min_periods:
+            na_pos.append(lab)
+    return (output, na_pos)
+
+# File: pandas-main/pandas/core/_numba/kernels/shared.py
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numba
+if TYPE_CHECKING:
+    import numpy as np
+
+@numba.jit(numba.boolean(numba.int64[:]), nopython=True, nogil=True, parallel=False)
+def is_monotonic_increasing(bounds: np.ndarray) -> bool:
+    n = len(bounds)
+    if n < 2:
+        return True
+    prev = bounds[0]
+    for i in range(1, n):
+        cur = bounds[i]
+        if cur < prev:
+            return False
+        prev = cur
+    return True
+
+# File: pandas-main/pandas/core/_numba/kernels/sum_.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+import numba
+from numba.extending import register_jitable
+import numpy as np
+if TYPE_CHECKING:
+    from pandas._typing import npt
+from pandas.core._numba.kernels.shared import is_monotonic_increasing
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def add_sum(val: Any, nobs: int, sum_x: Any, compensation: Any, num_consecutive_same_value: int, prev_value: Any) -> tuple[int, Any, Any, int, Any]:
+    if not np.isnan(val):
+        nobs += 1
+        y = val - compensation
+        t = sum_x + y
+        compensation = t - sum_x - y
+        sum_x = t
+        if val == prev_value:
+            num_consecutive_same_value += 1
+        else:
+            num_consecutive_same_value = 1
+        prev_value = val
+    return (nobs, sum_x, compensation, num_consecutive_same_value, prev_value)
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def remove_sum(val: Any, nobs: int, sum_x: Any, compensation: Any) -> tuple[int, Any, Any]:
+    if not np.isnan(val):
+        nobs -= 1
+        y = -val - compensation
+        t = sum_x + y
+        compensation = t - sum_x - y
+        sum_x = t
+    return (nobs, sum_x, compensation)
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def sliding_sum(values: np.ndarray, result_dtype: np.dtype, start: np.ndarray, end: np.ndarray, min_periods: int) -> tuple[np.ndarray, list[int]]:
+    dtype = values.dtype
+    na_val: object = np.nan
+    if dtype.kind == 'i':
+        na_val = 0
+    N = len(start)
+    nobs = 0
+    sum_x = 0
+    compensation_add = 0
+    compensation_remove = 0
+    na_pos = []
+    is_monotonic_increasing_bounds = is_monotonic_increasing(start) and is_monotonic_increasing(end)
+    output = np.empty(N, dtype=result_dtype)
+    for i in range(N):
+        s = start[i]
+        e = end[i]
+        if i == 0 or not is_monotonic_increasing_bounds:
+            prev_value = values[s]
+            num_consecutive_same_value = 0
+            for j in range(s, e):
+                val = values[j]
+                (nobs, sum_x, compensation_add, num_consecutive_same_value, prev_value) = add_sum(val, nobs, sum_x, compensation_add, num_consecutive_same_value, prev_value)
+        else:
+            for j in range(start[i - 1], s):
+                val = values[j]
+                (nobs, sum_x, compensation_remove) = remove_sum(val, nobs, sum_x, compensation_remove)
+            for j in range(end[i - 1], e):
+                val = values[j]
+                (nobs, sum_x, compensation_add, num_consecutive_same_value, prev_value) = add_sum(val, nobs, sum_x, compensation_add, num_consecutive_same_value, prev_value)
+        if nobs == 0 == min_periods:
+            result: object = 0
+        elif nobs >= min_periods:
+            if num_consecutive_same_value >= nobs:
+                result = prev_value * nobs
+            else:
+                result = sum_x
+        else:
+            result = na_val
+            if dtype.kind == 'i':
+                na_pos.append(i)
+        output[i] = result
+        if not is_monotonic_increasing_bounds:
+            nobs = 0
+            sum_x = 0
+            compensation_remove = 0
+    return (output, na_pos)
+
+@register_jitable
+def grouped_kahan_sum(values: np.ndarray, result_dtype: np.dtype, labels: npt.NDArray[np.intp], ngroups: int) -> tuple[np.ndarray, npt.NDArray[np.int64], np.ndarray, npt.NDArray[np.int64], np.ndarray]:
+    N = len(labels)
+    nobs_arr = np.zeros(ngroups, dtype=np.int64)
+    comp_arr = np.zeros(ngroups, dtype=values.dtype)
+    consecutive_counts = np.zeros(ngroups, dtype=np.int64)
+    prev_vals = np.zeros(ngroups, dtype=values.dtype)
+    output = np.zeros(ngroups, dtype=result_dtype)
+    for i in range(N):
+        lab = labels[i]
+        val = values[i]
+        if lab < 0:
+            continue
+        sum_x = output[lab]
+        nobs = nobs_arr[lab]
+        compensation_add = comp_arr[lab]
+        num_consecutive_same_value = consecutive_counts[lab]
+        prev_value = prev_vals[lab]
+        (nobs, sum_x, compensation_add, num_consecutive_same_value, prev_value) = add_sum(val, nobs, sum_x, compensation_add, num_consecutive_same_value, prev_value)
+        output[lab] = sum_x
+        consecutive_counts[lab] = num_consecutive_same_value
+        prev_vals[lab] = prev_value
+        comp_arr[lab] = compensation_add
+        nobs_arr[lab] = nobs
+    return (output, nobs_arr, comp_arr, consecutive_counts, prev_vals)
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def grouped_sum(values: np.ndarray, result_dtype: np.dtype, labels: npt.NDArray[np.intp], ngroups: int, min_periods: int) -> tuple[np.ndarray, list[int]]:
+    na_pos = []
+    (output, nobs_arr, comp_arr, consecutive_counts, prev_vals) = grouped_kahan_sum(values, result_dtype, labels, ngroups)
+    for lab in range(ngroups):
+        nobs = nobs_arr[lab]
+        num_consecutive_same_value = consecutive_counts[lab]
+        prev_value = prev_vals[lab]
+        sum_x = output[lab]
+        if nobs >= min_periods:
+            if num_consecutive_same_value >= nobs:
+                result = prev_value * nobs
+            else:
+                result = sum_x
+        else:
+            result = sum_x
+            na_pos.append(lab)
+        output[lab] = result
+    return (output, na_pos)
+
+# File: pandas-main/pandas/core/_numba/kernels/var_.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numba
+import numpy as np
+if TYPE_CHECKING:
+    from pandas._typing import npt
+from pandas.core._numba.kernels.shared import is_monotonic_increasing
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def add_var(val: float, nobs: int, mean_x: float, ssqdm_x: float, compensation: float, num_consecutive_same_value: int, prev_value: float) -> tuple[int, float, float, float, int, float]:
+    if not np.isnan(val):
+        if val == prev_value:
+            num_consecutive_same_value += 1
+        else:
+            num_consecutive_same_value = 1
+        prev_value = val
+        nobs += 1
+        prev_mean = mean_x - compensation
+        y = val - compensation
+        t = y - mean_x
+        compensation = t + mean_x - y
+        delta = t
+        if nobs:
+            mean_x += delta / nobs
+        else:
+            mean_x = 0
+        ssqdm_x += (val - prev_mean) * (val - mean_x)
+    return (nobs, mean_x, ssqdm_x, compensation, num_consecutive_same_value, prev_value)
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def remove_var(val: float, nobs: int, mean_x: float, ssqdm_x: float, compensation: float) -> tuple[int, float, float, float]:
+    if not np.isnan(val):
+        nobs -= 1
+        if nobs:
+            prev_mean = mean_x - compensation
+            y = val - compensation
+            t = y - mean_x
+            compensation = t + mean_x - y
+            delta = t
+            mean_x -= delta / nobs
+            ssqdm_x -= (val - prev_mean) * (val - mean_x)
+        else:
+            mean_x = 0
+            ssqdm_x = 0
+    return (nobs, mean_x, ssqdm_x, compensation)
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def sliding_var(values: np.ndarray, result_dtype: np.dtype, start: np.ndarray, end: np.ndarray, min_periods: int, ddof: int=1) -> tuple[np.ndarray, list[int]]:
+    N = len(start)
+    nobs = 0
+    mean_x = 0.0
+    ssqdm_x = 0.0
+    compensation_add = 0.0
+    compensation_remove = 0.0
+    min_periods = max(min_periods, 1)
+    is_monotonic_increasing_bounds = is_monotonic_increasing(start) and is_monotonic_increasing(end)
+    output = np.empty(N, dtype=result_dtype)
+    for i in range(N):
+        s = start[i]
+        e = end[i]
+        if i == 0 or not is_monotonic_increasing_bounds:
+            prev_value = values[s]
+            num_consecutive_same_value = 0
+            for j in range(s, e):
+                val = values[j]
+                (nobs, mean_x, ssqdm_x, compensation_add, num_consecutive_same_value, prev_value) = add_var(val, nobs, mean_x, ssqdm_x, compensation_add, num_consecutive_same_value, prev_value)
+        else:
+            for j in range(start[i - 1], s):
+                val = values[j]
+                (nobs, mean_x, ssqdm_x, compensation_remove) = remove_var(val, nobs, mean_x, ssqdm_x, compensation_remove)
+            for j in range(end[i - 1], e):
+                val = values[j]
+                (nobs, mean_x, ssqdm_x, compensation_add, num_consecutive_same_value, prev_value) = add_var(val, nobs, mean_x, ssqdm_x, compensation_add, num_consecutive_same_value, prev_value)
+        if nobs >= min_periods and nobs > ddof:
+            if nobs == 1 or num_consecutive_same_value >= nobs:
+                result = 0.0
+            else:
+                result = ssqdm_x / (nobs - ddof)
+        else:
+            result = np.nan
+        output[i] = result
+        if not is_monotonic_increasing_bounds:
+            nobs = 0
+            mean_x = 0.0
+            ssqdm_x = 0.0
+            compensation_remove = 0.0
+    na_pos = [0 for i in range(0)]
+    return (output, na_pos)
+
+@numba.jit(nopython=True, nogil=True, parallel=False)
+def grouped_var(values: np.ndarray, result_dtype: np.dtype, labels: npt.NDArray[np.intp], ngroups: int, min_periods: int, ddof: int=1) -> tuple[np.ndarray, list[int]]:
+    N = len(labels)
+    nobs_arr = np.zeros(ngroups, dtype=np.int64)
+    comp_arr = np.zeros(ngroups, dtype=values.dtype)
+    consecutive_counts = np.zeros(ngroups, dtype=np.int64)
+    prev_vals = np.zeros(ngroups, dtype=values.dtype)
+    output = np.zeros(ngroups, dtype=result_dtype)
+    means = np.zeros(ngroups, dtype=result_dtype)
+    for i in range(N):
+        lab = labels[i]
+        val = values[i]
+        if lab < 0:
+            continue
+        mean_x = means[lab]
+        ssqdm_x = output[lab]
+        nobs = nobs_arr[lab]
+        compensation_add = comp_arr[lab]
+        num_consecutive_same_value = consecutive_counts[lab]
+        prev_value = prev_vals[lab]
+        (nobs, mean_x, ssqdm_x, compensation_add, num_consecutive_same_value, prev_value) = add_var(val, nobs, mean_x, ssqdm_x, compensation_add, num_consecutive_same_value, prev_value)
+        output[lab] = ssqdm_x
+        means[lab] = mean_x
+        consecutive_counts[lab] = num_consecutive_same_value
+        prev_vals[lab] = prev_value
+        comp_arr[lab] = compensation_add
+        nobs_arr[lab] = nobs
+    for lab in range(ngroups):
+        nobs = nobs_arr[lab]
+        num_consecutive_same_value = consecutive_counts[lab]
+        ssqdm_x = output[lab]
+        if nobs >= min_periods and nobs > ddof:
+            if nobs == 1 or num_consecutive_same_value >= nobs:
+                result = 0.0
+            else:
+                result = ssqdm_x / (nobs - ddof)
+        else:
+            result = np.nan
+        output[lab] = result
+    na_pos = [0 for i in range(0)]
+    return (output, na_pos)
+
+# File: pandas-main/pandas/core/accessor.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, final
+import warnings
+from pandas.util._decorators import doc
+from pandas.util._exceptions import find_stack_level
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import TypeT
+    from pandas import Index
+    from pandas.core.generic import NDFrame
+
+class DirNamesMixin:
+    _accessors: set[str] = set()
+    _hidden_attrs: frozenset[str] = frozenset()
+
+    @final
+    def _dir_deletions(self) -> set[str]:
+        return self._accessors | self._hidden_attrs
+
+    def _dir_additions(self) -> set[str]:
+        return {accessor for accessor in self._accessors if hasattr(self, accessor)}
+
+    def __dir__(self) -> list[str]:
+        rv = set(super().__dir__())
+        rv = rv - self._dir_deletions() | self._dir_additions()
+        return sorted(rv)
+
+class PandasDelegate:
+
+    def _delegate_property_get(self, name: str, *args, **kwargs):
+        raise TypeError(f'You cannot access the property {name}')
+
+    def _delegate_property_set(self, name: str, value, *args, **kwargs) -> None:
+        raise TypeError(f'The property {name} cannot be set')
+
+    def _delegate_method(self, name: str, *args, **kwargs):
+        raise TypeError(f'You cannot call method {name}')
+
+    @classmethod
+    def _add_delegate_accessors(cls, delegate, accessors: list[str], typ: str, overwrite: bool=False, accessor_mapping: Callable[[str], str]=lambda x: x, raise_on_missing: bool=True) -> None:
+
+        def _create_delegator_property(name: str):
+
+            def _getter(self):
+                return self._delegate_property_get(name)
+
+            def _setter(self, new_values):
+                return self._delegate_property_set(name, new_values)
+            _getter.__name__ = name
+            _setter.__name__ = name
+            return property(fget=_getter, fset=_setter, doc=getattr(delegate, accessor_mapping(name)).__doc__)
+
+        def _create_delegator_method(name: str):
+
+            def f(self, *args, **kwargs):
+                return self._delegate_method(name, *args, **kwargs)
+            f.__name__ = name
+            f.__doc__ = getattr(delegate, accessor_mapping(name)).__doc__
+            return f
+        for name in accessors:
+            if not raise_on_missing and getattr(delegate, accessor_mapping(name), None) is None:
+                continue
+            if typ == 'property':
+                f = _create_delegator_property(name)
+            else:
+                f = _create_delegator_method(name)
+            if overwrite or not hasattr(cls, name):
+                setattr(cls, name, f)
+
+def delegate_names(delegate, accessors: list[str], typ: str, overwrite: bool=False, accessor_mapping: Callable[[str], str]=lambda x: x, raise_on_missing: bool=True):
+
+    def add_delegate_accessors(cls):
+        cls._add_delegate_accessors(delegate, accessors, typ, overwrite=overwrite, accessor_mapping=accessor_mapping, raise_on_missing=raise_on_missing)
+        return cls
+    return add_delegate_accessors
+
+class Accessor:
+
+    def __init__(self, name: str, accessor) -> None:
+        self._name = name
+        self._accessor = accessor
+
+    def __get__(self, obj, cls):
+        if obj is None:
+            return self._accessor
+        return self._accessor(obj)
+CachedAccessor = Accessor
+
+@doc(klass='', examples='', others='')
+def _register_accessor(name: str, cls: type[NDFrame | Index]) -> Callable[[TypeT], TypeT]:
+
+    def decorator(accessor: TypeT) -> TypeT:
+        if hasattr(cls, name):
+            warnings.warn(f'registration of accessor {accessor!r} under name {name!r} for type {cls!r} is overriding a preexisting attribute with the same name.', UserWarning, stacklevel=find_stack_level())
+        setattr(cls, name, Accessor(name, accessor))
+        cls._accessors.add(name)
+        return accessor
+    return decorator
+_register_df_examples = '\nAn accessor that only accepts integers could\nhave a class defined like this:\n\n>>> @pd.api.extensions.register_dataframe_accessor("int_accessor")\n... class IntAccessor:\n...     def __init__(self, pandas_obj):\n...         if not all(pandas_obj[col].dtype == \'int64\' for col in pandas_obj.columns):\n...             raise AttributeError("All columns must contain integer values only")\n...         self._obj = pandas_obj\n...\n...     def sum(self):\n...         return self._obj.sum()\n...\n>>> df = pd.DataFrame([[1, 2], [\'x\', \'y\']])\n>>> df.int_accessor\nTraceback (most recent call last):\n...\nAttributeError: All columns must contain integer values only.\n>>> df = pd.DataFrame([[1, 2], [3, 4]])\n>>> df.int_accessor.sum()\n0    4\n1    6\ndtype: int64'
+
+@doc(_register_accessor, klass='DataFrame', examples=_register_df_examples)
+def register_dataframe_accessor(name: str) -> Callable[[TypeT], TypeT]:
+    from pandas import DataFrame
+    return _register_accessor(name, DataFrame)
+_register_series_examples = '\nAn accessor that only accepts integers could\nhave a class defined like this:\n\n>>> @pd.api.extensions.register_series_accessor("int_accessor")\n... class IntAccessor:\n...     def __init__(self, pandas_obj):\n...         if not pandas_obj.dtype == \'int64\':\n...             raise AttributeError("The series must contain integer data only")\n...         self._obj = pandas_obj\n...\n...     def sum(self):\n...         return self._obj.sum()\n...\n>>> df = pd.Series([1, 2, \'x\'])\n>>> df.int_accessor\nTraceback (most recent call last):\n...\nAttributeError: The series must contain integer data only.\n>>> df = pd.Series([1, 2, 3])\n>>> df.int_accessor.sum()\n6'
+
+@doc(_register_accessor, klass='Series', examples=_register_series_examples)
+def register_series_accessor(name: str) -> Callable[[TypeT], TypeT]:
+    from pandas import Series
+    return _register_accessor(name, Series)
+_register_index_examples = '\nAn accessor that only accepts integers could\nhave a class defined like this:\n\n>>> @pd.api.extensions.register_index_accessor("int_accessor")\n... class IntAccessor:\n...     def __init__(self, pandas_obj):\n...         if not all(isinstance(x, int) for x in pandas_obj):\n...             raise AttributeError("The index must only be an integer value")\n...         self._obj = pandas_obj\n...\n...     def even(self):\n...         return [x for x in self._obj if x % 2 == 0]\n>>> df = pd.DataFrame.from_dict(\n...     {"row1": {"1": 1, "2": "a"}, "row2": {"1": 2, "2": "b"}}, orient="index"\n... )\n>>> df.index.int_accessor\nTraceback (most recent call last):\n...\nAttributeError: The index must only be an integer value.\n>>> df = pd.DataFrame(\n...     {"col1": [1, 2, 3, 4], "col2": ["a", "b", "c", "d"]}, index=[1, 2, 5, 8]\n... )\n>>> df.index.int_accessor.even()\n[2, 8]'
+
+@doc(_register_accessor, klass='Index', examples=_register_index_examples)
+def register_index_accessor(name: str) -> Callable[[TypeT], TypeT]:
+    from pandas import Index
+    return _register_accessor(name, Index)
+
+# File: pandas-main/pandas/core/algorithms.py
+""""""
+from __future__ import annotations
+import decimal
+import operator
+from textwrap import dedent
+from typing import TYPE_CHECKING, Literal, cast
+import warnings
+import numpy as np
+from pandas._libs import algos, hashtable as htable, iNaT, lib
+from pandas._typing import AnyArrayLike, ArrayLike, ArrayLikeT, AxisInt, DtypeObj, TakeIndexer, npt
+from pandas.util._decorators import doc
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike, np_find_common_type
+from pandas.core.dtypes.common import ensure_float64, ensure_object, ensure_platform_int, is_bool_dtype, is_complex_dtype, is_dict_like, is_extension_array_dtype, is_float, is_float_dtype, is_integer, is_integer_dtype, is_list_like, is_object_dtype, is_signed_integer_dtype, needs_i8_conversion
+from pandas.core.dtypes.concat import concat_compat
+from pandas.core.dtypes.dtypes import BaseMaskedDtype, CategoricalDtype, ExtensionDtype, NumpyEADtype
+from pandas.core.dtypes.generic import ABCDatetimeArray, ABCExtensionArray, ABCIndex, ABCMultiIndex, ABCNumpyExtensionArray, ABCSeries, ABCTimedeltaArray
+from pandas.core.dtypes.missing import isna, na_value_for_dtype
+from pandas.core.array_algos.take import take_nd
+from pandas.core.construction import array as pd_array, ensure_wrapped_if_datetimelike, extract_array
+from pandas.core.indexers import validate_indices
+if TYPE_CHECKING:
+    from pandas._typing import ListLike, NumpySorter, NumpyValueArrayLike
+    from pandas import Categorical, Index, Series
+    from pandas.core.arrays import BaseMaskedArray, ExtensionArray
+
+def _ensure_data(values: ArrayLike) -> np.ndarray:
+    if not isinstance(values, ABCMultiIndex):
+        values = extract_array(values, extract_numpy=True)
+    if is_object_dtype(values.dtype):
+        return ensure_object(np.asarray(values))
+    elif isinstance(values.dtype, BaseMaskedDtype):
+        values = cast('BaseMaskedArray', values)
+        if not values._hasna:
+            return _ensure_data(values._data)
+        return np.asarray(values)
+    elif isinstance(values.dtype, CategoricalDtype):
+        values = cast('Categorical', values)
+        return values.codes
+    elif is_bool_dtype(values.dtype):
+        if isinstance(values, np.ndarray):
+            return np.asarray(values).view('uint8')
+        else:
+            return np.asarray(values).astype('uint8', copy=False)
+    elif is_integer_dtype(values.dtype):
+        return np.asarray(values)
+    elif is_float_dtype(values.dtype):
+        if values.dtype.itemsize in [2, 12, 16]:
+            return ensure_float64(values)
+        return np.asarray(values)
+    elif is_complex_dtype(values.dtype):
+        return cast(np.ndarray, values)
+    elif needs_i8_conversion(values.dtype):
+        npvalues = values.view('i8')
+        npvalues = cast(np.ndarray, npvalues)
+        return npvalues
+    values = np.asarray(values, dtype=object)
+    return ensure_object(values)
+
+def _reconstruct_data(values: ArrayLikeT, dtype: DtypeObj, original: AnyArrayLike) -> ArrayLikeT:
+    if isinstance(values, ABCExtensionArray) and values.dtype == dtype:
+        return values
+    if not isinstance(dtype, np.dtype):
+        cls = dtype.construct_array_type()
+        values = cls._from_sequence(values, dtype=dtype)
+    else:
+        values = values.astype(dtype, copy=False)
+    return values
+
+def _ensure_arraylike(values, func_name: str) -> ArrayLike:
+    if not isinstance(values, (ABCIndex, ABCSeries, ABCExtensionArray, np.ndarray, ABCNumpyExtensionArray)):
+        if func_name != 'isin-targets':
+            raise TypeError(f'{func_name} requires a Series, Index, ExtensionArray, np.ndarray or NumpyExtensionArray got {type(values).__name__}.')
+        inferred = lib.infer_dtype(values, skipna=False)
+        if inferred in ['mixed', 'string', 'mixed-integer']:
+            if isinstance(values, tuple):
+                values = list(values)
+            values = construct_1d_object_array_from_listlike(values)
+        else:
+            values = np.asarray(values)
+    return values
+_hashtables = {'complex128': htable.Complex128HashTable, 'complex64': htable.Complex64HashTable, 'float64': htable.Float64HashTable, 'float32': htable.Float32HashTable, 'uint64': htable.UInt64HashTable, 'uint32': htable.UInt32HashTable, 'uint16': htable.UInt16HashTable, 'uint8': htable.UInt8HashTable, 'int64': htable.Int64HashTable, 'int32': htable.Int32HashTable, 'int16': htable.Int16HashTable, 'int8': htable.Int8HashTable, 'string': htable.StringHashTable, 'object': htable.PyObjectHashTable}
+
+def _get_hashtable_algo(values: np.ndarray) -> tuple[type[htable.HashTable], np.ndarray]:
+    values = _ensure_data(values)
+    ndtype = _check_object_for_strings(values)
+    hashtable = _hashtables[ndtype]
+    return (hashtable, values)
+
+def _check_object_for_strings(values: np.ndarray) -> str:
+    ndtype = values.dtype.name
+    if ndtype == 'object':
+        if lib.is_string_array(values, skipna=False):
+            ndtype = 'string'
+    return ndtype
+
+def unique(values):
+    return unique_with_mask(values)
+
+def nunique_ints(values: ArrayLike) -> int:
+    if len(values) == 0:
+        return 0
+    values = _ensure_data(values)
+    result = (np.bincount(values.ravel().astype('intp')) != 0).sum()
+    return result
+
+def unique_with_mask(values, mask: npt.NDArray[np.bool_] | None=None):
+    values = _ensure_arraylike(values, func_name='unique')
+    if isinstance(values.dtype, ExtensionDtype):
+        return values.unique()
+    if isinstance(values, ABCIndex):
+        return values.unique()
+    original = values
+    (hashtable, values) = _get_hashtable_algo(values)
+    table = hashtable(len(values))
+    if mask is None:
+        uniques = table.unique(values)
+        uniques = _reconstruct_data(uniques, original.dtype, original)
+        return uniques
+    else:
+        (uniques, mask) = table.unique(values, mask=mask)
+        uniques = _reconstruct_data(uniques, original.dtype, original)
+        assert mask is not None
+        return (uniques, mask.astype('bool'))
+unique1d = unique
+_MINIMUM_COMP_ARR_LEN = 1000000
+
+def isin(comps: ListLike, values: ListLike) -> npt.NDArray[np.bool_]:
+    if not is_list_like(comps):
+        raise TypeError(f'only list-like objects are allowed to be passed to isin(), you passed a `{type(comps).__name__}`')
+    if not is_list_like(values):
+        raise TypeError(f'only list-like objects are allowed to be passed to isin(), you passed a `{type(values).__name__}`')
+    if not isinstance(values, (ABCIndex, ABCSeries, ABCExtensionArray, np.ndarray)):
+        orig_values = list(values)
+        values = _ensure_arraylike(orig_values, func_name='isin-targets')
+        if len(values) > 0 and values.dtype.kind in 'iufcb' and (not is_signed_integer_dtype(comps)):
+            values = construct_1d_object_array_from_listlike(orig_values)
+    elif isinstance(values, ABCMultiIndex):
+        values = np.array(values)
+    else:
+        values = extract_array(values, extract_numpy=True, extract_range=True)
+    comps_array = _ensure_arraylike(comps, func_name='isin')
+    comps_array = extract_array(comps_array, extract_numpy=True)
+    if not isinstance(comps_array, np.ndarray):
+        return comps_array.isin(values)
+    elif needs_i8_conversion(comps_array.dtype):
+        return pd_array(comps_array).isin(values)
+    elif needs_i8_conversion(values.dtype) and (not is_object_dtype(comps_array.dtype)):
+        return np.zeros(comps_array.shape, dtype=bool)
+    elif needs_i8_conversion(values.dtype):
+        return isin(comps_array, values.astype(object))
+    elif isinstance(values.dtype, ExtensionDtype):
+        return isin(np.asarray(comps_array), np.asarray(values))
+    if len(comps_array) > _MINIMUM_COMP_ARR_LEN and len(values) <= 26 and (comps_array.dtype != object):
+        if isna(values).any():
+
+            def f(c, v):
+                return np.logical_or(np.isin(c, v).ravel(), np.isnan(c))
+        else:
+            f = lambda a, b: np.isin(a, b).ravel()
+    else:
+        common = np_find_common_type(values.dtype, comps_array.dtype)
+        values = values.astype(common, copy=False)
+        comps_array = comps_array.astype(common, copy=False)
+        f = htable.ismember
+    return f(comps_array, values)
+
+def factorize_array(values: np.ndarray, use_na_sentinel: bool=True, size_hint: int | None=None, na_value: object=None, mask: npt.NDArray[np.bool_] | None=None) -> tuple[npt.NDArray[np.intp], np.ndarray]:
+    original = values
+    if values.dtype.kind in 'mM':
+        na_value = iNaT
+    (hash_klass, values) = _get_hashtable_algo(values)
+    table = hash_klass(size_hint or len(values))
+    (uniques, codes) = table.factorize(values, na_sentinel=-1, na_value=na_value, mask=mask, ignore_na=use_na_sentinel)
+    uniques = _reconstruct_data(uniques, original.dtype, original)
+    codes = ensure_platform_int(codes)
+    return (codes, uniques)
+
+@doc(values=dedent("    values : sequence\n        A 1-D sequence. Sequences that aren't pandas objects are\n        coerced to ndarrays before factorization.\n    "), sort=dedent('    sort : bool, default False\n        Sort `uniques` and shuffle `codes` to maintain the\n        relationship.\n    '), size_hint=dedent('    size_hint : int, optional\n        Hint to the hashtable sizer.\n    '))
+def factorize(values, sort: bool=False, use_na_sentinel: bool=True, size_hint: int | None=None) -> tuple[np.ndarray, np.ndarray | Index]:
+    if isinstance(values, (ABCIndex, ABCSeries)):
+        return values.factorize(sort=sort, use_na_sentinel=use_na_sentinel)
+    values = _ensure_arraylike(values, func_name='factorize')
+    original = values
+    if isinstance(values, (ABCDatetimeArray, ABCTimedeltaArray)) and values.freq is not None:
+        (codes, uniques) = values.factorize(sort=sort)
+        return (codes, uniques)
+    elif not isinstance(values, np.ndarray):
+        (codes, uniques) = values.factorize(use_na_sentinel=use_na_sentinel)
+    else:
+        values = np.asarray(values)
+        if not use_na_sentinel and values.dtype == object:
+            null_mask = isna(values)
+            if null_mask.any():
+                na_value = na_value_for_dtype(values.dtype, compat=False)
+                values = np.where(null_mask, na_value, values)
+        (codes, uniques) = factorize_array(values, use_na_sentinel=use_na_sentinel, size_hint=size_hint)
+    if sort and len(uniques) > 0:
+        (uniques, codes) = safe_sort(uniques, codes, use_na_sentinel=use_na_sentinel, assume_unique=True, verify=False)
+    uniques = _reconstruct_data(uniques, original.dtype, original)
+    return (codes, uniques)
+
+def value_counts_internal(values, sort: bool=True, ascending: bool=False, normalize: bool=False, bins=None, dropna: bool=True) -> Series:
+    from pandas import Index, Series
+    index_name = getattr(values, 'name', None)
+    name = 'proportion' if normalize else 'count'
+    if bins is not None:
+        from pandas.core.reshape.tile import cut
+        if isinstance(values, Series):
+            values = values._values
+        try:
+            ii = cut(values, bins, include_lowest=True)
+        except TypeError as err:
+            raise TypeError('bins argument only works with numeric data.') from err
+        result = ii.value_counts(dropna=dropna)
+        result.name = name
+        result = result[result.index.notna()]
+        result.index = result.index.astype('interval')
+        result = result.sort_index()
+        if dropna and (result._values == 0).all():
+            result = result.iloc[0:0]
+        counts = np.array([len(ii)])
+    elif is_extension_array_dtype(values):
+        result = Series(values, copy=False)._values.value_counts(dropna=dropna)
+        result.name = name
+        result.index.name = index_name
+        counts = result._values
+        if not isinstance(counts, np.ndarray):
+            counts = np.asarray(counts)
+    elif isinstance(values, ABCMultiIndex):
+        levels = list(range(values.nlevels))
+        result = Series(index=values, name=name).groupby(level=levels, dropna=dropna).size()
+        result.index.names = values.names
+        counts = result._values
+    else:
+        values = _ensure_arraylike(values, func_name='value_counts')
+        (keys, counts, _) = value_counts_arraylike(values, dropna)
+        if keys.dtype == np.float16:
+            keys = keys.astype(np.float32)
+        idx = Index(keys, dtype=keys.dtype, name=index_name)
+        result = Series(counts, index=idx, name=name, copy=False)
+    if sort:
+        result = result.sort_values(ascending=ascending)
+    if normalize:
+        result = result / counts.sum()
+    return result
+
+def value_counts_arraylike(values: np.ndarray, dropna: bool, mask: npt.NDArray[np.bool_] | None=None) -> tuple[ArrayLike, npt.NDArray[np.int64], int]:
+    original = values
+    values = _ensure_data(values)
+    (keys, counts, na_counter) = htable.value_count(values, dropna, mask=mask)
+    if needs_i8_conversion(original.dtype):
+        if dropna:
+            mask = keys != iNaT
+            (keys, counts) = (keys[mask], counts[mask])
+    res_keys = _reconstruct_data(keys, original.dtype, original)
+    return (res_keys, counts, na_counter)
+
+def duplicated(values: ArrayLike, keep: Literal['first', 'last', False]='first', mask: npt.NDArray[np.bool_] | None=None) -> npt.NDArray[np.bool_]:
+    values = _ensure_data(values)
+    return htable.duplicated(values, keep=keep, mask=mask)
+
+def mode(values: ArrayLike, dropna: bool=True, mask: npt.NDArray[np.bool_] | None=None) -> ArrayLike:
+    values = _ensure_arraylike(values, func_name='mode')
+    original = values
+    if needs_i8_conversion(values.dtype):
+        values = ensure_wrapped_if_datetimelike(values)
+        values = cast('ExtensionArray', values)
+        return values._mode(dropna=dropna)
+    values = _ensure_data(values)
+    (npresult, res_mask) = htable.mode(values, dropna=dropna, mask=mask)
+    if res_mask is not None:
+        return (npresult, res_mask)
+    try:
+        npresult = np.sort(npresult)
+    except TypeError as err:
+        warnings.warn(f'Unable to sort modes: {err}', stacklevel=find_stack_level())
+    result = _reconstruct_data(npresult, original.dtype, original)
+    return result
+
+def rank(values: ArrayLike, axis: AxisInt=0, method: str='average', na_option: str='keep', ascending: bool=True, pct: bool=False) -> npt.NDArray[np.float64]:
+    is_datetimelike = needs_i8_conversion(values.dtype)
+    values = _ensure_data(values)
+    if values.ndim == 1:
+        ranks = algos.rank_1d(values, is_datetimelike=is_datetimelike, ties_method=method, ascending=ascending, na_option=na_option, pct=pct)
+    elif values.ndim == 2:
+        ranks = algos.rank_2d(values, axis=axis, is_datetimelike=is_datetimelike, ties_method=method, ascending=ascending, na_option=na_option, pct=pct)
+    else:
+        raise TypeError('Array with ndim > 2 are not supported.')
+    return ranks
+
+def take(arr, indices: TakeIndexer, axis: AxisInt=0, allow_fill: bool=False, fill_value=None):
+    if not isinstance(arr, (np.ndarray, ABCExtensionArray, ABCIndex, ABCSeries, ABCNumpyExtensionArray)):
+        raise TypeError(f'pd.api.extensions.take requires a numpy.ndarray, ExtensionArray, Index, Series, or NumpyExtensionArray got {type(arr).__name__}.')
+    indices = ensure_platform_int(indices)
+    if allow_fill:
+        validate_indices(indices, arr.shape[axis])
+        result = take_nd(arr, indices, axis=axis, allow_fill=True, fill_value=fill_value)
+    else:
+        result = arr.take(indices, axis=axis)
+    return result
+
+def searchsorted(arr: ArrayLike, value: NumpyValueArrayLike | ExtensionArray, side: Literal['left', 'right']='left', sorter: NumpySorter | None=None) -> npt.NDArray[np.intp] | np.intp:
+    if sorter is not None:
+        sorter = ensure_platform_int(sorter)
+    if isinstance(arr, np.ndarray) and arr.dtype.kind in 'iu' and (is_integer(value) or is_integer_dtype(value)):
+        iinfo = np.iinfo(arr.dtype.type)
+        value_arr = np.array([value]) if is_integer(value) else np.array(value)
+        if (value_arr >= iinfo.min).all() and (value_arr <= iinfo.max).all():
+            dtype = arr.dtype
+        else:
+            dtype = value_arr.dtype
+        if is_integer(value):
+            value = cast(int, dtype.type(value))
+        else:
+            value = pd_array(cast(ArrayLike, value), dtype=dtype)
+    else:
+        arr = ensure_wrapped_if_datetimelike(arr)
+    return arr.searchsorted(value, side=side, sorter=sorter)
+_diff_special = {'float64', 'float32', 'int64', 'int32', 'int16', 'int8'}
+
+def diff(arr, n: int, axis: AxisInt=0):
+    if not lib.is_integer(n):
+        if not (is_float(n) and n.is_integer()):
+            raise ValueError('periods must be an integer')
+        n = int(n)
+    na = np.nan
+    dtype = arr.dtype
+    is_bool = is_bool_dtype(dtype)
+    if is_bool:
+        op = operator.xor
+    else:
+        op = operator.sub
+    if isinstance(dtype, NumpyEADtype):
+        arr = arr.to_numpy()
+        dtype = arr.dtype
+    if not isinstance(arr, np.ndarray):
+        if hasattr(arr, f'__{op.__name__}__'):
+            if axis != 0:
+                raise ValueError(f'cannot diff {type(arr).__name__} on axis={axis}')
+            return op(arr, arr.shift(n))
+        else:
+            raise TypeError(f"{type(arr).__name__} has no 'diff' method. Convert to a suitable dtype prior to calling 'diff'.")
+    is_timedelta = False
+    if arr.dtype.kind in 'mM':
+        dtype = np.int64
+        arr = arr.view('i8')
+        na = iNaT
+        is_timedelta = True
+    elif is_bool:
+        dtype = np.object_
+    elif dtype.kind in 'iu':
+        if arr.dtype.name in ['int8', 'int16']:
+            dtype = np.float32
+        else:
+            dtype = np.float64
+    orig_ndim = arr.ndim
+    if orig_ndim == 1:
+        arr = arr.reshape(-1, 1)
+    dtype = np.dtype(dtype)
+    out_arr = np.empty(arr.shape, dtype=dtype)
+    na_indexer = [slice(None)] * 2
+    na_indexer[axis] = slice(None, n) if n >= 0 else slice(n, None)
+    out_arr[tuple(na_indexer)] = na
+    if arr.dtype.name in _diff_special:
+        algos.diff_2d(arr, out_arr, n, axis, datetimelike=is_timedelta)
+    else:
+        _res_indexer = [slice(None)] * 2
+        _res_indexer[axis] = slice(n, None) if n >= 0 else slice(None, n)
+        res_indexer = tuple(_res_indexer)
+        _lag_indexer = [slice(None)] * 2
+        _lag_indexer[axis] = slice(None, -n) if n > 0 else slice(-n, None)
+        lag_indexer = tuple(_lag_indexer)
+        out_arr[res_indexer] = op(arr[res_indexer], arr[lag_indexer])
+    if is_timedelta:
+        out_arr = out_arr.view('timedelta64[ns]')
+    if orig_ndim == 1:
+        out_arr = out_arr[:, 0]
+    return out_arr
+
+def safe_sort(values: Index | ArrayLike, codes: npt.NDArray[np.intp] | None=None, use_na_sentinel: bool=True, assume_unique: bool=False, verify: bool=True) -> AnyArrayLike | tuple[AnyArrayLike, np.ndarray]:
+    if not isinstance(values, (np.ndarray, ABCExtensionArray, ABCIndex)):
+        raise TypeError('Only np.ndarray, ExtensionArray, and Index objects are allowed to be passed to safe_sort as values')
+    sorter = None
+    ordered: AnyArrayLike
+    if not isinstance(values.dtype, ExtensionDtype) and lib.infer_dtype(values, skipna=False) == 'mixed-integer':
+        ordered = _sort_mixed(values)
+    else:
+        try:
+            sorter = values.argsort()
+            ordered = values.take(sorter)
+        except (TypeError, decimal.InvalidOperation):
+            if values.size and isinstance(values[0], tuple):
+                ordered = _sort_tuples(values)
+            else:
+                ordered = _sort_mixed(values)
+    if codes is None:
+        return ordered
+    if not is_list_like(codes):
+        raise TypeError('Only list-like objects or None are allowed to be passed to safe_sort as codes')
+    codes = ensure_platform_int(np.asarray(codes))
+    if not assume_unique and (not len(unique(values)) == len(values)):
+        raise ValueError('values should be unique if codes is not None')
+    if sorter is None:
+        (hash_klass, values) = _get_hashtable_algo(values)
+        t = hash_klass(len(values))
+        t.map_locations(values)
+        sorter = ensure_platform_int(t.lookup(ordered))
+    if use_na_sentinel:
+        order2 = sorter.argsort()
+        if verify:
+            mask = (codes < -len(values)) | (codes >= len(values))
+            codes[mask] = -1
+        new_codes = take_nd(order2, codes, fill_value=-1)
+    else:
+        reverse_indexer = np.empty(len(sorter), dtype=int)
+        reverse_indexer.put(sorter, np.arange(len(sorter)))
+        new_codes = reverse_indexer.take(codes, mode='wrap')
+    return (ordered, ensure_platform_int(new_codes))
+
+def _sort_mixed(values) -> AnyArrayLike:
+    str_pos = np.array([isinstance(x, str) for x in values], dtype=bool)
+    null_pos = np.array([isna(x) for x in values], dtype=bool)
+    num_pos = ~str_pos & ~null_pos
+    str_argsort = np.argsort(values[str_pos])
+    num_argsort = np.argsort(values[num_pos])
+    str_locs = str_pos.nonzero()[0].take(str_argsort)
+    num_locs = num_pos.nonzero()[0].take(num_argsort)
+    null_locs = null_pos.nonzero()[0]
+    locs = np.concatenate([num_locs, str_locs, null_locs])
+    return values.take(locs)
+
+def _sort_tuples(values: np.ndarray) -> np.ndarray:
+    from pandas.core.internals.construction import to_arrays
+    from pandas.core.sorting import lexsort_indexer
+    (arrays, _) = to_arrays(values, None)
+    indexer = lexsort_indexer(arrays, orders=True)
+    return values[indexer]
+
+def union_with_duplicates(lvals: ArrayLike | Index, rvals: ArrayLike | Index) -> ArrayLike | Index:
+    from pandas import Series
+    l_count = value_counts_internal(lvals, dropna=False)
+    r_count = value_counts_internal(rvals, dropna=False)
+    (l_count, r_count) = l_count.align(r_count, fill_value=0)
+    final_count = np.maximum(l_count.values, r_count.values)
+    final_count = Series(final_count, index=l_count.index, dtype='int', copy=False)
+    if isinstance(lvals, ABCMultiIndex) and isinstance(rvals, ABCMultiIndex):
+        unique_vals = lvals.append(rvals).unique()
+    else:
+        if isinstance(lvals, ABCIndex):
+            lvals = lvals._values
+        if isinstance(rvals, ABCIndex):
+            rvals = rvals._values
+        combined = concat_compat([lvals, rvals])
+        unique_vals = unique(combined)
+        unique_vals = ensure_wrapped_if_datetimelike(unique_vals)
+    repeats = final_count.reindex(unique_vals).values
+    return np.repeat(unique_vals, repeats)
+
+def map_array(arr: ArrayLike, mapper, na_action: Literal['ignore'] | None=None) -> np.ndarray | ExtensionArray | Index:
+    if na_action not in (None, 'ignore'):
+        msg = f"na_action must either be 'ignore' or None, {na_action} was passed"
+        raise ValueError(msg)
+    if is_dict_like(mapper):
+        if isinstance(mapper, dict) and hasattr(mapper, '__missing__'):
+            dict_with_default = mapper
+            mapper = lambda x: dict_with_default[np.nan if isinstance(x, float) and np.isnan(x) else x]
+        else:
+            from pandas import Series
+            if len(mapper) == 0:
+                mapper = Series(mapper, dtype=np.float64)
+            else:
+                mapper = Series(mapper)
+    if isinstance(mapper, ABCSeries):
+        if na_action == 'ignore':
+            mapper = mapper[mapper.index.notna()]
+        indexer = mapper.index.get_indexer(arr)
+        new_values = take_nd(mapper._values, indexer)
+        return new_values
+    if not len(arr):
+        return arr.copy()
+    values = arr.astype(object, copy=False)
+    if na_action is None:
+        return lib.map_infer(values, mapper)
+    else:
+        return lib.map_infer_mask(values, mapper, mask=isna(values).view(np.uint8))
+
+# File: pandas-main/pandas/core/api.py
+from pandas._libs import NaT, Period, Timedelta, Timestamp
+from pandas._libs.missing import NA
+from pandas.core.dtypes.dtypes import ArrowDtype, CategoricalDtype, DatetimeTZDtype, IntervalDtype, PeriodDtype
+from pandas.core.dtypes.missing import isna, isnull, notna, notnull
+from pandas.core.algorithms import factorize, unique
+from pandas.core.arrays import Categorical
+from pandas.core.arrays.boolean import BooleanDtype
+from pandas.core.arrays.floating import Float32Dtype, Float64Dtype
+from pandas.core.arrays.integer import Int8Dtype, Int16Dtype, Int32Dtype, Int64Dtype, UInt8Dtype, UInt16Dtype, UInt32Dtype, UInt64Dtype
+from pandas.core.arrays.string_ import StringDtype
+from pandas.core.construction import array
+from pandas.core.flags import Flags
+from pandas.core.groupby import Grouper, NamedAgg
+from pandas.core.indexes.api import CategoricalIndex, DatetimeIndex, Index, IntervalIndex, MultiIndex, PeriodIndex, RangeIndex, TimedeltaIndex
+from pandas.core.indexes.datetimes import bdate_range, date_range
+from pandas.core.indexes.interval import Interval, interval_range
+from pandas.core.indexes.period import period_range
+from pandas.core.indexes.timedeltas import timedelta_range
+from pandas.core.indexing import IndexSlice
+from pandas.core.series import Series
+from pandas.core.tools.datetimes import to_datetime
+from pandas.core.tools.numeric import to_numeric
+from pandas.core.tools.timedeltas import to_timedelta
+from pandas.io.formats.format import set_eng_float_format
+from pandas.tseries.offsets import DateOffset
+from pandas.core.frame import DataFrame
+__all__ = ['array', 'ArrowDtype', 'bdate_range', 'BooleanDtype', 'Categorical', 'CategoricalDtype', 'CategoricalIndex', 'DataFrame', 'DateOffset', 'date_range', 'DatetimeIndex', 'DatetimeTZDtype', 'factorize', 'Flags', 'Float32Dtype', 'Float64Dtype', 'Grouper', 'Index', 'IndexSlice', 'Int16Dtype', 'Int32Dtype', 'Int64Dtype', 'Int8Dtype', 'Interval', 'IntervalDtype', 'IntervalIndex', 'interval_range', 'isna', 'isnull', 'MultiIndex', 'NA', 'NamedAgg', 'NaT', 'notna', 'notnull', 'Period', 'PeriodDtype', 'PeriodIndex', 'period_range', 'RangeIndex', 'Series', 'set_eng_float_format', 'StringDtype', 'Timedelta', 'TimedeltaIndex', 'timedelta_range', 'Timestamp', 'to_datetime', 'to_numeric', 'to_timedelta', 'UInt16Dtype', 'UInt32Dtype', 'UInt64Dtype', 'UInt8Dtype', 'unique']
+
+# File: pandas-main/pandas/core/apply.py
+from __future__ import annotations
+import abc
+from collections import defaultdict
+from collections.abc import Callable
+import functools
+from functools import partial
+import inspect
+from typing import TYPE_CHECKING, Any, Literal, cast
+import numpy as np
+from pandas._libs.internals import BlockValuesRefs
+from pandas._typing import AggFuncType, AggFuncTypeBase, AggFuncTypeDict, AggObjType, Axis, AxisInt, NDFrameT, npt
+from pandas.compat._optional import import_optional_dependency
+from pandas.errors import SpecificationError
+from pandas.util._decorators import cache_readonly
+from pandas.core.dtypes.cast import is_nested_object
+from pandas.core.dtypes.common import is_dict_like, is_extension_array_dtype, is_list_like, is_numeric_dtype, is_sequence
+from pandas.core.dtypes.dtypes import CategoricalDtype, ExtensionDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCNDFrame, ABCSeries
+from pandas.core._numba.executor import generate_apply_looper
+import pandas.core.common as com
+from pandas.core.construction import ensure_wrapped_if_datetimelike
+from pandas.core.util.numba_ import get_jit_arguments, prepare_function_arguments
+if TYPE_CHECKING:
+    from collections.abc import Generator, Hashable, Iterable, MutableMapping, Sequence
+    from pandas import DataFrame, Index, Series
+    from pandas.core.groupby import GroupBy
+    from pandas.core.resample import Resampler
+    from pandas.core.window.rolling import BaseWindow
+ResType = dict[int, Any]
+
+def frame_apply(obj: DataFrame, func: AggFuncType, axis: Axis=0, raw: bool=False, result_type: str | None=None, by_row: Literal[False, 'compat']='compat', engine: str='python', engine_kwargs: dict[str, bool] | None=None, args=None, kwargs=None) -> FrameApply:
+    (_, func, columns, _) = reconstruct_func(func, **kwargs)
+    axis = obj._get_axis_number(axis)
+    klass: type[FrameApply]
+    if axis == 0:
+        klass = FrameRowApply
+    elif axis == 1:
+        if columns:
+            raise NotImplementedError(f'Named aggregation is not supported when axis={axis!r}.')
+        klass = FrameColumnApply
+    return klass(obj, func, raw=raw, result_type=result_type, by_row=by_row, engine=engine, engine_kwargs=engine_kwargs, args=args, kwargs=kwargs)
+
+class Apply(metaclass=abc.ABCMeta):
+    axis: AxisInt
+
+    def __init__(self, obj: AggObjType, func: AggFuncType, raw: bool, result_type: str | None, *, by_row: Literal[False, 'compat', '_compat']='compat', engine: str='python', engine_kwargs: dict[str, bool] | None=None, args, kwargs) -> None:
+        self.obj = obj
+        self.raw = raw
+        assert by_row is False or by_row in ['compat', '_compat']
+        self.by_row = by_row
+        self.args = args or ()
+        self.kwargs = kwargs or {}
+        self.engine = engine
+        self.engine_kwargs = {} if engine_kwargs is None else engine_kwargs
+        if result_type not in [None, 'reduce', 'broadcast', 'expand']:
+            raise ValueError("invalid value for result_type, must be one of {None, 'reduce', 'broadcast', 'expand'}")
+        self.result_type = result_type
+        self.func = func
+
+    @abc.abstractmethod
+    def apply(self) -> DataFrame | Series:
+        pass
+
+    @abc.abstractmethod
+    def agg_or_apply_list_like(self, op_name: Literal['agg', 'apply']) -> DataFrame | Series:
+        pass
+
+    @abc.abstractmethod
+    def agg_or_apply_dict_like(self, op_name: Literal['agg', 'apply']) -> DataFrame | Series:
+        pass
+
+    def agg(self) -> DataFrame | Series | None:
+        func = self.func
+        if isinstance(func, str):
+            return self.apply_str()
+        if is_dict_like(func):
+            return self.agg_dict_like()
+        elif is_list_like(func):
+            return self.agg_list_like()
+        return None
+
+    def transform(self) -> DataFrame | Series:
+        obj = self.obj
+        func = self.func
+        axis = self.axis
+        args = self.args
+        kwargs = self.kwargs
+        is_series = obj.ndim == 1
+        if obj._get_axis_number(axis) == 1:
+            assert not is_series
+            return obj.T.transform(func, 0, *args, **kwargs).T
+        if is_list_like(func) and (not is_dict_like(func)):
+            func = cast(list[AggFuncTypeBase], func)
+            if is_series:
+                func = {com.get_callable_name(v) or v: v for v in func}
+            else:
+                func = {col: func for col in obj}
+        if is_dict_like(func):
+            func = cast(AggFuncTypeDict, func)
+            return self.transform_dict_like(func)
+        func = cast(AggFuncTypeBase, func)
+        try:
+            result = self.transform_str_or_callable(func)
+        except TypeError:
+            raise
+        except Exception as err:
+            raise ValueError('Transform function failed') from err
+        if isinstance(result, (ABCSeries, ABCDataFrame)) and result.empty and (not obj.empty):
+            raise ValueError('Transform function failed')
+        if not isinstance(result, (ABCSeries, ABCDataFrame)) or not result.index.equals(obj.index):
+            raise ValueError('Function did not transform')
+        return result
+
+    def transform_dict_like(self, func) -> DataFrame:
+        from pandas.core.reshape.concat import concat
+        obj = self.obj
+        args = self.args
+        kwargs = self.kwargs
+        assert isinstance(obj, ABCNDFrame)
+        if len(func) == 0:
+            raise ValueError('No transform functions were provided')
+        func = self.normalize_dictlike_arg('transform', obj, func)
+        results: dict[Hashable, DataFrame | Series] = {}
+        for (name, how) in func.items():
+            colg = obj._gotitem(name, ndim=1)
+            results[name] = colg.transform(how, 0, *args, **kwargs)
+        return concat(results, axis=1)
+
+    def transform_str_or_callable(self, func) -> DataFrame | Series:
+        obj = self.obj
+        args = self.args
+        kwargs = self.kwargs
+        if isinstance(func, str):
+            return self._apply_str(obj, func, *args, **kwargs)
+        try:
+            return obj.apply(func, args=args, **kwargs)
+        except Exception:
+            return func(obj, *args, **kwargs)
+
+    def agg_list_like(self) -> DataFrame | Series:
+        return self.agg_or_apply_list_like(op_name='agg')
+
+    def compute_list_like(self, op_name: Literal['agg', 'apply'], selected_obj: Series | DataFrame, kwargs: dict[str, Any]) -> tuple[list[Hashable] | Index, list[Any]]:
+        func = cast(list[AggFuncTypeBase], self.func)
+        obj = self.obj
+        results = []
+        keys = []
+        if selected_obj.ndim == 1:
+            for a in func:
+                colg = obj._gotitem(selected_obj.name, ndim=1, subset=selected_obj)
+                args = [self.axis, *self.args] if include_axis(op_name, colg) else self.args
+                new_res = getattr(colg, op_name)(a, *args, **kwargs)
+                results.append(new_res)
+                name = com.get_callable_name(a) or a
+                keys.append(name)
+        else:
+            indices = []
+            for (index, col) in enumerate(selected_obj):
+                colg = obj._gotitem(col, ndim=1, subset=selected_obj.iloc[:, index])
+                args = [self.axis, *self.args] if include_axis(op_name, colg) else self.args
+                new_res = getattr(colg, op_name)(func, *args, **kwargs)
+                results.append(new_res)
+                indices.append(index)
+            keys = selected_obj.columns.take(indices)
+        return (keys, results)
+
+    def wrap_results_list_like(self, keys: Iterable[Hashable], results: list[Series | DataFrame]):
+        from pandas.core.reshape.concat import concat
+        obj = self.obj
+        try:
+            return concat(results, keys=keys, axis=1, sort=False)
+        except TypeError as err:
+            from pandas import Series
+            result = Series(results, index=keys, name=obj.name)
+            if is_nested_object(result):
+                raise ValueError('cannot combine transform and aggregation operations') from err
+            return result
+
+    def agg_dict_like(self) -> DataFrame | Series:
+        return self.agg_or_apply_dict_like(op_name='agg')
+
+    def compute_dict_like(self, op_name: Literal['agg', 'apply'], selected_obj: Series | DataFrame, selection: Hashable | Sequence[Hashable], kwargs: dict[str, Any]) -> tuple[list[Hashable], list[Any]]:
+        from pandas.core.groupby.generic import DataFrameGroupBy, SeriesGroupBy
+        obj = self.obj
+        is_groupby = isinstance(obj, (DataFrameGroupBy, SeriesGroupBy))
+        func = cast(AggFuncTypeDict, self.func)
+        func = self.normalize_dictlike_arg(op_name, selected_obj, func)
+        is_non_unique_col = selected_obj.ndim == 2 and selected_obj.columns.nunique() < len(selected_obj.columns)
+        if selected_obj.ndim == 1:
+            colg = obj._gotitem(selection, ndim=1)
+            results = [getattr(colg, op_name)(how, **kwargs) for (_, how) in func.items()]
+            keys = list(func.keys())
+        elif not is_groupby and is_non_unique_col:
+            results = []
+            keys = []
+            for (key, how) in func.items():
+                indices = selected_obj.columns.get_indexer_for([key])
+                labels = selected_obj.columns.take(indices)
+                label_to_indices = defaultdict(list)
+                for (index, label) in zip(indices, labels):
+                    label_to_indices[label].append(index)
+                key_data = [getattr(selected_obj._ixs(indice, axis=1), op_name)(how, **kwargs) for (label, indices) in label_to_indices.items() for indice in indices]
+                keys += [key] * len(key_data)
+                results += key_data
+        elif is_groupby:
+            df = selected_obj
+            (results, keys) = ([], [])
+            for (key, how) in func.items():
+                cols = df[key]
+                if cols.ndim == 1:
+                    series = obj._gotitem(key, ndim=1, subset=cols)
+                    results.append(getattr(series, op_name)(how, **kwargs))
+                    keys.append(key)
+                else:
+                    for (_, col) in cols.items():
+                        series = obj._gotitem(key, ndim=1, subset=col)
+                        results.append(getattr(series, op_name)(how, **kwargs))
+                        keys.append(key)
+        else:
+            results = [getattr(obj._gotitem(key, ndim=1), op_name)(how, **kwargs) for (key, how) in func.items()]
+            keys = list(func.keys())
+        return (keys, results)
+
+    def wrap_results_dict_like(self, selected_obj: Series | DataFrame, result_index: list[Hashable], result_data: list):
+        from pandas import Index
+        from pandas.core.reshape.concat import concat
+        obj = self.obj
+        is_ndframe = [isinstance(r, ABCNDFrame) for r in result_data]
+        if all(is_ndframe):
+            results = [result for result in result_data if not result.empty]
+            keys_to_use: Iterable[Hashable]
+            keys_to_use = [k for (k, v) in zip(result_index, result_data) if not v.empty]
+            if keys_to_use == []:
+                keys_to_use = result_index
+                results = result_data
+            if selected_obj.ndim == 2:
+                ktu = Index(keys_to_use)
+                ktu._set_names(selected_obj.columns.names)
+                keys_to_use = ktu
+            axis: AxisInt = 0 if isinstance(obj, ABCSeries) else 1
+            result = concat(results, axis=axis, keys=keys_to_use)
+        elif any(is_ndframe):
+            raise ValueError('cannot perform both aggregation and transformation operations simultaneously')
+        else:
+            from pandas import Series
+            if obj.ndim == 1:
+                obj = cast('Series', obj)
+                name = obj.name
+            else:
+                name = None
+            result = Series(result_data, index=result_index, name=name)
+        return result
+
+    def apply_str(self) -> DataFrame | Series:
+        func = cast(str, self.func)
+        obj = self.obj
+        from pandas.core.groupby.generic import DataFrameGroupBy, SeriesGroupBy
+        method = getattr(obj, func, None)
+        if callable(method):
+            sig = inspect.getfullargspec(method)
+            arg_names = (*sig.args, *sig.kwonlyargs)
+            if self.axis != 0 and ('axis' not in arg_names or func in ('corrwith', 'skew')):
+                raise ValueError(f'Operation {func} does not support axis=1')
+            if 'axis' in arg_names and (not isinstance(obj, (SeriesGroupBy, DataFrameGroupBy))):
+                self.kwargs['axis'] = self.axis
+        return self._apply_str(obj, func, *self.args, **self.kwargs)
+
+    def apply_list_or_dict_like(self) -> DataFrame | Series:
+        if self.engine == 'numba':
+            raise NotImplementedError("The 'numba' engine doesn't support list-like/dict likes of callables yet.")
+        if self.axis == 1 and isinstance(self.obj, ABCDataFrame):
+            return self.obj.T.apply(self.func, 0, args=self.args, **self.kwargs).T
+        func = self.func
+        kwargs = self.kwargs
+        if is_dict_like(func):
+            result = self.agg_or_apply_dict_like(op_name='apply')
+        else:
+            result = self.agg_or_apply_list_like(op_name='apply')
+        result = reconstruct_and_relabel_result(result, func, **kwargs)
+        return result
+
+    def normalize_dictlike_arg(self, how: str, obj: DataFrame | Series, func: AggFuncTypeDict) -> AggFuncTypeDict:
+        assert how in ('apply', 'agg', 'transform')
+        if how == 'agg' and isinstance(obj, ABCSeries) and any((is_list_like(v) for (_, v) in func.items())) or any((is_dict_like(v) for (_, v) in func.items())):
+            raise SpecificationError('nested renamer is not supported')
+        if obj.ndim != 1:
+            from pandas import Index
+            cols = Index(list(func.keys())).difference(obj.columns, sort=True)
+            if len(cols) > 0:
+                raise KeyError(f'Label(s) {list(cols)} do not exist')
+        aggregator_types = (list, tuple, dict)
+        if any((isinstance(x, aggregator_types) for (_, x) in func.items())):
+            new_func: AggFuncTypeDict = {}
+            for (k, v) in func.items():
+                if not isinstance(v, aggregator_types):
+                    new_func[k] = [v]
+                else:
+                    new_func[k] = v
+            func = new_func
+        return func
+
+    def _apply_str(self, obj, func: str, *args, **kwargs):
+        assert isinstance(func, str)
+        if hasattr(obj, func):
+            f = getattr(obj, func)
+            if callable(f):
+                return f(*args, **kwargs)
+            assert len(args) == 0
+            assert not any((kwarg == 'axis' for kwarg in kwargs))
+            return f
+        elif hasattr(np, func) and hasattr(obj, '__array__'):
+            f = getattr(np, func)
+            return f(obj, *args, **kwargs)
+        else:
+            msg = f"'{func}' is not a valid function for '{type(obj).__name__}' object"
+            raise AttributeError(msg)
+
+class NDFrameApply(Apply):
+    obj: DataFrame | Series
+
+    @property
+    def index(self) -> Index:
+        return self.obj.index
+
+    @property
+    def agg_axis(self) -> Index:
+        return self.obj._get_agg_axis(self.axis)
+
+    def agg_or_apply_list_like(self, op_name: Literal['agg', 'apply']) -> DataFrame | Series:
+        obj = self.obj
+        kwargs = self.kwargs
+        if op_name == 'apply':
+            if isinstance(self, FrameApply):
+                by_row = self.by_row
+            elif isinstance(self, SeriesApply):
+                by_row = '_compat' if self.by_row else False
+            else:
+                by_row = False
+            kwargs = {**kwargs, 'by_row': by_row}
+        if getattr(obj, 'axis', 0) == 1:
+            raise NotImplementedError('axis other than 0 is not supported')
+        (keys, results) = self.compute_list_like(op_name, obj, kwargs)
+        result = self.wrap_results_list_like(keys, results)
+        return result
+
+    def agg_or_apply_dict_like(self, op_name: Literal['agg', 'apply']) -> DataFrame | Series:
+        assert op_name in ['agg', 'apply']
+        obj = self.obj
+        kwargs = {}
+        if op_name == 'apply':
+            by_row = '_compat' if self.by_row else False
+            kwargs.update({'by_row': by_row})
+        if getattr(obj, 'axis', 0) == 1:
+            raise NotImplementedError('axis other than 0 is not supported')
+        selection = None
+        (result_index, result_data) = self.compute_dict_like(op_name, obj, selection, kwargs)
+        result = self.wrap_results_dict_like(obj, result_index, result_data)
+        return result
+
+class FrameApply(NDFrameApply):
+    obj: DataFrame
+
+    def __init__(self, obj: AggObjType, func: AggFuncType, raw: bool, result_type: str | None, *, by_row: Literal[False, 'compat']=False, engine: str='python', engine_kwargs: dict[str, bool] | None=None, args, kwargs) -> None:
+        if by_row is not False and by_row != 'compat':
+            raise ValueError(f'by_row={by_row} not allowed')
+        super().__init__(obj, func, raw, result_type, by_row=by_row, engine=engine, engine_kwargs=engine_kwargs, args=args, kwargs=kwargs)
+
+    @property
+    @abc.abstractmethod
+    def result_index(self) -> Index:
+        pass
+
+    @property
+    @abc.abstractmethod
+    def result_columns(self) -> Index:
+        pass
+
+    @property
+    @abc.abstractmethod
+    def series_generator(self) -> Generator[Series, None, None]:
+        pass
+
+    @staticmethod
+    @functools.cache
+    @abc.abstractmethod
+    def generate_numba_apply_func(func, nogil=True, nopython=True, parallel=False) -> Callable[[npt.NDArray, Index, Index], dict[int, Any]]:
+        pass
+
+    @abc.abstractmethod
+    def apply_with_numba(self):
+        pass
+
+    def validate_values_for_numba(self) -> None:
+        for (colname, dtype) in self.obj.dtypes.items():
+            if not is_numeric_dtype(dtype):
+                raise ValueError(f"Column {colname} must have a numeric dtype. Found '{dtype}' instead")
+            if is_extension_array_dtype(dtype):
+                raise ValueError(f'Column {colname} is backed by an extension array, which is not supported by the numba engine.')
+
+    @abc.abstractmethod
+    def wrap_results_for_axis(self, results: ResType, res_index: Index) -> DataFrame | Series:
+        pass
+
+    @property
+    def res_columns(self) -> Index:
+        return self.result_columns
+
+    @property
+    def columns(self) -> Index:
+        return self.obj.columns
+
+    @cache_readonly
+    def values(self):
+        return self.obj.values
+
+    def apply(self) -> DataFrame | Series:
+        if is_list_like(self.func):
+            if self.engine == 'numba':
+                raise NotImplementedError("the 'numba' engine doesn't support lists of callables yet")
+            return self.apply_list_or_dict_like()
+        if len(self.columns) == 0 and len(self.index) == 0:
+            return self.apply_empty_result()
+        if isinstance(self.func, str):
+            if self.engine == 'numba':
+                raise NotImplementedError("the 'numba' engine doesn't support using a string as the callable function")
+            return self.apply_str()
+        elif isinstance(self.func, np.ufunc):
+            if self.engine == 'numba':
+                raise NotImplementedError("the 'numba' engine doesn't support using a numpy ufunc as the callable function")
+            with np.errstate(all='ignore'):
+                results = self.obj._mgr.apply('apply', func=self.func)
+            return self.obj._constructor_from_mgr(results, axes=results.axes)
+        if self.result_type == 'broadcast':
+            if self.engine == 'numba':
+                raise NotImplementedError("the 'numba' engine doesn't support result_type='broadcast'")
+            return self.apply_broadcast(self.obj)
+        elif not all(self.obj.shape):
+            return self.apply_empty_result()
+        elif self.raw:
+            return self.apply_raw(engine=self.engine, engine_kwargs=self.engine_kwargs)
+        return self.apply_standard()
+
+    def agg(self):
+        obj = self.obj
+        axis = self.axis
+        self.obj = self.obj if self.axis == 0 else self.obj.T
+        self.axis = 0
+        result = None
+        try:
+            result = super().agg()
+        finally:
+            self.obj = obj
+            self.axis = axis
+        if axis == 1:
+            result = result.T if result is not None else result
+        if result is None:
+            result = self.obj.apply(self.func, axis, args=self.args, **self.kwargs)
+        return result
+
+    def apply_empty_result(self):
+        assert callable(self.func)
+        if self.result_type not in ['reduce', None]:
+            return self.obj.copy()
+        should_reduce = self.result_type == 'reduce'
+        from pandas import Series
+        if not should_reduce:
+            try:
+                if self.axis == 0:
+                    r = self.func(Series([], dtype=np.float64), *self.args, **self.kwargs)
+                else:
+                    r = self.func(Series(index=self.columns, dtype=np.float64), *self.args, **self.kwargs)
+            except Exception:
+                pass
+            else:
+                should_reduce = not isinstance(r, Series)
+        if should_reduce:
+            if len(self.agg_axis):
+                r = self.func(Series([], dtype=np.float64), *self.args, **self.kwargs)
+            else:
+                r = np.nan
+            return self.obj._constructor_sliced(r, index=self.agg_axis)
+        else:
+            return self.obj.copy()
+
+    def apply_raw(self, engine='python', engine_kwargs=None):
+
+        def wrap_function(func):
+
+            def wrapper(*args, **kwargs):
+                result = func(*args, **kwargs)
+                if isinstance(result, str):
+                    result = np.array(result, dtype=object)
+                return result
+            return wrapper
+        if engine == 'numba':
+            (args, kwargs) = prepare_function_arguments(self.func, self.args, self.kwargs)
+            nb_looper = generate_apply_looper(self.func, **get_jit_arguments(engine_kwargs, kwargs))
+            result = nb_looper(self.values, self.axis, *args)
+            result = np.squeeze(result)
+        else:
+            result = np.apply_along_axis(wrap_function(self.func), self.axis, self.values, *self.args, **self.kwargs)
+        if result.ndim == 2:
+            return self.obj._constructor(result, index=self.index, columns=self.columns)
+        else:
+            return self.obj._constructor_sliced(result, index=self.agg_axis)
+
+    def apply_broadcast(self, target: DataFrame) -> DataFrame:
+        assert callable(self.func)
+        result_values = np.empty_like(target.values)
+        result_compare = target.shape[0]
+        for (i, col) in enumerate(target.columns):
+            res = self.func(target[col], *self.args, **self.kwargs)
+            ares = np.asarray(res).ndim
+            if ares > 1:
+                raise ValueError('too many dims to broadcast')
+            if ares == 1:
+                if result_compare != len(res):
+                    raise ValueError('cannot broadcast result')
+            result_values[:, i] = res
+        result = self.obj._constructor(result_values, index=target.index, columns=target.columns)
+        return result
+
+    def apply_standard(self):
+        if self.engine == 'python':
+            (results, res_index) = self.apply_series_generator()
+        else:
+            (results, res_index) = self.apply_series_numba()
+        return self.wrap_results(results, res_index)
+
+    def apply_series_generator(self) -> tuple[ResType, Index]:
+        assert callable(self.func)
+        series_gen = self.series_generator
+        res_index = self.result_index
+        results = {}
+        for (i, v) in enumerate(series_gen):
+            results[i] = self.func(v, *self.args, **self.kwargs)
+            if isinstance(results[i], ABCSeries):
+                results[i] = results[i].copy(deep=False)
+        return (results, res_index)
+
+    def apply_series_numba(self):
+        if self.engine_kwargs.get('parallel', False):
+            raise NotImplementedError("Parallel apply is not supported when raw=False and engine='numba'")
+        if not self.obj.index.is_unique or not self.columns.is_unique:
+            raise NotImplementedError("The index/columns must be unique when raw=False and engine='numba'")
+        self.validate_values_for_numba()
+        results = self.apply_with_numba()
+        return (results, self.result_index)
+
+    def wrap_results(self, results: ResType, res_index: Index) -> DataFrame | Series:
+        from pandas import Series
+        if len(results) > 0 and 0 in results and is_sequence(results[0]):
+            return self.wrap_results_for_axis(results, res_index)
+        constructor_sliced = self.obj._constructor_sliced
+        if len(results) == 0 and constructor_sliced is Series:
+            result = constructor_sliced(results, dtype=np.float64)
+        else:
+            result = constructor_sliced(results)
+        result.index = res_index
+        return result
+
+    def apply_str(self) -> DataFrame | Series:
+        if self.func == 'size':
+            obj = self.obj
+            value = obj.shape[self.axis]
+            return obj._constructor_sliced(value, index=self.agg_axis)
+        return super().apply_str()
+
+class FrameRowApply(FrameApply):
+    axis: AxisInt = 0
+
+    @property
+    def series_generator(self) -> Generator[Series, None, None]:
+        return (self.obj._ixs(i, axis=1) for i in range(len(self.columns)))
+
+    @staticmethod
+    @functools.cache
+    def generate_numba_apply_func(func, nogil=True, nopython=True, parallel=False) -> Callable[[npt.NDArray, Index, Index], dict[int, Any]]:
+        numba = import_optional_dependency('numba')
+        from pandas import Series
+        from pandas.core._numba.extensions import maybe_cast_str
+        jitted_udf = numba.extending.register_jitable(func)
+
+        @numba.jit(nogil=nogil, nopython=nopython, parallel=parallel)
+        def numba_func(values, col_names, df_index, *args):
+            results = {}
+            for j in range(values.shape[1]):
+                ser = Series(values[:, j], index=df_index, name=maybe_cast_str(col_names[j]))
+                results[j] = jitted_udf(ser, *args)
+            return results
+        return numba_func
+
+    def apply_with_numba(self) -> dict[int, Any]:
+        func = cast(Callable, self.func)
+        (args, kwargs) = prepare_function_arguments(func, self.args, self.kwargs)
+        nb_func = self.generate_numba_apply_func(func, **get_jit_arguments(self.engine_kwargs, kwargs))
+        from pandas.core._numba.extensions import set_numba_data
+        index = self.obj.index
+        if index.dtype == 'string':
+            index = index.astype(object)
+        columns = self.obj.columns
+        if columns.dtype == 'string':
+            columns = columns.astype(object)
+        with set_numba_data(index) as index, set_numba_data(columns) as columns:
+            res = dict(nb_func(self.values, columns, index, *args))
+        return res
+
+    @property
+    def result_index(self) -> Index:
+        return self.columns
+
+    @property
+    def result_columns(self) -> Index:
+        return self.index
+
+    def wrap_results_for_axis(self, results: ResType, res_index: Index) -> DataFrame | Series:
+        if self.result_type == 'reduce':
+            res = self.obj._constructor_sliced(results)
+            res.index = res_index
+            return res
+        elif self.result_type is None and all((isinstance(x, dict) for x in results.values())):
+            res = self.obj._constructor_sliced(results)
+            res.index = res_index
+            return res
+        try:
+            result = self.obj._constructor(data=results)
+        except ValueError as err:
+            if 'All arrays must be of the same length' in str(err):
+                res = self.obj._constructor_sliced(results)
+                res.index = res_index
+                return res
+            else:
+                raise
+        if not isinstance(results[0], ABCSeries):
+            if len(result.index) == len(self.res_columns):
+                result.index = self.res_columns
+        if len(result.columns) == len(res_index):
+            result.columns = res_index
+        return result
+
+class FrameColumnApply(FrameApply):
+    axis: AxisInt = 1
+
+    def apply_broadcast(self, target: DataFrame) -> DataFrame:
+        result = super().apply_broadcast(target.T)
+        return result.T
+
+    @property
+    def series_generator(self) -> Generator[Series, None, None]:
+        values = self.values
+        values = ensure_wrapped_if_datetimelike(values)
+        assert len(values) > 0
+        ser = self.obj._ixs(0, axis=0)
+        mgr = ser._mgr
+        is_view = mgr.blocks[0].refs.has_reference()
+        if isinstance(ser.dtype, ExtensionDtype):
+            obj = self.obj
+            for i in range(len(obj)):
+                yield obj._ixs(i, axis=0)
+        else:
+            for (arr, name) in zip(values, self.index):
+                ser._mgr = mgr
+                mgr.set_values(arr)
+                object.__setattr__(ser, '_name', name)
+                if not is_view:
+                    mgr.blocks[0].refs = BlockValuesRefs(mgr.blocks[0])
+                yield ser
+
+    @staticmethod
+    @functools.cache
+    def generate_numba_apply_func(func, nogil=True, nopython=True, parallel=False) -> Callable[[npt.NDArray, Index, Index], dict[int, Any]]:
+        numba = import_optional_dependency('numba')
+        from pandas import Series
+        from pandas.core._numba.extensions import maybe_cast_str
+        jitted_udf = numba.extending.register_jitable(func)
+
+        @numba.jit(nogil=nogil, nopython=nopython, parallel=parallel)
+        def numba_func(values, col_names_index, index, *args):
+            results = {}
+            for i in range(values.shape[0]):
+                ser = Series(values[i].copy(), index=col_names_index, name=maybe_cast_str(index[i]))
+                results[i] = jitted_udf(ser, *args)
+            return results
+        return numba_func
+
+    def apply_with_numba(self) -> dict[int, Any]:
+        func = cast(Callable, self.func)
+        (args, kwargs) = prepare_function_arguments(func, self.args, self.kwargs)
+        nb_func = self.generate_numba_apply_func(func, **get_jit_arguments(self.engine_kwargs, kwargs))
+        from pandas.core._numba.extensions import set_numba_data
+        with set_numba_data(self.obj.index) as index, set_numba_data(self.columns) as columns:
+            res = dict(nb_func(self.values, columns, index, *args))
+        return res
+
+    @property
+    def result_index(self) -> Index:
+        return self.index
+
+    @property
+    def result_columns(self) -> Index:
+        return self.columns
+
+    def wrap_results_for_axis(self, results: ResType, res_index: Index) -> DataFrame | Series:
+        result: DataFrame | Series
+        if self.result_type == 'expand':
+            result = self.infer_to_same_shape(results, res_index)
+        elif not isinstance(results[0], ABCSeries):
+            result = self.obj._constructor_sliced(results)
+            result.index = res_index
+        else:
+            result = self.infer_to_same_shape(results, res_index)
+        return result
+
+    def infer_to_same_shape(self, results: ResType, res_index: Index) -> DataFrame:
+        result = self.obj._constructor(data=results)
+        result = result.T
+        result.index = res_index
+        result = result.infer_objects()
+        return result
+
+class SeriesApply(NDFrameApply):
+    obj: Series
+    axis: AxisInt = 0
+    by_row: Literal[False, 'compat', '_compat']
+
+    def __init__(self, obj: Series, func: AggFuncType, *, by_row: Literal[False, 'compat', '_compat']='compat', args, kwargs) -> None:
+        super().__init__(obj, func, raw=False, result_type=None, by_row=by_row, args=args, kwargs=kwargs)
+
+    def apply(self) -> DataFrame | Series:
+        obj = self.obj
+        if len(obj) == 0:
+            return self.apply_empty_result()
+        if is_list_like(self.func):
+            return self.apply_list_or_dict_like()
+        if isinstance(self.func, str):
+            return self.apply_str()
+        if self.by_row == '_compat':
+            return self.apply_compat()
+        return self.apply_standard()
+
+    def agg(self):
+        result = super().agg()
+        if result is None:
+            obj = self.obj
+            func = self.func
+            assert callable(func)
+            result = func(obj, *self.args, **self.kwargs)
+        return result
+
+    def apply_empty_result(self) -> Series:
+        obj = self.obj
+        return obj._constructor(dtype=obj.dtype, index=obj.index).__finalize__(obj, method='apply')
+
+    def apply_compat(self):
+        obj = self.obj
+        func = self.func
+        if callable(func):
+            f = com.get_cython_func(func)
+            if f and (not self.args) and (not self.kwargs):
+                return obj.apply(func, by_row=False)
+        try:
+            result = obj.apply(func, by_row='compat')
+        except (ValueError, AttributeError, TypeError):
+            result = obj.apply(func, by_row=False)
+        return result
+
+    def apply_standard(self) -> DataFrame | Series:
+        func = cast(Callable, self.func)
+        obj = self.obj
+        if isinstance(func, np.ufunc):
+            with np.errstate(all='ignore'):
+                return func(obj, *self.args, **self.kwargs)
+        elif not self.by_row:
+            return func(obj, *self.args, **self.kwargs)
+        if self.args or self.kwargs:
+
+            def curried(x):
+                return func(x, *self.args, **self.kwargs)
+        else:
+            curried = func
+        action = 'ignore' if isinstance(obj.dtype, CategoricalDtype) else None
+        mapped = obj._map_values(mapper=curried, na_action=action)
+        if len(mapped) and isinstance(mapped[0], ABCSeries):
+            return obj._constructor_expanddim(list(mapped), index=obj.index)
+        else:
+            return obj._constructor(mapped, index=obj.index).__finalize__(obj, method='apply')
+
+class GroupByApply(Apply):
+    obj: GroupBy | Resampler | BaseWindow
+
+    def __init__(self, obj: GroupBy[NDFrameT], func: AggFuncType, *, args, kwargs) -> None:
+        kwargs = kwargs.copy()
+        self.axis = obj.obj._get_axis_number(kwargs.get('axis', 0))
+        super().__init__(obj, func, raw=False, result_type=None, args=args, kwargs=kwargs)
+
+    def apply(self):
+        raise NotImplementedError
+
+    def transform(self):
+        raise NotImplementedError
+
+    def agg_or_apply_list_like(self, op_name: Literal['agg', 'apply']) -> DataFrame | Series:
+        obj = self.obj
+        kwargs = self.kwargs
+        if op_name == 'apply':
+            kwargs = {**kwargs, 'by_row': False}
+        if getattr(obj, 'axis', 0) == 1:
+            raise NotImplementedError('axis other than 0 is not supported')
+        if obj._selected_obj.ndim == 1:
+            selected_obj = obj._selected_obj
+        else:
+            selected_obj = obj._obj_with_exclusions
+        with com.temp_setattr(obj, 'as_index', True, condition=hasattr(obj, 'as_index')):
+            (keys, results) = self.compute_list_like(op_name, selected_obj, kwargs)
+        result = self.wrap_results_list_like(keys, results)
+        return result
+
+    def agg_or_apply_dict_like(self, op_name: Literal['agg', 'apply']) -> DataFrame | Series:
+        from pandas.core.groupby.generic import DataFrameGroupBy, SeriesGroupBy
+        assert op_name in ['agg', 'apply']
+        obj = self.obj
+        kwargs = {}
+        if op_name == 'apply':
+            by_row = '_compat' if self.by_row else False
+            kwargs.update({'by_row': by_row})
+        if getattr(obj, 'axis', 0) == 1:
+            raise NotImplementedError('axis other than 0 is not supported')
+        selected_obj = obj._selected_obj
+        selection = obj._selection
+        is_groupby = isinstance(obj, (DataFrameGroupBy, SeriesGroupBy))
+        if is_groupby:
+            engine = self.kwargs.get('engine', None)
+            engine_kwargs = self.kwargs.get('engine_kwargs', None)
+            kwargs.update({'engine': engine, 'engine_kwargs': engine_kwargs})
+        with com.temp_setattr(obj, 'as_index', True, condition=hasattr(obj, 'as_index')):
+            (result_index, result_data) = self.compute_dict_like(op_name, selected_obj, selection, kwargs)
+        result = self.wrap_results_dict_like(selected_obj, result_index, result_data)
+        return result
+
+class ResamplerWindowApply(GroupByApply):
+    axis: AxisInt = 0
+    obj: Resampler | BaseWindow
+
+    def __init__(self, obj: Resampler | BaseWindow, func: AggFuncType, *, args, kwargs) -> None:
+        super(GroupByApply, self).__init__(obj, func, raw=False, result_type=None, args=args, kwargs=kwargs)
+
+    def apply(self):
+        raise NotImplementedError
+
+    def transform(self):
+        raise NotImplementedError
+
+def reconstruct_func(func: AggFuncType | None, **kwargs) -> tuple[bool, AggFuncType, tuple[str, ...] | None, npt.NDArray[np.intp] | None]:
+    relabeling = func is None and is_multi_agg_with_relabel(**kwargs)
+    columns: tuple[str, ...] | None = None
+    order: npt.NDArray[np.intp] | None = None
+    if not relabeling:
+        if isinstance(func, list) and len(func) > len(set(func)):
+            raise SpecificationError('Function names must be unique if there is no new column names assigned')
+        if func is None:
+            raise TypeError("Must provide 'func' or tuples of '(column, aggfunc).")
+    if relabeling:
+        (func, columns, order) = normalize_keyword_aggregation(kwargs)
+    assert func is not None
+    return (relabeling, func, columns, order)
+
+def is_multi_agg_with_relabel(**kwargs) -> bool:
+    return all((isinstance(v, tuple) and len(v) == 2 for v in kwargs.values())) and len(kwargs) > 0
+
+def normalize_keyword_aggregation(kwargs: dict) -> tuple[MutableMapping[Hashable, list[AggFuncTypeBase]], tuple[str, ...], npt.NDArray[np.intp]]:
+    from pandas.core.indexes.base import Index
+    aggspec = defaultdict(list)
+    order = []
+    columns = tuple(kwargs.keys())
+    for (column, aggfunc) in kwargs.values():
+        aggspec[column].append(aggfunc)
+        order.append((column, com.get_callable_name(aggfunc) or aggfunc))
+    uniquified_order = _make_unique_kwarg_list(order)
+    aggspec_order = [(column, com.get_callable_name(aggfunc) or aggfunc) for (column, aggfuncs) in aggspec.items() for aggfunc in aggfuncs]
+    uniquified_aggspec = _make_unique_kwarg_list(aggspec_order)
+    col_idx_order = Index(uniquified_aggspec).get_indexer(uniquified_order)
+    return (aggspec, columns, col_idx_order)
+
+def _make_unique_kwarg_list(seq: Sequence[tuple[Any, Any]]) -> Sequence[tuple[Any, Any]]:
+    return [(pair[0], f'{pair[1]}_{seq[:i].count(pair)}') if seq.count(pair) > 1 else pair for (i, pair) in enumerate(seq)]
+
+def relabel_result(result: DataFrame | Series, func: dict[str, list[Callable | str]], columns: Iterable[Hashable], order: Iterable[int]) -> dict[Hashable, Series]:
+    from pandas.core.indexes.base import Index
+    reordered_indexes = [pair[0] for pair in sorted(zip(columns, order), key=lambda t: t[1])]
+    reordered_result_in_dict: dict[Hashable, Series] = {}
+    idx = 0
+    reorder_mask = not isinstance(result, ABCSeries) and len(result.columns) > 1
+    for (col, fun) in func.items():
+        s = result[col].dropna()
+        if reorder_mask:
+            fun = [com.get_callable_name(f) if not isinstance(f, str) else f for f in fun]
+            col_idx_order = Index(s.index).get_indexer(fun)
+            valid_idx = col_idx_order != -1
+            if valid_idx.any():
+                s = s.iloc[col_idx_order[valid_idx]]
+        if not s.empty:
+            s.index = reordered_indexes[idx:idx + len(fun)]
+        reordered_result_in_dict[col] = s.reindex(columns)
+        idx = idx + len(fun)
+    return reordered_result_in_dict
+
+def reconstruct_and_relabel_result(result, func, **kwargs) -> DataFrame | Series:
+    from pandas import DataFrame
+    (relabeling, func, columns, order) = reconstruct_func(func, **kwargs)
+    if relabeling:
+        assert columns is not None
+        assert order is not None
+        result_in_dict = relabel_result(result, func, columns, order)
+        result = DataFrame(result_in_dict, index=columns)
+    return result
+
+def _managle_lambda_list(aggfuncs: Sequence[Any]) -> Sequence[Any]:
+    if len(aggfuncs) <= 1:
+        return aggfuncs
+    i = 0
+    mangled_aggfuncs = []
+    for aggfunc in aggfuncs:
+        if com.get_callable_name(aggfunc) == '<lambda>':
+            aggfunc = partial(aggfunc)
+            aggfunc.__name__ = f'<lambda_{i}>'
+            i += 1
+        mangled_aggfuncs.append(aggfunc)
+    return mangled_aggfuncs
+
+def maybe_mangle_lambdas(agg_spec: Any) -> Any:
+    is_dict = is_dict_like(agg_spec)
+    if not (is_dict or is_list_like(agg_spec)):
+        return agg_spec
+    mangled_aggspec = type(agg_spec)()
+    if is_dict:
+        for (key, aggfuncs) in agg_spec.items():
+            if is_list_like(aggfuncs) and (not is_dict_like(aggfuncs)):
+                mangled_aggfuncs = _managle_lambda_list(aggfuncs)
+            else:
+                mangled_aggfuncs = aggfuncs
+            mangled_aggspec[key] = mangled_aggfuncs
+    else:
+        mangled_aggspec = _managle_lambda_list(agg_spec)
+    return mangled_aggspec
+
+def validate_func_kwargs(kwargs: dict) -> tuple[list[str], list[str | Callable[..., Any]]]:
+    tuple_given_message = 'func is expected but received {} in **kwargs.'
+    columns = list(kwargs)
+    func = []
+    for col_func in kwargs.values():
+        if not (isinstance(col_func, str) or callable(col_func)):
+            raise TypeError(tuple_given_message.format(type(col_func).__name__))
+        func.append(col_func)
+    if not columns:
+        no_arg_message = "Must provide 'func' or named aggregation **kwargs."
+        raise TypeError(no_arg_message)
+    return (columns, func)
+
+def include_axis(op_name: Literal['agg', 'apply'], colg: Series | DataFrame) -> bool:
+    return isinstance(colg, ABCDataFrame) or (isinstance(colg, ABCSeries) and op_name == 'agg')
+
+# File: pandas-main/pandas/core/array_algos/datetimelike_accumulations.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs import iNaT
+from pandas.core.dtypes.missing import isna
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+def _cum_func(func: Callable, values: np.ndarray, *, skipna: bool=True) -> np.ndarray:
+    try:
+        fill_value = {np.maximum.accumulate: np.iinfo(np.int64).min, np.cumsum: 0, np.minimum.accumulate: np.iinfo(np.int64).max}[func]
+    except KeyError as err:
+        raise ValueError(f'No accumulation for {func} implemented on BaseMaskedArray') from err
+    mask = isna(values)
+    y = values.view('i8')
+    y[mask] = fill_value
+    if not skipna:
+        mask = np.maximum.accumulate(mask)
+    result = func(y, axis=0)
+    result[mask] = iNaT
+    if values.dtype.kind in 'mM':
+        return result.view(values.dtype.base)
+    return result
+
+def cumsum(values: np.ndarray, *, skipna: bool=True) -> np.ndarray:
+    return _cum_func(np.cumsum, values, skipna=skipna)
+
+def cummin(values: np.ndarray, *, skipna: bool=True) -> np.ndarray:
+    return _cum_func(np.minimum.accumulate, values, skipna=skipna)
+
+def cummax(values: np.ndarray, *, skipna: bool=True) -> np.ndarray:
+    return _cum_func(np.maximum.accumulate, values, skipna=skipna)
+
+# File: pandas-main/pandas/core/array_algos/masked_accumulations.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import npt
+
+def _cum_func(func: Callable, values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
+    dtype_info: np.iinfo | np.finfo
+    if values.dtype.kind == 'f':
+        dtype_info = np.finfo(values.dtype.type)
+    elif values.dtype.kind in 'iu':
+        dtype_info = np.iinfo(values.dtype.type)
+    elif values.dtype.kind == 'b':
+        dtype_info = np.iinfo(np.uint8)
+    else:
+        raise NotImplementedError(f'No masked accumulation defined for dtype {values.dtype.type}')
+    try:
+        fill_value = {np.cumprod: 1, np.maximum.accumulate: dtype_info.min, np.cumsum: 0, np.minimum.accumulate: dtype_info.max}[func]
+    except KeyError as err:
+        raise NotImplementedError(f'No accumulation for {func} implemented on BaseMaskedArray') from err
+    values[mask] = fill_value
+    if not skipna:
+        mask = np.maximum.accumulate(mask)
+    values = func(values)
+    return (values, mask)
+
+def cumsum(values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
+    return _cum_func(np.cumsum, values, mask, skipna=skipna)
+
+def cumprod(values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
+    return _cum_func(np.cumprod, values, mask, skipna=skipna)
+
+def cummin(values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
+    return _cum_func(np.minimum.accumulate, values, mask, skipna=skipna)
+
+def cummax(values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
+    return _cum_func(np.maximum.accumulate, values, mask, skipna=skipna)
+
+# File: pandas-main/pandas/core/array_algos/masked_reductions.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import warnings
+import numpy as np
+from pandas._libs import missing as libmissing
+from pandas.core.nanops import check_below_min_count
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import AxisInt, npt
+
+def _reductions(func: Callable, values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True, min_count: int=0, axis: AxisInt | None=None, **kwargs):
+    if not skipna:
+        if mask.any() or check_below_min_count(values.shape, None, min_count):
+            return libmissing.NA
+        else:
+            return func(values, axis=axis, **kwargs)
+    else:
+        if check_below_min_count(values.shape, mask, min_count) and (axis is None or values.ndim == 1):
+            return libmissing.NA
+        return func(values, where=~mask, axis=axis, **kwargs)
+
+def sum(values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True, min_count: int=0, axis: AxisInt | None=None):
+    return _reductions(np.sum, values=values, mask=mask, skipna=skipna, min_count=min_count, axis=axis)
+
+def prod(values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True, min_count: int=0, axis: AxisInt | None=None):
+    return _reductions(np.prod, values=values, mask=mask, skipna=skipna, min_count=min_count, axis=axis)
+
+def _minmax(func: Callable, values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True, axis: AxisInt | None=None):
+    if not skipna:
+        if mask.any() or not values.size:
+            return libmissing.NA
+        else:
+            return func(values, axis=axis)
+    else:
+        subset = values[~mask]
+        if subset.size:
+            return func(subset, axis=axis)
+        else:
+            return libmissing.NA
+
+def min(values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True, axis: AxisInt | None=None):
+    return _minmax(np.min, values=values, mask=mask, skipna=skipna, axis=axis)
+
+def max(values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True, axis: AxisInt | None=None):
+    return _minmax(np.max, values=values, mask=mask, skipna=skipna, axis=axis)
+
+def mean(values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True, axis: AxisInt | None=None):
+    if not values.size or mask.all():
+        return libmissing.NA
+    return _reductions(np.mean, values=values, mask=mask, skipna=skipna, axis=axis)
+
+def var(values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True, axis: AxisInt | None=None, ddof: int=1):
+    if not values.size or mask.all():
+        return libmissing.NA
+    with warnings.catch_warnings():
+        warnings.simplefilter('ignore', RuntimeWarning)
+        return _reductions(np.var, values=values, mask=mask, skipna=skipna, axis=axis, ddof=ddof)
+
+def std(values: np.ndarray, mask: npt.NDArray[np.bool_], *, skipna: bool=True, axis: AxisInt | None=None, ddof: int=1):
+    if not values.size or mask.all():
+        return libmissing.NA
+    with warnings.catch_warnings():
+        warnings.simplefilter('ignore', RuntimeWarning)
+        return _reductions(np.std, values=values, mask=mask, skipna=skipna, axis=axis, ddof=ddof)
+
+# File: pandas-main/pandas/core/array_algos/putmask.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+import numpy as np
+from pandas._libs import lib
+from pandas.core.dtypes.cast import infer_dtype_from
+from pandas.core.dtypes.common import is_list_like
+from pandas.core.arrays import ExtensionArray
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike, npt
+    from pandas import MultiIndex
+
+def putmask_inplace(values: ArrayLike, mask: npt.NDArray[np.bool_], value: Any) -> None:
+    if not isinstance(values, np.ndarray) or (values.dtype == object and (not lib.is_scalar(value))) or (isinstance(value, np.ndarray) and (not np.can_cast(value.dtype, values.dtype))):
+        if is_list_like(value) and len(value) == len(values):
+            values[mask] = value[mask]
+        else:
+            values[mask] = value
+    else:
+        np.putmask(values, mask, value)
+
+def putmask_without_repeat(values: np.ndarray, mask: npt.NDArray[np.bool_], new: Any) -> None:
+    if getattr(new, 'ndim', 0) >= 1:
+        new = new.astype(values.dtype, copy=False)
+    nlocs = mask.sum()
+    if nlocs > 0 and is_list_like(new) and (getattr(new, 'ndim', 1) == 1):
+        shape = np.shape(new)
+        if nlocs == shape[-1]:
+            np.place(values, mask, new)
+        elif mask.shape[-1] == shape[-1] or shape[-1] == 1:
+            np.putmask(values, mask, new)
+        else:
+            raise ValueError('cannot assign mismatch length to masked array')
+    else:
+        np.putmask(values, mask, new)
+
+def validate_putmask(values: ArrayLike | MultiIndex, mask: np.ndarray) -> tuple[npt.NDArray[np.bool_], bool]:
+    mask = extract_bool_array(mask)
+    if mask.shape != values.shape:
+        raise ValueError('putmask: mask and data must be the same size')
+    noop = not mask.any()
+    return (mask, noop)
+
+def extract_bool_array(mask: ArrayLike) -> npt.NDArray[np.bool_]:
+    if isinstance(mask, ExtensionArray):
+        mask = mask.to_numpy(dtype=bool, na_value=False)
+    mask = np.asarray(mask, dtype=bool)
+    return mask
+
+def setitem_datetimelike_compat(values: np.ndarray, num_set: int, other):
+    if values.dtype == object:
+        (dtype, _) = infer_dtype_from(other)
+        if lib.is_np_dtype(dtype, 'mM'):
+            if not is_list_like(other):
+                other = [other] * num_set
+            else:
+                other = list(other)
+    return other
+
+# File: pandas-main/pandas/core/array_algos/quantile.py
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas.core.dtypes.missing import isna, na_value_for_dtype
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike, Scalar, npt
+
+def quantile_compat(values: ArrayLike, qs: npt.NDArray[np.float64], interpolation: str) -> ArrayLike:
+    if isinstance(values, np.ndarray):
+        fill_value = na_value_for_dtype(values.dtype, compat=False)
+        mask = isna(values)
+        return quantile_with_mask(values, mask, fill_value, qs, interpolation)
+    else:
+        return values._quantile(qs, interpolation)
+
+def quantile_with_mask(values: np.ndarray, mask: npt.NDArray[np.bool_], fill_value, qs: npt.NDArray[np.float64], interpolation: str) -> np.ndarray:
+    assert values.shape == mask.shape
+    if values.ndim == 1:
+        values = np.atleast_2d(values)
+        mask = np.atleast_2d(mask)
+        res_values = quantile_with_mask(values, mask, fill_value, qs, interpolation)
+        return res_values[0]
+    assert values.ndim == 2
+    is_empty = values.shape[1] == 0
+    if is_empty:
+        flat = np.full(len(qs), fill_value)
+        result = np.repeat(flat, len(values)).reshape(len(values), len(qs))
+    else:
+        result = _nanquantile(values, qs, na_value=fill_value, mask=mask, interpolation=interpolation)
+        result = np.asarray(result)
+        result = result.T
+    return result
+
+def _nanquantile_1d(values: np.ndarray, mask: npt.NDArray[np.bool_], qs: npt.NDArray[np.float64], na_value: Scalar, interpolation: str) -> Scalar | np.ndarray:
+    values = values[~mask]
+    if len(values) == 0:
+        return np.full(len(qs), na_value)
+    return np.quantile(values, qs, method=interpolation)
+
+def _nanquantile(values: np.ndarray, qs: npt.NDArray[np.float64], *, na_value, mask: npt.NDArray[np.bool_], interpolation: str):
+    if values.dtype.kind in 'mM':
+        result = _nanquantile(values.view('i8'), qs=qs, na_value=na_value.view('i8'), mask=mask, interpolation=interpolation)
+        return result.astype(values.dtype)
+    if mask.any():
+        assert mask.shape == values.shape
+        result = [_nanquantile_1d(val, m, qs, na_value, interpolation=interpolation) for (val, m) in zip(list(values), list(mask))]
+        if values.dtype.kind == 'f':
+            result = np.asarray(result, dtype=values.dtype).T
+        else:
+            result = np.asarray(result).T
+            if result.dtype != values.dtype and (not mask.all()) and (result == result.astype(values.dtype, copy=False)).all():
+                result = result.astype(values.dtype, copy=False)
+        return result
+    else:
+        return np.quantile(values, qs, axis=1, method=interpolation)
+
+# File: pandas-main/pandas/core/array_algos/replace.py
+""""""
+from __future__ import annotations
+import operator
+import re
+from re import Pattern
+from typing import TYPE_CHECKING, Any
+import numpy as np
+from pandas.core.dtypes.common import is_bool, is_re, is_re_compilable
+from pandas.core.dtypes.missing import isna
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike, Scalar, npt
+
+def should_use_regex(regex: bool, to_replace: Any) -> bool:
+    if is_re(to_replace):
+        regex = True
+    regex = regex and is_re_compilable(to_replace)
+    regex = regex and re.compile(to_replace).pattern != ''
+    return regex
+
+def compare_or_regex_search(a: ArrayLike, b: Scalar | Pattern, regex: bool, mask: npt.NDArray[np.bool_]) -> ArrayLike:
+    if isna(b):
+        return ~mask
+
+    def _check_comparison_types(result: ArrayLike | bool, a: ArrayLike, b: Scalar | Pattern) -> None:
+        if is_bool(result) and isinstance(a, np.ndarray):
+            type_names = [type(a).__name__, type(b).__name__]
+            type_names[0] = f'ndarray(dtype={a.dtype})'
+            raise TypeError(f'Cannot compare types {type_names[0]!r} and {type_names[1]!r}')
+    if not regex or not should_use_regex(regex, b):
+        op = lambda x: operator.eq(x, b)
+    else:
+        op = np.vectorize(lambda x: bool(re.search(b, x)) if isinstance(x, str) and isinstance(b, (str, Pattern)) else False)
+    if isinstance(a, np.ndarray) and mask is not None:
+        a = a[mask]
+        result = op(a)
+        if isinstance(result, np.ndarray):
+            tmp = np.zeros(mask.shape, dtype=np.bool_)
+            np.place(tmp, mask, result)
+            result = tmp
+    else:
+        result = op(a)
+    _check_comparison_types(result, a, b)
+    return result
+
+def replace_regex(values: ArrayLike, rx: re.Pattern, value, mask: npt.NDArray[np.bool_] | None) -> None:
+    if isna(value) or not isinstance(value, str):
+
+        def re_replacer(s):
+            if is_re(rx) and isinstance(s, str):
+                return value if rx.search(s) is not None else s
+            else:
+                return s
+    else:
+
+        def re_replacer(s):
+            if is_re(rx) and isinstance(s, str):
+                return rx.sub(value, s)
+            else:
+                return s
+    f = np.vectorize(re_replacer, otypes=[np.object_])
+    if mask is None:
+        values[:] = f(values)
+    else:
+        values[mask] = f(values[mask])
+
+# File: pandas-main/pandas/core/array_algos/take.py
+from __future__ import annotations
+import functools
+from typing import TYPE_CHECKING, cast, overload
+import numpy as np
+from pandas._libs import algos as libalgos, lib
+from pandas.core.dtypes.cast import maybe_promote
+from pandas.core.dtypes.common import ensure_platform_int, is_1d_only_ea_dtype
+from pandas.core.dtypes.missing import na_value_for_dtype
+from pandas.core.construction import ensure_wrapped_if_datetimelike
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike, AxisInt, npt
+    from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
+    from pandas.core.arrays.base import ExtensionArray
+
+@overload
+def take_nd(arr: np.ndarray, indexer, axis: AxisInt=..., fill_value=..., allow_fill: bool=...) -> np.ndarray:
+    ...
+
+@overload
+def take_nd(arr: ExtensionArray, indexer, axis: AxisInt=..., fill_value=..., allow_fill: bool=...) -> ArrayLike:
+    ...
+
+def take_nd(arr: ArrayLike, indexer, axis: AxisInt=0, fill_value=lib.no_default, allow_fill: bool=True) -> ArrayLike:
+    if fill_value is lib.no_default:
+        fill_value = na_value_for_dtype(arr.dtype, compat=False)
+    elif lib.is_np_dtype(arr.dtype, 'mM'):
+        (dtype, fill_value) = maybe_promote(arr.dtype, fill_value)
+        if arr.dtype != dtype:
+            arr = arr.astype(dtype)
+    if not isinstance(arr, np.ndarray):
+        if not is_1d_only_ea_dtype(arr.dtype):
+            arr = cast('NDArrayBackedExtensionArray', arr)
+            return arr.take(indexer, fill_value=fill_value, allow_fill=allow_fill, axis=axis)
+        return arr.take(indexer, fill_value=fill_value, allow_fill=allow_fill)
+    arr = np.asarray(arr)
+    return _take_nd_ndarray(arr, indexer, axis, fill_value, allow_fill)
+
+def _take_nd_ndarray(arr: np.ndarray, indexer: npt.NDArray[np.intp] | None, axis: AxisInt, fill_value, allow_fill: bool) -> np.ndarray:
+    if indexer is None:
+        indexer = np.arange(arr.shape[axis], dtype=np.intp)
+        (dtype, fill_value) = (arr.dtype, arr.dtype.type())
+    else:
+        indexer = ensure_platform_int(indexer)
+    (dtype, fill_value, mask_info) = _take_preprocess_indexer_and_fill_value(arr, indexer, fill_value, allow_fill)
+    flip_order = False
+    if arr.ndim == 2 and arr.flags.f_contiguous:
+        flip_order = True
+    if flip_order:
+        arr = arr.T
+        axis = arr.ndim - axis - 1
+    out_shape_ = list(arr.shape)
+    out_shape_[axis] = len(indexer)
+    out_shape = tuple(out_shape_)
+    if arr.flags.f_contiguous and axis == arr.ndim - 1:
+        out = np.empty(out_shape, dtype=dtype, order='F')
+    else:
+        out = np.empty(out_shape, dtype=dtype)
+    func = _get_take_nd_function(arr.ndim, arr.dtype, out.dtype, axis=axis, mask_info=mask_info)
+    func(arr, indexer, out, fill_value)
+    if flip_order:
+        out = out.T
+    return out
+
+def take_2d_multi(arr: np.ndarray, indexer: tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]], fill_value=np.nan) -> np.ndarray:
+    assert indexer is not None
+    assert indexer[0] is not None
+    assert indexer[1] is not None
+    (row_idx, col_idx) = indexer
+    row_idx = ensure_platform_int(row_idx)
+    col_idx = ensure_platform_int(col_idx)
+    indexer = (row_idx, col_idx)
+    mask_info = None
+    (dtype, fill_value) = maybe_promote(arr.dtype, fill_value)
+    if dtype != arr.dtype:
+        row_mask = row_idx == -1
+        col_mask = col_idx == -1
+        row_needs = row_mask.any()
+        col_needs = col_mask.any()
+        mask_info = ((row_mask, col_mask), (row_needs, col_needs))
+        if not (row_needs or col_needs):
+            (dtype, fill_value) = (arr.dtype, arr.dtype.type())
+    out_shape = (len(row_idx), len(col_idx))
+    out = np.empty(out_shape, dtype=dtype)
+    func = _take_2d_multi_dict.get((arr.dtype.name, out.dtype.name), None)
+    if func is None and arr.dtype != out.dtype:
+        func = _take_2d_multi_dict.get((out.dtype.name, out.dtype.name), None)
+        if func is not None:
+            func = _convert_wrapper(func, out.dtype)
+    if func is not None:
+        func(arr, indexer, out=out, fill_value=fill_value)
+    else:
+        _take_2d_multi_object(arr, indexer, out, fill_value=fill_value, mask_info=mask_info)
+    return out
+
+@functools.lru_cache
+def _get_take_nd_function_cached(ndim: int, arr_dtype: np.dtype, out_dtype: np.dtype, axis: AxisInt):
+    tup = (arr_dtype.name, out_dtype.name)
+    if ndim == 1:
+        func = _take_1d_dict.get(tup, None)
+    elif ndim == 2:
+        if axis == 0:
+            func = _take_2d_axis0_dict.get(tup, None)
+        else:
+            func = _take_2d_axis1_dict.get(tup, None)
+    if func is not None:
+        return func
+    tup = (out_dtype.name, out_dtype.name)
+    if ndim == 1:
+        func = _take_1d_dict.get(tup, None)
+    elif ndim == 2:
+        if axis == 0:
+            func = _take_2d_axis0_dict.get(tup, None)
+        else:
+            func = _take_2d_axis1_dict.get(tup, None)
+    if func is not None:
+        func = _convert_wrapper(func, out_dtype)
+        return func
+    return None
+
+def _get_take_nd_function(ndim: int, arr_dtype: np.dtype, out_dtype: np.dtype, axis: AxisInt=0, mask_info=None):
+    func = None
+    if ndim <= 2:
+        func = _get_take_nd_function_cached(ndim, arr_dtype, out_dtype, axis)
+    if func is None:
+
+        def func(arr, indexer, out, fill_value=np.nan) -> None:
+            indexer = ensure_platform_int(indexer)
+            _take_nd_object(arr, indexer, out, axis=axis, fill_value=fill_value, mask_info=mask_info)
+    return func
+
+def _view_wrapper(f, arr_dtype=None, out_dtype=None, fill_wrap=None):
+
+    def wrapper(arr: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=np.nan) -> None:
+        if arr_dtype is not None:
+            arr = arr.view(arr_dtype)
+        if out_dtype is not None:
+            out = out.view(out_dtype)
+        if fill_wrap is not None:
+            if fill_value.dtype.kind == 'm':
+                fill_value = fill_value.astype('m8[ns]')
+            else:
+                fill_value = fill_value.astype('M8[ns]')
+            fill_value = fill_wrap(fill_value)
+        f(arr, indexer, out, fill_value=fill_value)
+    return wrapper
+
+def _convert_wrapper(f, conv_dtype):
+
+    def wrapper(arr: np.ndarray, indexer: np.ndarray, out: np.ndarray, fill_value=np.nan) -> None:
+        if conv_dtype == object:
+            arr = ensure_wrapped_if_datetimelike(arr)
+        arr = arr.astype(conv_dtype)
+        f(arr, indexer, out, fill_value=fill_value)
+    return wrapper
+_take_1d_dict = {('int8', 'int8'): libalgos.take_1d_int8_int8, ('int8', 'int32'): libalgos.take_1d_int8_int32, ('int8', 'int64'): libalgos.take_1d_int8_int64, ('int8', 'float64'): libalgos.take_1d_int8_float64, ('int16', 'int16'): libalgos.take_1d_int16_int16, ('int16', 'int32'): libalgos.take_1d_int16_int32, ('int16', 'int64'): libalgos.take_1d_int16_int64, ('int16', 'float64'): libalgos.take_1d_int16_float64, ('int32', 'int32'): libalgos.take_1d_int32_int32, ('int32', 'int64'): libalgos.take_1d_int32_int64, ('int32', 'float64'): libalgos.take_1d_int32_float64, ('int64', 'int64'): libalgos.take_1d_int64_int64, ('uint8', 'uint8'): libalgos.take_1d_bool_bool, ('uint16', 'int64'): libalgos.take_1d_uint16_uint16, ('uint32', 'int64'): libalgos.take_1d_uint32_uint32, ('uint64', 'int64'): libalgos.take_1d_uint64_uint64, ('int64', 'float64'): libalgos.take_1d_int64_float64, ('float32', 'float32'): libalgos.take_1d_float32_float32, ('float32', 'float64'): libalgos.take_1d_float32_float64, ('float64', 'float64'): libalgos.take_1d_float64_float64, ('object', 'object'): libalgos.take_1d_object_object, ('bool', 'bool'): _view_wrapper(libalgos.take_1d_bool_bool, np.uint8, np.uint8), ('bool', 'object'): _view_wrapper(libalgos.take_1d_bool_object, np.uint8, None), ('datetime64[ns]', 'datetime64[ns]'): _view_wrapper(libalgos.take_1d_int64_int64, np.int64, np.int64, np.int64), ('timedelta64[ns]', 'timedelta64[ns]'): _view_wrapper(libalgos.take_1d_int64_int64, np.int64, np.int64, np.int64)}
+_take_2d_axis0_dict = {('int8', 'int8'): libalgos.take_2d_axis0_int8_int8, ('int8', 'int32'): libalgos.take_2d_axis0_int8_int32, ('int8', 'int64'): libalgos.take_2d_axis0_int8_int64, ('int8', 'float64'): libalgos.take_2d_axis0_int8_float64, ('int16', 'int16'): libalgos.take_2d_axis0_int16_int16, ('int16', 'int32'): libalgos.take_2d_axis0_int16_int32, ('int16', 'int64'): libalgos.take_2d_axis0_int16_int64, ('int16', 'float64'): libalgos.take_2d_axis0_int16_float64, ('int32', 'int32'): libalgos.take_2d_axis0_int32_int32, ('int32', 'int64'): libalgos.take_2d_axis0_int32_int64, ('int32', 'float64'): libalgos.take_2d_axis0_int32_float64, ('int64', 'int64'): libalgos.take_2d_axis0_int64_int64, ('int64', 'float64'): libalgos.take_2d_axis0_int64_float64, ('uint8', 'uint8'): libalgos.take_2d_axis0_bool_bool, ('uint16', 'uint16'): libalgos.take_2d_axis0_uint16_uint16, ('uint32', 'uint32'): libalgos.take_2d_axis0_uint32_uint32, ('uint64', 'uint64'): libalgos.take_2d_axis0_uint64_uint64, ('float32', 'float32'): libalgos.take_2d_axis0_float32_float32, ('float32', 'float64'): libalgos.take_2d_axis0_float32_float64, ('float64', 'float64'): libalgos.take_2d_axis0_float64_float64, ('object', 'object'): libalgos.take_2d_axis0_object_object, ('bool', 'bool'): _view_wrapper(libalgos.take_2d_axis0_bool_bool, np.uint8, np.uint8), ('bool', 'object'): _view_wrapper(libalgos.take_2d_axis0_bool_object, np.uint8, None), ('datetime64[ns]', 'datetime64[ns]'): _view_wrapper(libalgos.take_2d_axis0_int64_int64, np.int64, np.int64, fill_wrap=np.int64), ('timedelta64[ns]', 'timedelta64[ns]'): _view_wrapper(libalgos.take_2d_axis0_int64_int64, np.int64, np.int64, fill_wrap=np.int64)}
+_take_2d_axis1_dict = {('int8', 'int8'): libalgos.take_2d_axis1_int8_int8, ('int8', 'int32'): libalgos.take_2d_axis1_int8_int32, ('int8', 'int64'): libalgos.take_2d_axis1_int8_int64, ('int8', 'float64'): libalgos.take_2d_axis1_int8_float64, ('int16', 'int16'): libalgos.take_2d_axis1_int16_int16, ('int16', 'int32'): libalgos.take_2d_axis1_int16_int32, ('int16', 'int64'): libalgos.take_2d_axis1_int16_int64, ('int16', 'float64'): libalgos.take_2d_axis1_int16_float64, ('int32', 'int32'): libalgos.take_2d_axis1_int32_int32, ('int32', 'int64'): libalgos.take_2d_axis1_int32_int64, ('int32', 'float64'): libalgos.take_2d_axis1_int32_float64, ('int64', 'int64'): libalgos.take_2d_axis1_int64_int64, ('int64', 'float64'): libalgos.take_2d_axis1_int64_float64, ('uint8', 'uint8'): libalgos.take_2d_axis1_bool_bool, ('uint16', 'uint16'): libalgos.take_2d_axis1_uint16_uint16, ('uint32', 'uint32'): libalgos.take_2d_axis1_uint32_uint32, ('uint64', 'uint64'): libalgos.take_2d_axis1_uint64_uint64, ('float32', 'float32'): libalgos.take_2d_axis1_float32_float32, ('float32', 'float64'): libalgos.take_2d_axis1_float32_float64, ('float64', 'float64'): libalgos.take_2d_axis1_float64_float64, ('object', 'object'): libalgos.take_2d_axis1_object_object, ('bool', 'bool'): _view_wrapper(libalgos.take_2d_axis1_bool_bool, np.uint8, np.uint8), ('bool', 'object'): _view_wrapper(libalgos.take_2d_axis1_bool_object, np.uint8, None), ('datetime64[ns]', 'datetime64[ns]'): _view_wrapper(libalgos.take_2d_axis1_int64_int64, np.int64, np.int64, fill_wrap=np.int64), ('timedelta64[ns]', 'timedelta64[ns]'): _view_wrapper(libalgos.take_2d_axis1_int64_int64, np.int64, np.int64, fill_wrap=np.int64)}
+_take_2d_multi_dict = {('int8', 'int8'): libalgos.take_2d_multi_int8_int8, ('int8', 'int32'): libalgos.take_2d_multi_int8_int32, ('int8', 'int64'): libalgos.take_2d_multi_int8_int64, ('int8', 'float64'): libalgos.take_2d_multi_int8_float64, ('int16', 'int16'): libalgos.take_2d_multi_int16_int16, ('int16', 'int32'): libalgos.take_2d_multi_int16_int32, ('int16', 'int64'): libalgos.take_2d_multi_int16_int64, ('int16', 'float64'): libalgos.take_2d_multi_int16_float64, ('int32', 'int32'): libalgos.take_2d_multi_int32_int32, ('int32', 'int64'): libalgos.take_2d_multi_int32_int64, ('int32', 'float64'): libalgos.take_2d_multi_int32_float64, ('int64', 'int64'): libalgos.take_2d_multi_int64_int64, ('int64', 'float64'): libalgos.take_2d_multi_int64_float64, ('float32', 'float32'): libalgos.take_2d_multi_float32_float32, ('float32', 'float64'): libalgos.take_2d_multi_float32_float64, ('float64', 'float64'): libalgos.take_2d_multi_float64_float64, ('object', 'object'): libalgos.take_2d_multi_object_object, ('bool', 'bool'): _view_wrapper(libalgos.take_2d_multi_bool_bool, np.uint8, np.uint8), ('bool', 'object'): _view_wrapper(libalgos.take_2d_multi_bool_object, np.uint8, None), ('datetime64[ns]', 'datetime64[ns]'): _view_wrapper(libalgos.take_2d_multi_int64_int64, np.int64, np.int64, fill_wrap=np.int64), ('timedelta64[ns]', 'timedelta64[ns]'): _view_wrapper(libalgos.take_2d_multi_int64_int64, np.int64, np.int64, fill_wrap=np.int64)}
+
+def _take_nd_object(arr: np.ndarray, indexer: npt.NDArray[np.intp], out: np.ndarray, axis: AxisInt, fill_value, mask_info) -> None:
+    if mask_info is not None:
+        (mask, needs_masking) = mask_info
+    else:
+        mask = indexer == -1
+        needs_masking = mask.any()
+    if arr.dtype != out.dtype:
+        arr = arr.astype(out.dtype)
+    if arr.shape[axis] > 0:
+        arr.take(indexer, axis=axis, out=out)
+    if needs_masking:
+        outindexer = [slice(None)] * arr.ndim
+        outindexer[axis] = mask
+        out[tuple(outindexer)] = fill_value
+
+def _take_2d_multi_object(arr: np.ndarray, indexer: tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]], out: np.ndarray, fill_value, mask_info) -> None:
+    (row_idx, col_idx) = indexer
+    if mask_info is not None:
+        ((row_mask, col_mask), (row_needs, col_needs)) = mask_info
+    else:
+        row_mask = row_idx == -1
+        col_mask = col_idx == -1
+        row_needs = row_mask.any()
+        col_needs = col_mask.any()
+    if fill_value is not None:
+        if row_needs:
+            out[row_mask, :] = fill_value
+        if col_needs:
+            out[:, col_mask] = fill_value
+    for (i, u_) in enumerate(row_idx):
+        if u_ != -1:
+            for (j, v) in enumerate(col_idx):
+                if v != -1:
+                    out[i, j] = arr[u_, v]
+
+def _take_preprocess_indexer_and_fill_value(arr: np.ndarray, indexer: npt.NDArray[np.intp], fill_value, allow_fill: bool, mask: npt.NDArray[np.bool_] | None=None):
+    mask_info: tuple[np.ndarray | None, bool] | None = None
+    if not allow_fill:
+        (dtype, fill_value) = (arr.dtype, arr.dtype.type())
+        mask_info = (None, False)
+    else:
+        (dtype, fill_value) = maybe_promote(arr.dtype, fill_value)
+        if dtype != arr.dtype:
+            if mask is not None:
+                needs_masking = True
+            else:
+                mask = indexer == -1
+                needs_masking = bool(mask.any())
+            mask_info = (mask, needs_masking)
+            if not needs_masking:
+                (dtype, fill_value) = (arr.dtype, arr.dtype.type())
+    return (dtype, fill_value, mask_info)
+
+# File: pandas-main/pandas/core/array_algos/transforms.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+if TYPE_CHECKING:
+    from pandas._typing import AxisInt, Scalar
+
+def shift(values: np.ndarray, periods: int, axis: AxisInt, fill_value: Scalar) -> np.ndarray:
+    new_values = values
+    if periods == 0 or values.size == 0:
+        return new_values.copy()
+    f_ordered = values.flags.f_contiguous
+    if f_ordered:
+        new_values = new_values.T
+        axis = new_values.ndim - axis - 1
+    if new_values.size:
+        new_values = np.roll(new_values, np.intp(periods), axis=axis)
+    axis_indexer = [slice(None)] * values.ndim
+    if periods > 0:
+        axis_indexer[axis] = slice(None, periods)
+    else:
+        axis_indexer[axis] = slice(periods, None)
+    new_values[tuple(axis_indexer)] = fill_value
+    if f_ordered:
+        new_values = new_values.T
+    return new_values
+
+# File: pandas-main/pandas/core/arraylike.py
+""""""
+from __future__ import annotations
+import operator
+from typing import Any
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.ops_dispatch import maybe_dispatch_ufunc_to_dunder_op
+from pandas.core.dtypes.generic import ABCNDFrame
+from pandas.core import roperator
+from pandas.core.construction import extract_array
+from pandas.core.ops.common import unpack_zerodim_and_defer
+REDUCTION_ALIASES = {'maximum': 'max', 'minimum': 'min', 'add': 'sum', 'multiply': 'prod'}
+
+class OpsMixin:
+
+    def _cmp_method(self, other, op):
+        return NotImplemented
+
+    @unpack_zerodim_and_defer('__eq__')
+    def __eq__(self, other):
+        return self._cmp_method(other, operator.eq)
+
+    @unpack_zerodim_and_defer('__ne__')
+    def __ne__(self, other):
+        return self._cmp_method(other, operator.ne)
+
+    @unpack_zerodim_and_defer('__lt__')
+    def __lt__(self, other):
+        return self._cmp_method(other, operator.lt)
+
+    @unpack_zerodim_and_defer('__le__')
+    def __le__(self, other):
+        return self._cmp_method(other, operator.le)
+
+    @unpack_zerodim_and_defer('__gt__')
+    def __gt__(self, other):
+        return self._cmp_method(other, operator.gt)
+
+    @unpack_zerodim_and_defer('__ge__')
+    def __ge__(self, other):
+        return self._cmp_method(other, operator.ge)
+
+    def _logical_method(self, other, op):
+        return NotImplemented
+
+    @unpack_zerodim_and_defer('__and__')
+    def __and__(self, other):
+        return self._logical_method(other, operator.and_)
+
+    @unpack_zerodim_and_defer('__rand__')
+    def __rand__(self, other):
+        return self._logical_method(other, roperator.rand_)
+
+    @unpack_zerodim_and_defer('__or__')
+    def __or__(self, other):
+        return self._logical_method(other, operator.or_)
+
+    @unpack_zerodim_and_defer('__ror__')
+    def __ror__(self, other):
+        return self._logical_method(other, roperator.ror_)
+
+    @unpack_zerodim_and_defer('__xor__')
+    def __xor__(self, other):
+        return self._logical_method(other, operator.xor)
+
+    @unpack_zerodim_and_defer('__rxor__')
+    def __rxor__(self, other):
+        return self._logical_method(other, roperator.rxor)
+
+    def _arith_method(self, other, op):
+        return NotImplemented
+
+    @unpack_zerodim_and_defer('__add__')
+    def __add__(self, other):
+        return self._arith_method(other, operator.add)
+
+    @unpack_zerodim_and_defer('__radd__')
+    def __radd__(self, other):
+        return self._arith_method(other, roperator.radd)
+
+    @unpack_zerodim_and_defer('__sub__')
+    def __sub__(self, other):
+        return self._arith_method(other, operator.sub)
+
+    @unpack_zerodim_and_defer('__rsub__')
+    def __rsub__(self, other):
+        return self._arith_method(other, roperator.rsub)
+
+    @unpack_zerodim_and_defer('__mul__')
+    def __mul__(self, other):
+        return self._arith_method(other, operator.mul)
+
+    @unpack_zerodim_and_defer('__rmul__')
+    def __rmul__(self, other):
+        return self._arith_method(other, roperator.rmul)
+
+    @unpack_zerodim_and_defer('__truediv__')
+    def __truediv__(self, other):
+        return self._arith_method(other, operator.truediv)
+
+    @unpack_zerodim_and_defer('__rtruediv__')
+    def __rtruediv__(self, other):
+        return self._arith_method(other, roperator.rtruediv)
+
+    @unpack_zerodim_and_defer('__floordiv__')
+    def __floordiv__(self, other):
+        return self._arith_method(other, operator.floordiv)
+
+    @unpack_zerodim_and_defer('__rfloordiv')
+    def __rfloordiv__(self, other):
+        return self._arith_method(other, roperator.rfloordiv)
+
+    @unpack_zerodim_and_defer('__mod__')
+    def __mod__(self, other):
+        return self._arith_method(other, operator.mod)
+
+    @unpack_zerodim_and_defer('__rmod__')
+    def __rmod__(self, other):
+        return self._arith_method(other, roperator.rmod)
+
+    @unpack_zerodim_and_defer('__divmod__')
+    def __divmod__(self, other):
+        return self._arith_method(other, divmod)
+
+    @unpack_zerodim_and_defer('__rdivmod__')
+    def __rdivmod__(self, other):
+        return self._arith_method(other, roperator.rdivmod)
+
+    @unpack_zerodim_and_defer('__pow__')
+    def __pow__(self, other):
+        return self._arith_method(other, operator.pow)
+
+    @unpack_zerodim_and_defer('__rpow__')
+    def __rpow__(self, other):
+        return self._arith_method(other, roperator.rpow)
+
+def array_ufunc(self, ufunc: np.ufunc, method: str, *inputs: Any, **kwargs: Any):
+    from pandas.core.frame import DataFrame, Series
+    from pandas.core.generic import NDFrame
+    from pandas.core.internals import BlockManager
+    cls = type(self)
+    kwargs = _standardize_out_kwarg(**kwargs)
+    result = maybe_dispatch_ufunc_to_dunder_op(self, ufunc, method, *inputs, **kwargs)
+    if result is not NotImplemented:
+        return result
+    no_defer = (np.ndarray.__array_ufunc__, cls.__array_ufunc__)
+    for item in inputs:
+        higher_priority = hasattr(item, '__array_priority__') and item.__array_priority__ > self.__array_priority__
+        has_array_ufunc = hasattr(item, '__array_ufunc__') and type(item).__array_ufunc__ not in no_defer and (not isinstance(item, self._HANDLED_TYPES))
+        if higher_priority or has_array_ufunc:
+            return NotImplemented
+    types = tuple((type(x) for x in inputs))
+    alignable = [x for (x, t) in zip(inputs, types) if issubclass(t, NDFrame)]
+    if len(alignable) > 1:
+        set_types = set(types)
+        if len(set_types) > 1 and {DataFrame, Series}.issubset(set_types):
+            raise NotImplementedError(f'Cannot apply ufunc {ufunc} to mixed DataFrame and Series inputs.')
+        axes = self.axes
+        for obj in alignable[1:]:
+            for (i, (ax1, ax2)) in enumerate(zip(axes, obj.axes)):
+                axes[i] = ax1.union(ax2)
+        reconstruct_axes = dict(zip(self._AXIS_ORDERS, axes))
+        inputs = tuple((x.reindex(**reconstruct_axes) if issubclass(t, NDFrame) else x for (x, t) in zip(inputs, types)))
+    else:
+        reconstruct_axes = dict(zip(self._AXIS_ORDERS, self.axes))
+    if self.ndim == 1:
+        names = {getattr(x, 'name') for x in inputs if hasattr(x, 'name')}
+        name = names.pop() if len(names) == 1 else None
+        reconstruct_kwargs = {'name': name}
+    else:
+        reconstruct_kwargs = {}
+
+    def reconstruct(result):
+        if ufunc.nout > 1:
+            return tuple((_reconstruct(x) for x in result))
+        return _reconstruct(result)
+
+    def _reconstruct(result):
+        if lib.is_scalar(result):
+            return result
+        if result.ndim != self.ndim:
+            if method == 'outer':
+                raise NotImplementedError
+            return result
+        if isinstance(result, BlockManager):
+            result = self._constructor_from_mgr(result, axes=result.axes)
+        else:
+            result = self._constructor(result, **reconstruct_axes, **reconstruct_kwargs, copy=False)
+        if len(alignable) == 1:
+            result = result.__finalize__(self)
+        return result
+    if 'out' in kwargs:
+        result = dispatch_ufunc_with_out(self, ufunc, method, *inputs, **kwargs)
+        return reconstruct(result)
+    if method == 'reduce':
+        result = dispatch_reduction_ufunc(self, ufunc, method, *inputs, **kwargs)
+        if result is not NotImplemented:
+            return result
+    if self.ndim > 1 and (len(inputs) > 1 or ufunc.nout > 1):
+        inputs = tuple((np.asarray(x) for x in inputs))
+        result = getattr(ufunc, method)(*inputs, **kwargs)
+    elif self.ndim == 1:
+        inputs = tuple((extract_array(x, extract_numpy=True) for x in inputs))
+        result = getattr(ufunc, method)(*inputs, **kwargs)
+    elif method == '__call__' and (not kwargs):
+        mgr = inputs[0]._mgr
+        result = mgr.apply(getattr(ufunc, method))
+    else:
+        result = default_array_ufunc(inputs[0], ufunc, method, *inputs, **kwargs)
+    result = reconstruct(result)
+    return result
+
+def _standardize_out_kwarg(**kwargs) -> dict:
+    if 'out' not in kwargs and 'out1' in kwargs and ('out2' in kwargs):
+        out1 = kwargs.pop('out1')
+        out2 = kwargs.pop('out2')
+        out = (out1, out2)
+        kwargs['out'] = out
+    return kwargs
+
+def dispatch_ufunc_with_out(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
+    out = kwargs.pop('out')
+    where = kwargs.pop('where', None)
+    result = getattr(ufunc, method)(*inputs, **kwargs)
+    if result is NotImplemented:
+        return NotImplemented
+    if isinstance(result, tuple):
+        if not isinstance(out, tuple) or len(out) != len(result):
+            raise NotImplementedError
+        for (arr, res) in zip(out, result):
+            _assign_where(arr, res, where)
+        return out
+    if isinstance(out, tuple):
+        if len(out) == 1:
+            out = out[0]
+        else:
+            raise NotImplementedError
+    _assign_where(out, result, where)
+    return out
+
+def _assign_where(out, result, where) -> None:
+    if where is None:
+        out[:] = result
+    else:
+        np.putmask(out, where, result)
+
+def default_array_ufunc(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
+    if not any((x is self for x in inputs)):
+        raise NotImplementedError
+    new_inputs = [x if x is not self else np.asarray(x) for x in inputs]
+    return getattr(ufunc, method)(*new_inputs, **kwargs)
+
+def dispatch_reduction_ufunc(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
+    assert method == 'reduce'
+    if len(inputs) != 1 or inputs[0] is not self:
+        return NotImplemented
+    if ufunc.__name__ not in REDUCTION_ALIASES:
+        return NotImplemented
+    method_name = REDUCTION_ALIASES[ufunc.__name__]
+    if not hasattr(self, method_name):
+        return NotImplemented
+    if self.ndim > 1:
+        if isinstance(self, ABCNDFrame):
+            kwargs['numeric_only'] = False
+        if 'axis' not in kwargs:
+            kwargs['axis'] = 0
+    return getattr(self, method_name)(skipna=False, **kwargs)
+
+# File: pandas-main/pandas/core/arrays/__init__.py
+from pandas.core.arrays.arrow import ArrowExtensionArray
+from pandas.core.arrays.base import ExtensionArray, ExtensionOpsMixin, ExtensionScalarOpsMixin
+from pandas.core.arrays.boolean import BooleanArray
+from pandas.core.arrays.categorical import Categorical
+from pandas.core.arrays.datetimes import DatetimeArray
+from pandas.core.arrays.floating import FloatingArray
+from pandas.core.arrays.integer import IntegerArray
+from pandas.core.arrays.interval import IntervalArray
+from pandas.core.arrays.masked import BaseMaskedArray
+from pandas.core.arrays.numpy_ import NumpyExtensionArray
+from pandas.core.arrays.period import PeriodArray, period_array
+from pandas.core.arrays.sparse import SparseArray
+from pandas.core.arrays.string_ import StringArray
+from pandas.core.arrays.string_arrow import ArrowStringArray
+from pandas.core.arrays.timedeltas import TimedeltaArray
+__all__ = ['ArrowExtensionArray', 'ExtensionArray', 'ExtensionOpsMixin', 'ExtensionScalarOpsMixin', 'ArrowStringArray', 'BaseMaskedArray', 'BooleanArray', 'Categorical', 'DatetimeArray', 'FloatingArray', 'IntegerArray', 'IntervalArray', 'NumpyExtensionArray', 'PeriodArray', 'period_array', 'SparseArray', 'StringArray', 'TimedeltaArray']
+
+# File: pandas-main/pandas/core/arrays/_arrow_string_mixins.py
+from __future__ import annotations
+from functools import partial
+import re
+from typing import TYPE_CHECKING, Any, Literal
+import numpy as np
+from pandas.compat import pa_version_under10p1, pa_version_under11p0, pa_version_under13p0, pa_version_under17p0
+from pandas.core.dtypes.missing import isna
+if not pa_version_under10p1:
+    import pyarrow as pa
+    import pyarrow.compute as pc
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import Scalar, Self
+
+class ArrowStringArrayMixin:
+    _pa_array: pa.ChunkedArray
+
+    def __init__(self, *args, **kwargs) -> None:
+        raise NotImplementedError
+
+    def _convert_bool_result(self, result):
+        raise NotImplementedError
+
+    def _convert_int_result(self, result):
+        raise NotImplementedError
+
+    def _apply_elementwise(self, func: Callable) -> list[list[Any]]:
+        raise NotImplementedError
+
+    def _str_len(self):
+        result = pc.utf8_length(self._pa_array)
+        return self._convert_int_result(result)
+
+    def _str_lower(self) -> Self:
+        return type(self)(pc.utf8_lower(self._pa_array))
+
+    def _str_upper(self) -> Self:
+        return type(self)(pc.utf8_upper(self._pa_array))
+
+    def _str_strip(self, to_strip=None) -> Self:
+        if to_strip is None:
+            result = pc.utf8_trim_whitespace(self._pa_array)
+        else:
+            result = pc.utf8_trim(self._pa_array, characters=to_strip)
+        return type(self)(result)
+
+    def _str_lstrip(self, to_strip=None) -> Self:
+        if to_strip is None:
+            result = pc.utf8_ltrim_whitespace(self._pa_array)
+        else:
+            result = pc.utf8_ltrim(self._pa_array, characters=to_strip)
+        return type(self)(result)
+
+    def _str_rstrip(self, to_strip=None) -> Self:
+        if to_strip is None:
+            result = pc.utf8_rtrim_whitespace(self._pa_array)
+        else:
+            result = pc.utf8_rtrim(self._pa_array, characters=to_strip)
+        return type(self)(result)
+
+    def _str_pad(self, width: int, side: Literal['left', 'right', 'both']='left', fillchar: str=' ') -> Self:
+        if side == 'left':
+            pa_pad = pc.utf8_lpad
+        elif side == 'right':
+            pa_pad = pc.utf8_rpad
+        elif side == 'both':
+            if pa_version_under17p0:
+                from pandas import array
+                obj_arr = self.astype(object, copy=False)
+                obj = array(obj_arr, dtype=object)
+                result = obj._str_pad(width, side, fillchar)
+                return type(self)._from_sequence(result, dtype=self.dtype)
+            else:
+                lean_left = width % 2 == 0
+                pa_pad = partial(pc.utf8_center, lean_left_on_odd_padding=lean_left)
+        else:
+            raise ValueError(f"Invalid side: {side}. Side must be one of 'left', 'right', 'both'")
+        return type(self)(pa_pad(self._pa_array, width=width, padding=fillchar))
+
+    def _str_get(self, i: int) -> Self:
+        lengths = pc.utf8_length(self._pa_array)
+        if i >= 0:
+            out_of_bounds = pc.greater_equal(i, lengths)
+            start = i
+            stop = i + 1
+            step = 1
+        else:
+            out_of_bounds = pc.greater(-i, lengths)
+            start = i
+            stop = i - 1
+            step = -1
+        not_out_of_bounds = pc.invert(out_of_bounds.fill_null(True))
+        selected = pc.utf8_slice_codeunits(self._pa_array, start=start, stop=stop, step=step)
+        null_value = pa.scalar(None, type=self._pa_array.type)
+        result = pc.if_else(not_out_of_bounds, selected, null_value)
+        return type(self)(result)
+
+    def _str_slice(self, start: int | None=None, stop: int | None=None, step: int | None=None) -> Self:
+        if pa_version_under11p0:
+            result = self._apply_elementwise(lambda val: val[start:stop:step])
+            return type(self)(pa.chunked_array(result, type=self._pa_array.type))
+        if start is None:
+            if step is not None and step < 0:
+                start = -1
+            else:
+                start = 0
+        if step is None:
+            step = 1
+        return type(self)(pc.utf8_slice_codeunits(self._pa_array, start=start, stop=stop, step=step))
+
+    def _str_slice_replace(self, start: int | None=None, stop: int | None=None, repl: str | None=None) -> Self:
+        if repl is None:
+            repl = ''
+        if start is None:
+            start = 0
+        if stop is None:
+            stop = np.iinfo(np.int64).max
+        return type(self)(pc.utf8_replace_slice(self._pa_array, start, stop, repl))
+
+    def _str_replace(self, pat: str | re.Pattern, repl: str | Callable, n: int=-1, case: bool=True, flags: int=0, regex: bool=True) -> Self:
+        if isinstance(pat, re.Pattern) or callable(repl) or (not case) or flags:
+            raise NotImplementedError('replace is not supported with a re.Pattern, callable repl, case=False, or flags!=0')
+        func = pc.replace_substring_regex if regex else pc.replace_substring
+        pa_max_replacements = None if n < 0 else n
+        result = func(self._pa_array, pattern=pat, replacement=repl, max_replacements=pa_max_replacements)
+        return type(self)(result)
+
+    def _str_capitalize(self) -> Self:
+        return type(self)(pc.utf8_capitalize(self._pa_array))
+
+    def _str_title(self) -> Self:
+        return type(self)(pc.utf8_title(self._pa_array))
+
+    def _str_swapcase(self) -> Self:
+        return type(self)(pc.utf8_swapcase(self._pa_array))
+
+    def _str_removeprefix(self, prefix: str):
+        if not pa_version_under13p0:
+            starts_with = pc.starts_with(self._pa_array, pattern=prefix)
+            removed = pc.utf8_slice_codeunits(self._pa_array, len(prefix))
+            result = pc.if_else(starts_with, removed, self._pa_array)
+            return type(self)(result)
+        predicate = lambda val: val.removeprefix(prefix)
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    def _str_removesuffix(self, suffix: str):
+        ends_with = pc.ends_with(self._pa_array, pattern=suffix)
+        removed = pc.utf8_slice_codeunits(self._pa_array, 0, stop=-len(suffix))
+        result = pc.if_else(ends_with, removed, self._pa_array)
+        return type(self)(result)
+
+    def _str_startswith(self, pat: str | tuple[str, ...], na: Scalar | None=None):
+        if isinstance(pat, str):
+            result = pc.starts_with(self._pa_array, pattern=pat)
+        elif len(pat) == 0:
+            result = pc.if_else(pc.is_null(self._pa_array), None, False)
+        else:
+            result = pc.starts_with(self._pa_array, pattern=pat[0])
+            for p in pat[1:]:
+                result = pc.or_(result, pc.starts_with(self._pa_array, pattern=p))
+        if not isna(na):
+            result = result.fill_null(na)
+        return self._convert_bool_result(result)
+
+    def _str_endswith(self, pat: str | tuple[str, ...], na: Scalar | None=None):
+        if isinstance(pat, str):
+            result = pc.ends_with(self._pa_array, pattern=pat)
+        elif len(pat) == 0:
+            result = pc.if_else(pc.is_null(self._pa_array), None, False)
+        else:
+            result = pc.ends_with(self._pa_array, pattern=pat[0])
+            for p in pat[1:]:
+                result = pc.or_(result, pc.ends_with(self._pa_array, pattern=p))
+        if not isna(na):
+            result = result.fill_null(na)
+        return self._convert_bool_result(result)
+
+    def _str_isalnum(self):
+        result = pc.utf8_is_alnum(self._pa_array)
+        return self._convert_bool_result(result)
+
+    def _str_isalpha(self):
+        result = pc.utf8_is_alpha(self._pa_array)
+        return self._convert_bool_result(result)
+
+    def _str_isdecimal(self):
+        result = pc.utf8_is_decimal(self._pa_array)
+        return self._convert_bool_result(result)
+
+    def _str_isdigit(self):
+        result = pc.utf8_is_digit(self._pa_array)
+        return self._convert_bool_result(result)
+
+    def _str_islower(self):
+        result = pc.utf8_is_lower(self._pa_array)
+        return self._convert_bool_result(result)
+
+    def _str_isnumeric(self):
+        result = pc.utf8_is_numeric(self._pa_array)
+        return self._convert_bool_result(result)
+
+    def _str_isspace(self):
+        result = pc.utf8_is_space(self._pa_array)
+        return self._convert_bool_result(result)
+
+    def _str_istitle(self):
+        result = pc.utf8_is_title(self._pa_array)
+        return self._convert_bool_result(result)
+
+    def _str_isupper(self):
+        result = pc.utf8_is_upper(self._pa_array)
+        return self._convert_bool_result(result)
+
+    def _str_contains(self, pat, case: bool=True, flags: int=0, na=None, regex: bool=True):
+        if flags:
+            raise NotImplementedError(f'contains not implemented with flags={flags!r}')
+        if regex:
+            pa_contains = pc.match_substring_regex
+        else:
+            pa_contains = pc.match_substring
+        result = pa_contains(self._pa_array, pat, ignore_case=not case)
+        if not isna(na):
+            result = result.fill_null(na)
+        return self._convert_bool_result(result)
+
+    def _str_match(self, pat: str, case: bool=True, flags: int=0, na: Scalar | None=None):
+        if not pat.startswith('^'):
+            pat = f'^{pat}'
+        return self._str_contains(pat, case, flags, na, regex=True)
+
+    def _str_fullmatch(self, pat, case: bool=True, flags: int=0, na: Scalar | None=None):
+        if not pat.endswith('$') or pat.endswith('\\$'):
+            pat = f'{pat}$'
+        return self._str_match(pat, case, flags, na)
+
+    def _str_find(self, sub: str, start: int=0, end: int | None=None):
+        if pa_version_under13p0 and (not (start != 0 and end is not None)) and (not (start == 0 and end is None)):
+            res_list = self._apply_elementwise(lambda val: val.find(sub, start, end))
+            return self._convert_int_result(pa.chunked_array(res_list))
+        if (start == 0 or start is None) and end is None:
+            result = pc.find_substring(self._pa_array, sub)
+        else:
+            if sub == '':
+                res_list = self._apply_elementwise(lambda val: val.find(sub, start, end))
+                return self._convert_int_result(pa.chunked_array(res_list))
+            if start is None:
+                start_offset = 0
+                start = 0
+            elif start < 0:
+                start_offset = pc.add(start, pc.utf8_length(self._pa_array))
+                start_offset = pc.if_else(pc.less(start_offset, 0), 0, start_offset)
+            else:
+                start_offset = start
+            slices = pc.utf8_slice_codeunits(self._pa_array, start, stop=end)
+            result = pc.find_substring(slices, sub)
+            found = pc.not_equal(result, pa.scalar(-1, type=result.type))
+            offset_result = pc.add(result, start_offset)
+            result = pc.if_else(found, offset_result, -1)
+        return self._convert_int_result(result)
+
+# File: pandas-main/pandas/core/arrays/_mixins.py
+from __future__ import annotations
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.arrays import NDArrayBacked
+from pandas._libs.tslibs import is_supported_dtype
+from pandas._typing import ArrayLike, AxisInt, Dtype, F, FillnaOptions, PositionalIndexer2D, PositionalIndexerTuple, ScalarIndexer, Self, SequenceIndexer, Shape, TakeIndexer, npt
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import doc
+from pandas.util._validators import validate_bool_kwarg, validate_insert_loc
+from pandas.core.dtypes.common import pandas_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype, ExtensionDtype, PeriodDtype
+from pandas.core.dtypes.missing import array_equivalent
+from pandas.core import missing
+from pandas.core.algorithms import take, unique, value_counts_internal as value_counts
+from pandas.core.array_algos.quantile import quantile_with_mask
+from pandas.core.array_algos.transforms import shift
+from pandas.core.arrays.base import ExtensionArray
+from pandas.core.construction import extract_array
+from pandas.core.indexers import check_array_indexer
+from pandas.core.sorting import nargminmax
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pandas._typing import NumpySorter, NumpyValueArrayLike
+    from pandas import Series
+
+def ravel_compat(meth: F) -> F:
+
+    @wraps(meth)
+    def method(self, *args, **kwargs):
+        if self.ndim == 1:
+            return meth(self, *args, **kwargs)
+        flags = self._ndarray.flags
+        flat = self.ravel('K')
+        result = meth(flat, *args, **kwargs)
+        order = 'F' if flags.f_contiguous else 'C'
+        return result.reshape(self.shape, order=order)
+    return cast(F, method)
+
+class NDArrayBackedExtensionArray(NDArrayBacked, ExtensionArray):
+    _ndarray: np.ndarray
+    _internal_fill_value: Any
+
+    def _box_func(self, x):
+        return x
+
+    def _validate_scalar(self, value):
+        raise AbstractMethodError(self)
+
+    def view(self, dtype: Dtype | None=None) -> ArrayLike:
+        if dtype is None or dtype is self.dtype:
+            return self._from_backing_data(self._ndarray)
+        if isinstance(dtype, type):
+            return self._ndarray.view(dtype)
+        dtype = pandas_dtype(dtype)
+        arr = self._ndarray
+        if isinstance(dtype, PeriodDtype):
+            cls = dtype.construct_array_type()
+            return cls(arr.view('i8'), dtype=dtype)
+        elif isinstance(dtype, DatetimeTZDtype):
+            dt_cls = dtype.construct_array_type()
+            dt64_values = arr.view(f'M8[{dtype.unit}]')
+            return dt_cls._simple_new(dt64_values, dtype=dtype)
+        elif lib.is_np_dtype(dtype, 'M') and is_supported_dtype(dtype):
+            from pandas.core.arrays import DatetimeArray
+            dt64_values = arr.view(dtype)
+            return DatetimeArray._simple_new(dt64_values, dtype=dtype)
+        elif lib.is_np_dtype(dtype, 'm') and is_supported_dtype(dtype):
+            from pandas.core.arrays import TimedeltaArray
+            td64_values = arr.view(dtype)
+            return TimedeltaArray._simple_new(td64_values, dtype=dtype)
+        return arr.view(dtype=dtype)
+
+    def take(self, indices: TakeIndexer, *, allow_fill: bool=False, fill_value: Any=None, axis: AxisInt=0) -> Self:
+        if allow_fill:
+            fill_value = self._validate_scalar(fill_value)
+        new_data = take(self._ndarray, indices, allow_fill=allow_fill, fill_value=fill_value, axis=axis)
+        return self._from_backing_data(new_data)
+
+    def equals(self, other) -> bool:
+        if type(self) is not type(other):
+            return False
+        if self.dtype != other.dtype:
+            return False
+        return bool(array_equivalent(self._ndarray, other._ndarray, dtype_equal=True))
+
+    @classmethod
+    def _from_factorized(cls, values, original):
+        assert values.dtype == original._ndarray.dtype
+        return original._from_backing_data(values)
+
+    def _values_for_argsort(self) -> np.ndarray:
+        return self._ndarray
+
+    def _values_for_factorize(self):
+        return (self._ndarray, self._internal_fill_value)
+
+    def _hash_pandas_object(self, *, encoding: str, hash_key: str, categorize: bool) -> npt.NDArray[np.uint64]:
+        from pandas.core.util.hashing import hash_array
+        values = self._ndarray
+        return hash_array(values, encoding=encoding, hash_key=hash_key, categorize=categorize)
+
+    def argmin(self, axis: AxisInt=0, skipna: bool=True):
+        validate_bool_kwarg(skipna, 'skipna')
+        if not skipna and self._hasna:
+            raise ValueError('Encountered an NA value with skipna=False')
+        return nargminmax(self, 'argmin', axis=axis)
+
+    def argmax(self, axis: AxisInt=0, skipna: bool=True):
+        validate_bool_kwarg(skipna, 'skipna')
+        if not skipna and self._hasna:
+            raise ValueError('Encountered an NA value with skipna=False')
+        return nargminmax(self, 'argmax', axis=axis)
+
+    def unique(self) -> Self:
+        new_data = unique(self._ndarray)
+        return self._from_backing_data(new_data)
+
+    @classmethod
+    @doc(ExtensionArray._concat_same_type)
+    def _concat_same_type(cls, to_concat: Sequence[Self], axis: AxisInt=0) -> Self:
+        if not lib.dtypes_all_equal([x.dtype for x in to_concat]):
+            dtypes = {str(x.dtype) for x in to_concat}
+            raise ValueError('to_concat must have the same dtype', dtypes)
+        return super()._concat_same_type(to_concat, axis=axis)
+
+    @doc(ExtensionArray.searchsorted)
+    def searchsorted(self, value: NumpyValueArrayLike | ExtensionArray, side: Literal['left', 'right']='left', sorter: NumpySorter | None=None) -> npt.NDArray[np.intp] | np.intp:
+        npvalue = self._validate_setitem_value(value)
+        return self._ndarray.searchsorted(npvalue, side=side, sorter=sorter)
+
+    @doc(ExtensionArray.shift)
+    def shift(self, periods: int=1, fill_value=None) -> Self:
+        axis = 0
+        fill_value = self._validate_scalar(fill_value)
+        new_values = shift(self._ndarray, periods, axis, fill_value)
+        return self._from_backing_data(new_values)
+
+    def __setitem__(self, key, value) -> None:
+        key = check_array_indexer(self, key)
+        value = self._validate_setitem_value(value)
+        self._ndarray[key] = value
+
+    def _validate_setitem_value(self, value):
+        return value
+
+    @overload
+    def __getitem__(self, key: ScalarIndexer) -> Any:
+        ...
+
+    @overload
+    def __getitem__(self, key: SequenceIndexer | PositionalIndexerTuple) -> Self:
+        ...
+
+    def __getitem__(self, key: PositionalIndexer2D) -> Self | Any:
+        if lib.is_integer(key):
+            result = self._ndarray[key]
+            if self.ndim == 1:
+                return self._box_func(result)
+            return self._from_backing_data(result)
+        key = extract_array(key, extract_numpy=True)
+        key = check_array_indexer(self, key)
+        result = self._ndarray[key]
+        if lib.is_scalar(result):
+            return self._box_func(result)
+        result = self._from_backing_data(result)
+        return result
+
+    def _pad_or_backfill(self, *, method: FillnaOptions, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None, copy: bool=True) -> Self:
+        mask = self.isna()
+        if mask.any():
+            func = missing.get_fill_func(method, ndim=self.ndim)
+            npvalues = self._ndarray.T
+            if copy:
+                npvalues = npvalues.copy()
+            func(npvalues, limit=limit, limit_area=limit_area, mask=mask.T)
+            npvalues = npvalues.T
+            if copy:
+                new_values = self._from_backing_data(npvalues)
+            else:
+                new_values = self
+        elif copy:
+            new_values = self.copy()
+        else:
+            new_values = self
+        return new_values
+
+    @doc(ExtensionArray.fillna)
+    def fillna(self, value, limit: int | None=None, copy: bool=True) -> Self:
+        mask = self.isna()
+        if limit is not None and limit < len(self):
+            modify = mask.cumsum() > limit
+            if modify.any():
+                mask = mask.copy()
+                mask[modify] = False
+        value = missing.check_value_size(value, mask, len(self))
+        if mask.any():
+            if copy:
+                new_values = self.copy()
+            else:
+                new_values = self[:]
+            new_values[mask] = value
+        else:
+            self._validate_setitem_value(value)
+            if not copy:
+                new_values = self[:]
+            else:
+                new_values = self.copy()
+        return new_values
+
+    def _wrap_reduction_result(self, axis: AxisInt | None, result) -> Any:
+        if axis is None or self.ndim == 1:
+            return self._box_func(result)
+        return self._from_backing_data(result)
+
+    def _putmask(self, mask: npt.NDArray[np.bool_], value) -> None:
+        value = self._validate_setitem_value(value)
+        np.putmask(self._ndarray, mask, value)
+
+    def _where(self: Self, mask: npt.NDArray[np.bool_], value) -> Self:
+        value = self._validate_setitem_value(value)
+        res_values = np.where(mask, self._ndarray, value)
+        if res_values.dtype != self._ndarray.dtype:
+            raise AssertionError('Something has gone wrong, please report a bug at github.com/pandas-dev/pandas/')
+        return self._from_backing_data(res_values)
+
+    def insert(self, loc: int, item) -> Self:
+        loc = validate_insert_loc(loc, len(self))
+        code = self._validate_scalar(item)
+        new_vals = np.concatenate((self._ndarray[:loc], np.asarray([code], dtype=self._ndarray.dtype), self._ndarray[loc:]))
+        return self._from_backing_data(new_vals)
+
+    def value_counts(self, dropna: bool=True) -> Series:
+        if self.ndim != 1:
+            raise NotImplementedError
+        from pandas import Index, Series
+        if dropna:
+            values = self[~self.isna()]._ndarray
+        else:
+            values = self._ndarray
+        result = value_counts(values, sort=False, dropna=dropna)
+        index_arr = self._from_backing_data(np.asarray(result.index._data))
+        index = Index(index_arr, name=result.index.name)
+        return Series(result._values, index=index, name=result.name, copy=False)
+
+    def _quantile(self, qs: npt.NDArray[np.float64], interpolation: str) -> Self:
+        mask = np.asarray(self.isna())
+        arr = self._ndarray
+        fill_value = self._internal_fill_value
+        res_values = quantile_with_mask(arr, mask, fill_value, qs, interpolation)
+        if res_values.dtype == self._ndarray.dtype:
+            return self._from_backing_data(res_values)
+        else:
+            return type(self)(res_values)
+
+    @classmethod
+    def _empty(cls, shape: Shape, dtype: ExtensionDtype) -> Self:
+        arr = cls._from_sequence([], dtype=dtype)
+        backing = np.empty(shape, dtype=arr._ndarray.dtype)
+        return arr._from_backing_data(backing)
+
+# File: pandas-main/pandas/core/arrays/_ranges.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs.lib import i8max
+from pandas._libs.tslibs import BaseOffset, OutOfBoundsDatetime, Timedelta, Timestamp, iNaT
+from pandas.core.construction import range_to_ndarray
+if TYPE_CHECKING:
+    from pandas._typing import npt
+
+def generate_regular_range(start: Timestamp | Timedelta | None, end: Timestamp | Timedelta | None, periods: int | None, freq: BaseOffset, unit: str='ns') -> npt.NDArray[np.intp]:
+    istart = start._value if start is not None else None
+    iend = end._value if end is not None else None
+    freq.nanos
+    td = Timedelta(freq)
+    b: int
+    e: int
+    try:
+        td = td.as_unit(unit, round_ok=False)
+    except ValueError as err:
+        raise ValueError(f'freq={freq} is incompatible with unit={unit}. Use a lower freq or a higher unit instead.') from err
+    stride = int(td._value)
+    if periods is None and istart is not None and (iend is not None):
+        b = istart
+        e = b + (iend - b) // stride * stride + stride // 2 + 1
+    elif istart is not None and periods is not None:
+        b = istart
+        e = _generate_range_overflow_safe(b, periods, stride, side='start')
+    elif iend is not None and periods is not None:
+        e = iend + stride
+        b = _generate_range_overflow_safe(e, periods, stride, side='end')
+    else:
+        raise ValueError("at least 'start' or 'end' should be specified if a 'period' is given.")
+    return range_to_ndarray(range(b, e, stride))
+
+def _generate_range_overflow_safe(endpoint: int, periods: int, stride: int, side: str='start') -> int:
+    assert side in ['start', 'end']
+    i64max = np.uint64(i8max)
+    msg = f'Cannot generate range with {side}={endpoint} and periods={periods}'
+    with np.errstate(over='raise'):
+        try:
+            addend = np.uint64(periods) * np.uint64(np.abs(stride))
+        except FloatingPointError as err:
+            raise OutOfBoundsDatetime(msg) from err
+    if np.abs(addend) <= i64max:
+        return _generate_range_overflow_safe_signed(endpoint, periods, stride, side)
+    elif endpoint > 0 and side == 'start' and (stride > 0) or (endpoint < 0 < stride and side == 'end'):
+        raise OutOfBoundsDatetime(msg)
+    elif side == 'end' and endpoint - stride <= i64max < endpoint:
+        return _generate_range_overflow_safe(endpoint - stride, periods - 1, stride, side)
+    mid_periods = periods // 2
+    remaining = periods - mid_periods
+    assert 0 < remaining < periods, (remaining, periods, endpoint, stride)
+    midpoint = int(_generate_range_overflow_safe(endpoint, mid_periods, stride, side))
+    return _generate_range_overflow_safe(midpoint, remaining, stride, side)
+
+def _generate_range_overflow_safe_signed(endpoint: int, periods: int, stride: int, side: str) -> int:
+    assert side in ['start', 'end']
+    if side == 'end':
+        stride *= -1
+    with np.errstate(over='raise'):
+        addend = np.int64(periods) * np.int64(stride)
+        try:
+            result = np.int64(endpoint) + addend
+            if result == iNaT:
+                raise OverflowError
+            return int(result)
+        except (FloatingPointError, OverflowError):
+            pass
+        assert stride > 0 and endpoint >= 0 or (stride < 0 and endpoint <= 0)
+        if stride > 0:
+            uresult = np.uint64(endpoint) + np.uint64(addend)
+            i64max = np.uint64(i8max)
+            assert uresult > i64max
+            if uresult <= i64max + np.uint64(stride):
+                return int(uresult)
+    raise OutOfBoundsDatetime(f'Cannot generate range with {side}={endpoint} and periods={periods}')
+
+# File: pandas-main/pandas/core/arrays/_utils.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+import numpy as np
+from pandas._libs import lib
+from pandas.errors import LossySetitemError
+from pandas.core.dtypes.cast import np_can_hold_element
+from pandas.core.dtypes.common import is_numeric_dtype
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike, npt
+
+def to_numpy_dtype_inference(arr: ArrayLike, dtype: npt.DTypeLike | None, na_value, hasna: bool) -> tuple[npt.DTypeLike, Any]:
+    if dtype is None and is_numeric_dtype(arr.dtype):
+        dtype_given = False
+        if hasna:
+            if arr.dtype.kind == 'b':
+                dtype = np.dtype(np.object_)
+            else:
+                if arr.dtype.kind in 'iu':
+                    dtype = np.dtype(np.float64)
+                else:
+                    dtype = arr.dtype.numpy_dtype
+                if na_value is lib.no_default:
+                    na_value = np.nan
+        else:
+            dtype = arr.dtype.numpy_dtype
+    elif dtype is not None:
+        dtype = np.dtype(dtype)
+        dtype_given = True
+    else:
+        dtype_given = True
+    if na_value is lib.no_default:
+        if dtype is None or not hasna:
+            na_value = arr.dtype.na_value
+        elif dtype.kind == 'f':
+            na_value = np.nan
+        elif dtype.kind == 'M':
+            na_value = np.datetime64('nat')
+        elif dtype.kind == 'm':
+            na_value = np.timedelta64('nat')
+        else:
+            na_value = arr.dtype.na_value
+    if not dtype_given and hasna:
+        try:
+            np_can_hold_element(dtype, na_value)
+        except LossySetitemError:
+            dtype = np.dtype(np.object_)
+    return (dtype, na_value)
+
+# File: pandas-main/pandas/core/arrays/arrow/_arrow_utils.py
+from __future__ import annotations
+import numpy as np
+import pyarrow
+
+def pyarrow_array_to_numpy_and_mask(arr, dtype: np.dtype) -> tuple[np.ndarray, np.ndarray]:
+    dtype = np.dtype(dtype)
+    if pyarrow.types.is_null(arr.type):
+        data = np.empty(len(arr), dtype=dtype)
+        mask = np.zeros(len(arr), dtype=bool)
+        return (data, mask)
+    buflist = arr.buffers()
+    offset = arr.offset * dtype.itemsize
+    length = len(arr) * dtype.itemsize
+    data_buf = buflist[1][offset:offset + length]
+    data = np.frombuffer(data_buf, dtype=dtype)
+    bitmask = buflist[0]
+    if bitmask is not None:
+        mask = pyarrow.BooleanArray.from_buffers(pyarrow.bool_(), len(arr), [None, bitmask], offset=arr.offset)
+        mask = np.asarray(mask)
+    else:
+        mask = np.ones(len(arr), dtype=bool)
+    return (data, mask)
+
+# File: pandas-main/pandas/core/arrays/arrow/accessors.py
+""""""
+from __future__ import annotations
+from abc import ABCMeta, abstractmethod
+from typing import TYPE_CHECKING, cast
+from pandas.compat import pa_version_under10p1, pa_version_under11p0
+from pandas.core.dtypes.common import is_list_like
+if not pa_version_under10p1:
+    import pyarrow as pa
+    import pyarrow.compute as pc
+    from pandas.core.dtypes.dtypes import ArrowDtype
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from pandas import DataFrame, Series
+
+class ArrowAccessor(metaclass=ABCMeta):
+
+    @abstractmethod
+    def __init__(self, data, validation_msg: str) -> None:
+        self._data = data
+        self._validation_msg = validation_msg
+        self._validate(data)
+
+    @abstractmethod
+    def _is_valid_pyarrow_dtype(self, pyarrow_dtype) -> bool:
+        pass
+
+    def _validate(self, data) -> None:
+        dtype = data.dtype
+        if not isinstance(dtype, ArrowDtype):
+            raise AttributeError(self._validation_msg.format(dtype=dtype))
+        if not self._is_valid_pyarrow_dtype(dtype.pyarrow_dtype):
+            raise AttributeError(self._validation_msg.format(dtype=dtype))
+
+    @property
+    def _pa_array(self):
+        return self._data.array._pa_array
+
+class ListAccessor(ArrowAccessor):
+
+    def __init__(self, data=None) -> None:
+        super().__init__(data, validation_msg="Can only use the '.list' accessor with 'list[pyarrow]' dtype, not {dtype}.")
+
+    def _is_valid_pyarrow_dtype(self, pyarrow_dtype) -> bool:
+        return pa.types.is_list(pyarrow_dtype) or pa.types.is_fixed_size_list(pyarrow_dtype) or pa.types.is_large_list(pyarrow_dtype)
+
+    def len(self) -> Series:
+        from pandas import Series
+        value_lengths = pc.list_value_length(self._pa_array)
+        return Series(value_lengths, dtype=ArrowDtype(value_lengths.type), index=self._data.index)
+
+    def __getitem__(self, key: int | slice) -> Series:
+        from pandas import Series
+        if isinstance(key, int):
+            element = pc.list_element(self._pa_array, key)
+            return Series(element, dtype=ArrowDtype(element.type), index=self._data.index)
+        elif isinstance(key, slice):
+            if pa_version_under11p0:
+                raise NotImplementedError(f'List slice not supported by pyarrow {pa.__version__}.')
+            (start, stop, step) = (key.start, key.stop, key.step)
+            if start is None:
+                start = 0
+            if step is None:
+                step = 1
+            sliced = pc.list_slice(self._pa_array, start, stop, step)
+            return Series(sliced, dtype=ArrowDtype(sliced.type), index=self._data.index)
+        else:
+            raise ValueError(f'key must be an int or slice, got {type(key).__name__}')
+
+    def __iter__(self) -> Iterator:
+        raise TypeError(f"'{type(self).__name__}' object is not iterable")
+
+    def flatten(self) -> Series:
+        from pandas import Series
+        counts = pa.compute.list_value_length(self._pa_array)
+        flattened = pa.compute.list_flatten(self._pa_array)
+        index = self._data.index.repeat(counts.fill_null(pa.scalar(0, counts.type)))
+        return Series(flattened, dtype=ArrowDtype(flattened.type), index=index)
+
+class StructAccessor(ArrowAccessor):
+
+    def __init__(self, data=None) -> None:
+        super().__init__(data, validation_msg="Can only use the '.struct' accessor with 'struct[pyarrow]' dtype, not {dtype}.")
+
+    def _is_valid_pyarrow_dtype(self, pyarrow_dtype) -> bool:
+        return pa.types.is_struct(pyarrow_dtype)
+
+    @property
+    def dtypes(self) -> Series:
+        from pandas import Index, Series
+        pa_type = self._data.dtype.pyarrow_dtype
+        types = [ArrowDtype(struct.type) for struct in pa_type]
+        names = [struct.name for struct in pa_type]
+        return Series(types, index=Index(names))
+
+    def field(self, name_or_index: list[str] | list[bytes] | list[int] | pc.Expression | bytes | str | int) -> Series:
+        from pandas import Series
+
+        def get_name(level_name_or_index: list[str] | list[bytes] | list[int] | pc.Expression | bytes | str | int, data: pa.ChunkedArray):
+            if isinstance(level_name_or_index, int):
+                name = data.type.field(level_name_or_index).name
+            elif isinstance(level_name_or_index, (str, bytes)):
+                name = level_name_or_index
+            elif isinstance(level_name_or_index, pc.Expression):
+                name = str(level_name_or_index)
+            elif is_list_like(level_name_or_index):
+                level_name_or_index = list(reversed(level_name_or_index))
+                selected = data
+                while level_name_or_index:
+                    level_name_or_index = cast(list, level_name_or_index)
+                    name_or_index = level_name_or_index.pop()
+                    name = get_name(name_or_index, selected)
+                    selected = selected.type.field(selected.type.get_field_index(name))
+                    name = selected.name
+            else:
+                raise ValueError('name_or_index must be an int, str, bytes, pyarrow.compute.Expression, or list of those')
+            return name
+        pa_arr = self._data.array._pa_array
+        name = get_name(name_or_index, pa_arr)
+        field_arr = pc.struct_field(pa_arr, name_or_index)
+        return Series(field_arr, dtype=ArrowDtype(field_arr.type), index=self._data.index, name=name)
+
+    def explode(self) -> DataFrame:
+        from pandas import concat
+        pa_type = self._pa_array.type
+        return concat([self.field(i) for i in range(pa_type.num_fields)], axis='columns')
+
+# File: pandas-main/pandas/core/arrays/arrow/array.py
+from __future__ import annotations
+import functools
+import operator
+import re
+import textwrap
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
+import unicodedata
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.tslibs import Timedelta, Timestamp, timezones
+from pandas.compat import pa_version_under10p1, pa_version_under11p0, pa_version_under13p0
+from pandas.util._decorators import doc
+from pandas.core.dtypes.cast import can_hold_element, infer_dtype_from_scalar
+from pandas.core.dtypes.common import CategoricalDtype, is_array_like, is_bool_dtype, is_float_dtype, is_integer, is_list_like, is_numeric_dtype, is_scalar, pandas_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+from pandas.core.dtypes.missing import isna
+from pandas.core import algorithms as algos, missing, ops, roperator
+from pandas.core.algorithms import map_array
+from pandas.core.arraylike import OpsMixin
+from pandas.core.arrays._arrow_string_mixins import ArrowStringArrayMixin
+from pandas.core.arrays._utils import to_numpy_dtype_inference
+from pandas.core.arrays.base import ExtensionArray, ExtensionArraySupportsAnyAll
+from pandas.core.arrays.masked import BaseMaskedArray
+from pandas.core.arrays.string_ import StringDtype
+import pandas.core.common as com
+from pandas.core.indexers import check_array_indexer, unpack_tuple_and_ellipses, validate_indices
+from pandas.core.strings.base import BaseStringArrayMethods
+from pandas.io._util import _arrow_dtype_mapping
+from pandas.tseries.frequencies import to_offset
+if not pa_version_under10p1:
+    import pyarrow as pa
+    import pyarrow.compute as pc
+    from pandas.core.dtypes.dtypes import ArrowDtype
+    ARROW_CMP_FUNCS = {'eq': pc.equal, 'ne': pc.not_equal, 'lt': pc.less, 'gt': pc.greater, 'le': pc.less_equal, 'ge': pc.greater_equal}
+    ARROW_LOGICAL_FUNCS = {'and_': pc.and_kleene, 'rand_': lambda x, y: pc.and_kleene(y, x), 'or_': pc.or_kleene, 'ror_': lambda x, y: pc.or_kleene(y, x), 'xor': pc.xor, 'rxor': lambda x, y: pc.xor(y, x)}
+    ARROW_BIT_WISE_FUNCS = {'and_': pc.bit_wise_and, 'rand_': lambda x, y: pc.bit_wise_and(y, x), 'or_': pc.bit_wise_or, 'ror_': lambda x, y: pc.bit_wise_or(y, x), 'xor': pc.bit_wise_xor, 'rxor': lambda x, y: pc.bit_wise_xor(y, x)}
+
+    def cast_for_truediv(arrow_array: pa.ChunkedArray, pa_object: pa.Array | pa.Scalar) -> tuple[pa.ChunkedArray, pa.Array | pa.Scalar]:
+        if pa.types.is_integer(arrow_array.type) and pa.types.is_integer(pa_object.type):
+            return (pc.cast(arrow_array, pa.float64(), safe=False), pc.cast(pa_object, pa.float64(), safe=False))
+        return (arrow_array, pa_object)
+
+    def floordiv_compat(left: pa.ChunkedArray | pa.Array | pa.Scalar, right: pa.ChunkedArray | pa.Array | pa.Scalar) -> pa.ChunkedArray:
+        if pa.types.is_integer(left.type) and pa.types.is_integer(right.type):
+            divided = pc.divide_checked(left, right)
+            if pa.types.is_signed_integer(divided.type):
+                has_remainder = pc.not_equal(pc.multiply(divided, right), left)
+                has_one_negative_operand = pc.less(pc.bit_wise_xor(left, right), pa.scalar(0, type=divided.type))
+                result = pc.if_else(pc.and_(has_remainder, has_one_negative_operand), pc.subtract(divided, pa.scalar(1, type=divided.type)), divided)
+            else:
+                result = divided
+            result = result.cast(left.type)
+        else:
+            divided = pc.divide(left, right)
+            result = pc.floor(divided)
+        return result
+    ARROW_ARITHMETIC_FUNCS = {'add': pc.add_checked, 'radd': lambda x, y: pc.add_checked(y, x), 'sub': pc.subtract_checked, 'rsub': lambda x, y: pc.subtract_checked(y, x), 'mul': pc.multiply_checked, 'rmul': lambda x, y: pc.multiply_checked(y, x), 'truediv': lambda x, y: pc.divide(*cast_for_truediv(x, y)), 'rtruediv': lambda x, y: pc.divide(*cast_for_truediv(y, x)), 'floordiv': lambda x, y: floordiv_compat(x, y), 'rfloordiv': lambda x, y: floordiv_compat(y, x), 'mod': NotImplemented, 'rmod': NotImplemented, 'divmod': NotImplemented, 'rdivmod': NotImplemented, 'pow': pc.power_checked, 'rpow': lambda x, y: pc.power_checked(y, x)}
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+    from pandas._libs.missing import NAType
+    from pandas._typing import ArrayLike, AxisInt, Dtype, FillnaOptions, InterpolateOptions, Iterator, NpDtype, NumpySorter, NumpyValueArrayLike, PositionalIndexer, Scalar, Self, SortKind, TakeIndexer, TimeAmbiguous, TimeNonexistent, npt
+    from pandas.core.dtypes.dtypes import ExtensionDtype
+    from pandas import Series
+    from pandas.core.arrays.datetimes import DatetimeArray
+    from pandas.core.arrays.timedeltas import TimedeltaArray
+
+def get_unit_from_pa_dtype(pa_dtype) -> str:
+    if pa_version_under11p0:
+        unit = str(pa_dtype).split('[', 1)[-1][:-1]
+        if unit not in ['s', 'ms', 'us', 'ns']:
+            raise ValueError(pa_dtype)
+        return unit
+    return pa_dtype.unit
+
+def to_pyarrow_type(dtype: ArrowDtype | pa.DataType | Dtype | None) -> pa.DataType | None:
+    if isinstance(dtype, ArrowDtype):
+        return dtype.pyarrow_dtype
+    elif isinstance(dtype, pa.DataType):
+        return dtype
+    elif isinstance(dtype, DatetimeTZDtype):
+        return pa.timestamp(dtype.unit, dtype.tz)
+    elif dtype:
+        try:
+            return pa.from_numpy_dtype(dtype)
+        except pa.ArrowNotImplementedError:
+            pass
+    return None
+
+class ArrowExtensionArray(OpsMixin, ExtensionArraySupportsAnyAll, ArrowStringArrayMixin, BaseStringArrayMethods):
+    _pa_array: pa.ChunkedArray
+    _dtype: ArrowDtype
+
+    def __init__(self, values: pa.Array | pa.ChunkedArray) -> None:
+        if pa_version_under10p1:
+            msg = 'pyarrow>=10.0.1 is required for PyArrow backed ArrowExtensionArray.'
+            raise ImportError(msg)
+        if isinstance(values, pa.Array):
+            self._pa_array = pa.chunked_array([values])
+        elif isinstance(values, pa.ChunkedArray):
+            self._pa_array = values
+        else:
+            raise ValueError(f"Unsupported type '{type(values)}' for ArrowExtensionArray")
+        self._dtype = ArrowDtype(self._pa_array.type)
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype: Dtype | None=None, copy: bool=False) -> Self:
+        pa_type = to_pyarrow_type(dtype)
+        pa_array = cls._box_pa_array(scalars, pa_type=pa_type, copy=copy)
+        arr = cls(pa_array)
+        return arr
+
+    @classmethod
+    def _from_sequence_of_strings(cls, strings, *, dtype: ExtensionDtype, copy: bool=False) -> Self:
+        pa_type = to_pyarrow_type(dtype)
+        if pa_type is None or pa.types.is_binary(pa_type) or pa.types.is_string(pa_type) or pa.types.is_large_string(pa_type):
+            scalars = strings
+        elif pa.types.is_timestamp(pa_type):
+            from pandas.core.tools.datetimes import to_datetime
+            scalars = to_datetime(strings, errors='raise')
+        elif pa.types.is_date(pa_type):
+            from pandas.core.tools.datetimes import to_datetime
+            scalars = to_datetime(strings, errors='raise').date
+        elif pa.types.is_duration(pa_type):
+            from pandas.core.tools.timedeltas import to_timedelta
+            scalars = to_timedelta(strings, errors='raise')
+            if pa_type.unit != 'ns':
+                mask = isna(scalars)
+                if not isinstance(strings, (pa.Array, pa.ChunkedArray)):
+                    strings = pa.array(strings, type=pa.string(), from_pandas=True)
+                strings = pc.if_else(mask, None, strings)
+                try:
+                    scalars = strings.cast(pa.int64())
+                except pa.ArrowInvalid:
+                    pass
+        elif pa.types.is_time(pa_type):
+            from pandas.core.tools.times import to_time
+            scalars = to_time(strings, errors='coerce')
+        elif pa.types.is_boolean(pa_type):
+            if isinstance(strings, (pa.Array, pa.ChunkedArray)):
+                scalars = strings
+            else:
+                scalars = pa.array(strings, type=pa.string(), from_pandas=True)
+            scalars = pc.if_else(pc.equal(scalars, '1.0'), '1', scalars)
+            scalars = pc.if_else(pc.equal(scalars, '0.0'), '0', scalars)
+            scalars = scalars.cast(pa.bool_())
+        elif pa.types.is_integer(pa_type) or pa.types.is_floating(pa_type) or pa.types.is_decimal(pa_type):
+            from pandas.core.tools.numeric import to_numeric
+            scalars = to_numeric(strings, errors='raise')
+        else:
+            raise NotImplementedError(f'Converting strings to {pa_type} is not implemented.')
+        return cls._from_sequence(scalars, dtype=pa_type, copy=copy)
+
+    @classmethod
+    def _box_pa(cls, value, pa_type: pa.DataType | None=None) -> pa.Array | pa.ChunkedArray | pa.Scalar:
+        if isinstance(value, pa.Scalar) or not is_list_like(value):
+            return cls._box_pa_scalar(value, pa_type)
+        return cls._box_pa_array(value, pa_type)
+
+    @classmethod
+    def _box_pa_scalar(cls, value, pa_type: pa.DataType | None=None) -> pa.Scalar:
+        if isinstance(value, pa.Scalar):
+            pa_scalar = value
+        elif isna(value):
+            pa_scalar = pa.scalar(None, type=pa_type)
+        else:
+            if isinstance(value, Timedelta):
+                if pa_type is None:
+                    pa_type = pa.duration(value.unit)
+                elif value.unit != pa_type.unit:
+                    value = value.as_unit(pa_type.unit)
+                value = value._value
+            elif isinstance(value, Timestamp):
+                if pa_type is None:
+                    pa_type = pa.timestamp(value.unit, tz=value.tz)
+                elif value.unit != pa_type.unit:
+                    value = value.as_unit(pa_type.unit)
+                value = value._value
+            pa_scalar = pa.scalar(value, type=pa_type, from_pandas=True)
+        if pa_type is not None and pa_scalar.type != pa_type:
+            pa_scalar = pa_scalar.cast(pa_type)
+        return pa_scalar
+
+    @classmethod
+    def _box_pa_array(cls, value, pa_type: pa.DataType | None=None, copy: bool=False) -> pa.Array | pa.ChunkedArray:
+        if isinstance(value, cls):
+            pa_array = value._pa_array
+        elif isinstance(value, (pa.Array, pa.ChunkedArray)):
+            pa_array = value
+        elif isinstance(value, BaseMaskedArray):
+            if copy:
+                value = value.copy()
+            pa_array = value.__arrow_array__()
+        else:
+            if isinstance(value, np.ndarray) and pa_type is not None and (pa.types.is_large_binary(pa_type) or pa.types.is_large_string(pa_type)):
+                value = value.tolist()
+            elif copy and is_array_like(value):
+                value = value.copy()
+            if pa_type is not None and pa.types.is_duration(pa_type) and (not isinstance(value, np.ndarray) or value.dtype.kind not in 'mi'):
+                from pandas.core.tools.timedeltas import to_timedelta
+                value = to_timedelta(value, unit=pa_type.unit).as_unit(pa_type.unit)
+                value = value.to_numpy()
+            try:
+                pa_array = pa.array(value, type=pa_type, from_pandas=True)
+            except (pa.ArrowInvalid, pa.ArrowTypeError):
+                pa_array = pa.array(value, from_pandas=True)
+            if pa_type is None and pa.types.is_duration(pa_array.type):
+                from pandas.core.tools.timedeltas import to_timedelta
+                value = to_timedelta(value)
+                value = value.to_numpy()
+                pa_array = pa.array(value, type=pa_type, from_pandas=True)
+            if pa.types.is_duration(pa_array.type) and pa_array.null_count > 0:
+                arr = cls(pa_array)
+                arr = arr.fillna(arr.dtype.na_value)
+                pa_array = arr._pa_array
+        if pa_type is not None and pa_array.type != pa_type:
+            if pa.types.is_dictionary(pa_type):
+                pa_array = pa_array.dictionary_encode()
+                if pa_array.type != pa_type:
+                    pa_array = pa_array.cast(pa_type)
+            else:
+                try:
+                    pa_array = pa_array.cast(pa_type)
+                except (pa.ArrowNotImplementedError, pa.ArrowTypeError):
+                    if pa.types.is_string(pa_array.type) or pa.types.is_large_string(pa_array.type):
+                        dtype = ArrowDtype(pa_type)
+                        return cls._from_sequence_of_strings(value, dtype=dtype)._pa_array
+                    else:
+                        raise
+        return pa_array
+
+    def __getitem__(self, item: PositionalIndexer):
+        item = check_array_indexer(self, item)
+        if isinstance(item, np.ndarray):
+            if not len(item):
+                if isinstance(self._dtype, StringDtype) and self._dtype.storage == 'pyarrow':
+                    pa_dtype = pa.string()
+                else:
+                    pa_dtype = self._dtype.pyarrow_dtype
+                return type(self)(pa.chunked_array([], type=pa_dtype))
+            elif item.dtype.kind in 'iu':
+                return self.take(item)
+            elif item.dtype.kind == 'b':
+                return type(self)(self._pa_array.filter(item))
+            else:
+                raise IndexError('Only integers, slices and integer or boolean arrays are valid indices.')
+        elif isinstance(item, tuple):
+            item = unpack_tuple_and_ellipses(item)
+        if item is Ellipsis:
+            item = slice(None)
+        if is_scalar(item) and (not is_integer(item)):
+            raise IndexError('only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices')
+        if isinstance(item, slice):
+            if item.start == item.stop:
+                pass
+            elif item.stop is not None and item.stop < -len(self) and (item.step is not None) and (item.step < 0):
+                item = slice(item.start, None, item.step)
+        value = self._pa_array[item]
+        if isinstance(value, pa.ChunkedArray):
+            return type(self)(value)
+        else:
+            pa_type = self._pa_array.type
+            scalar = value.as_py()
+            if scalar is None:
+                return self._dtype.na_value
+            elif pa.types.is_timestamp(pa_type) and pa_type.unit != 'ns':
+                return Timestamp(scalar).as_unit(pa_type.unit)
+            elif pa.types.is_duration(pa_type) and pa_type.unit != 'ns':
+                return Timedelta(scalar).as_unit(pa_type.unit)
+            else:
+                return scalar
+
+    def __iter__(self) -> Iterator[Any]:
+        na_value = self._dtype.na_value
+        pa_type = self._pa_array.type
+        box_timestamp = pa.types.is_timestamp(pa_type) and pa_type.unit != 'ns'
+        box_timedelta = pa.types.is_duration(pa_type) and pa_type.unit != 'ns'
+        for value in self._pa_array:
+            val = value.as_py()
+            if val is None:
+                yield na_value
+            elif box_timestamp:
+                yield Timestamp(val).as_unit(pa_type.unit)
+            elif box_timedelta:
+                yield Timedelta(val).as_unit(pa_type.unit)
+            else:
+                yield val
+
+    def __arrow_array__(self, type=None):
+        return self._pa_array
+
+    def __array__(self, dtype: NpDtype | None=None, copy: bool | None=None) -> np.ndarray:
+        return self.to_numpy(dtype=dtype)
+
+    def __invert__(self) -> Self:
+        if pa.types.is_integer(self._pa_array.type):
+            return type(self)(pc.bit_wise_not(self._pa_array))
+        elif pa.types.is_string(self._pa_array.type) or pa.types.is_large_string(self._pa_array.type):
+            raise TypeError('__invert__ is not supported for string dtypes')
+        else:
+            return type(self)(pc.invert(self._pa_array))
+
+    def __neg__(self) -> Self:
+        try:
+            return type(self)(pc.negate_checked(self._pa_array))
+        except pa.ArrowNotImplementedError as err:
+            raise TypeError(f"unary '-' not supported for dtype '{self.dtype}'") from err
+
+    def __pos__(self) -> Self:
+        return type(self)(self._pa_array)
+
+    def __abs__(self) -> Self:
+        return type(self)(pc.abs_checked(self._pa_array))
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state['_pa_array'] = self._pa_array.combine_chunks()
+        return state
+
+    def __setstate__(self, state) -> None:
+        if '_data' in state:
+            data = state.pop('_data')
+        else:
+            data = state['_pa_array']
+        state['_pa_array'] = pa.chunked_array(data)
+        self.__dict__.update(state)
+
+    def _cmp_method(self, other, op) -> ArrowExtensionArray:
+        pc_func = ARROW_CMP_FUNCS[op.__name__]
+        if isinstance(other, (ArrowExtensionArray, np.ndarray, list, BaseMaskedArray)) or isinstance(getattr(other, 'dtype', None), CategoricalDtype):
+            try:
+                result = pc_func(self._pa_array, self._box_pa(other))
+            except pa.ArrowNotImplementedError:
+                result = ops.invalid_comparison(self, other, op)
+                result = pa.array(result, type=pa.bool_())
+        elif is_scalar(other):
+            try:
+                result = pc_func(self._pa_array, self._box_pa(other))
+            except (pa.lib.ArrowNotImplementedError, pa.lib.ArrowInvalid):
+                mask = isna(self) | isna(other)
+                valid = ~mask
+                result = np.zeros(len(self), dtype='bool')
+                np_array = np.array(self)
+                try:
+                    result[valid] = op(np_array[valid], other)
+                except TypeError:
+                    result = ops.invalid_comparison(np_array, other, op)
+                result = pa.array(result, type=pa.bool_())
+                result = pc.if_else(valid, result, None)
+        else:
+            raise NotImplementedError(f'{op.__name__} not implemented for {type(other)}')
+        return ArrowExtensionArray(result)
+
+    def _op_method_error_message(self, other, op) -> str:
+        if hasattr(other, 'dtype'):
+            other_type = f"dtype '{other.dtype}'"
+        else:
+            other_type = f'object of type {type(other)}'
+        return f"operation '{op.__name__}' not supported for dtype '{self.dtype}' with {other_type}"
+
+    def _evaluate_op_method(self, other, op, arrow_funcs) -> Self:
+        pa_type = self._pa_array.type
+        other_original = other
+        other = self._box_pa(other)
+        if pa.types.is_string(pa_type) or pa.types.is_large_string(pa_type) or pa.types.is_binary(pa_type):
+            if op in [operator.add, roperator.radd]:
+                sep = pa.scalar('', type=pa_type)
+                try:
+                    if op is operator.add:
+                        result = pc.binary_join_element_wise(self._pa_array, other, sep)
+                    elif op is roperator.radd:
+                        result = pc.binary_join_element_wise(other, self._pa_array, sep)
+                except pa.ArrowNotImplementedError as err:
+                    raise TypeError(self._op_method_error_message(other_original, op)) from err
+                return type(self)(result)
+            elif op in [operator.mul, roperator.rmul]:
+                binary = self._pa_array
+                integral = other
+                if not pa.types.is_integer(integral.type):
+                    raise TypeError('Can only string multiply by an integer.')
+                pa_integral = pc.if_else(pc.less(integral, 0), 0, integral)
+                result = pc.binary_repeat(binary, pa_integral)
+                return type(self)(result)
+        elif (pa.types.is_string(other.type) or pa.types.is_binary(other.type) or pa.types.is_large_string(other.type)) and op in [operator.mul, roperator.rmul]:
+            binary = other
+            integral = self._pa_array
+            if not pa.types.is_integer(integral.type):
+                raise TypeError('Can only string multiply by an integer.')
+            pa_integral = pc.if_else(pc.less(integral, 0), 0, integral)
+            result = pc.binary_repeat(binary, pa_integral)
+            return type(self)(result)
+        if isinstance(other, pa.Scalar) and pc.is_null(other).as_py() and (op.__name__ in ARROW_LOGICAL_FUNCS):
+            other = other.cast(pa_type)
+        pc_func = arrow_funcs[op.__name__]
+        if pc_func is NotImplemented:
+            if pa.types.is_string(pa_type) or pa.types.is_large_string(pa_type):
+                raise TypeError(self._op_method_error_message(other_original, op))
+            raise NotImplementedError(f'{op.__name__} not implemented.')
+        try:
+            result = pc_func(self._pa_array, other)
+        except pa.ArrowNotImplementedError as err:
+            raise TypeError(self._op_method_error_message(other_original, op)) from err
+        return type(self)(result)
+
+    def _logical_method(self, other, op) -> Self:
+        if pa.types.is_integer(self._pa_array.type):
+            return self._evaluate_op_method(other, op, ARROW_BIT_WISE_FUNCS)
+        else:
+            return self._evaluate_op_method(other, op, ARROW_LOGICAL_FUNCS)
+
+    def _arith_method(self, other, op) -> Self:
+        return self._evaluate_op_method(other, op, ARROW_ARITHMETIC_FUNCS)
+
+    def equals(self, other) -> bool:
+        if not isinstance(other, ArrowExtensionArray):
+            return False
+        return self._pa_array == other._pa_array
+
+    @property
+    def dtype(self) -> ArrowDtype:
+        return self._dtype
+
+    @property
+    def nbytes(self) -> int:
+        return self._pa_array.nbytes
+
+    def __len__(self) -> int:
+        return len(self._pa_array)
+
+    def __contains__(self, key) -> bool:
+        if isna(key) and key is not self.dtype.na_value:
+            if self.dtype.kind == 'f' and lib.is_float(key):
+                return pc.any(pc.is_nan(self._pa_array)).as_py()
+            return False
+        return bool(super().__contains__(key))
+
+    @property
+    def _hasna(self) -> bool:
+        return self._pa_array.null_count > 0
+
+    def isna(self) -> npt.NDArray[np.bool_]:
+        null_count = self._pa_array.null_count
+        if null_count == 0:
+            return np.zeros(len(self), dtype=np.bool_)
+        elif null_count == len(self):
+            return np.ones(len(self), dtype=np.bool_)
+        return self._pa_array.is_null().to_numpy()
+
+    @overload
+    def any(self, *, skipna: Literal[True]=..., **kwargs) -> bool:
+        ...
+
+    @overload
+    def any(self, *, skipna: bool, **kwargs) -> bool | NAType:
+        ...
+
+    def any(self, *, skipna: bool=True, **kwargs) -> bool | NAType:
+        return self._reduce('any', skipna=skipna, **kwargs)
+
+    @overload
+    def all(self, *, skipna: Literal[True]=..., **kwargs) -> bool:
+        ...
+
+    @overload
+    def all(self, *, skipna: bool, **kwargs) -> bool | NAType:
+        ...
+
+    def all(self, *, skipna: bool=True, **kwargs) -> bool | NAType:
+        return self._reduce('all', skipna=skipna, **kwargs)
+
+    def argsort(self, *, ascending: bool=True, kind: SortKind='quicksort', na_position: str='last', **kwargs) -> np.ndarray:
+        order = 'ascending' if ascending else 'descending'
+        null_placement = {'last': 'at_end', 'first': 'at_start'}.get(na_position, None)
+        if null_placement is None:
+            raise ValueError(f'invalid na_position: {na_position}')
+        result = pc.array_sort_indices(self._pa_array, order=order, null_placement=null_placement)
+        np_result = result.to_numpy()
+        return np_result.astype(np.intp, copy=False)
+
+    def _argmin_max(self, skipna: bool, method: str) -> int:
+        if self._pa_array.length() in (0, self._pa_array.null_count) or (self._hasna and (not skipna)):
+            return getattr(super(), f'arg{method}')(skipna=skipna)
+        data = self._pa_array
+        if pa.types.is_duration(data.type):
+            data = data.cast(pa.int64())
+        value = getattr(pc, method)(data, skip_nulls=skipna)
+        return pc.index(data, value).as_py()
+
+    def argmin(self, skipna: bool=True) -> int:
+        return self._argmin_max(skipna, 'min')
+
+    def argmax(self, skipna: bool=True) -> int:
+        return self._argmin_max(skipna, 'max')
+
+    def copy(self) -> Self:
+        return type(self)(self._pa_array)
+
+    def dropna(self) -> Self:
+        return type(self)(pc.drop_null(self._pa_array))
+
+    def _pad_or_backfill(self, *, method: FillnaOptions, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None, copy: bool=True) -> Self:
+        if not self._hasna:
+            return self
+        if limit is None and limit_area is None:
+            method = missing.clean_fill_method(method)
+            try:
+                if method == 'pad':
+                    return type(self)(pc.fill_null_forward(self._pa_array))
+                elif method == 'backfill':
+                    return type(self)(pc.fill_null_backward(self._pa_array))
+            except pa.ArrowNotImplementedError:
+                pass
+        return super()._pad_or_backfill(method=method, limit=limit, limit_area=limit_area, copy=copy)
+
+    @doc(ExtensionArray.fillna)
+    def fillna(self, value: object | ArrayLike, limit: int | None=None, copy: bool=True) -> Self:
+        if not self._hasna:
+            return self.copy()
+        if limit is not None:
+            return super().fillna(value=value, limit=limit, copy=copy)
+        if isinstance(value, (np.ndarray, ExtensionArray)):
+            if len(value) != len(self):
+                raise ValueError(f"Length of 'value' does not match. Got ({len(value)})  expected {len(self)}")
+        try:
+            fill_value = self._box_pa(value, pa_type=self._pa_array.type)
+        except pa.ArrowTypeError as err:
+            msg = f"Invalid value '{value!s}' for dtype {self.dtype}"
+            raise TypeError(msg) from err
+        try:
+            return type(self)(pc.fill_null(self._pa_array, fill_value=fill_value))
+        except pa.ArrowNotImplementedError:
+            pass
+        return super().fillna(value=value, limit=limit, copy=copy)
+
+    def isin(self, values: ArrayLike) -> npt.NDArray[np.bool_]:
+        if not len(values):
+            return np.zeros(len(self), dtype=bool)
+        result = pc.is_in(self._pa_array, value_set=pa.array(values, from_pandas=True))
+        return np.array(result, dtype=np.bool_)
+
+    def _values_for_factorize(self) -> tuple[np.ndarray, Any]:
+        values = self._pa_array.to_numpy()
+        return (values, self.dtype.na_value)
+
+    @doc(ExtensionArray.factorize)
+    def factorize(self, use_na_sentinel: bool=True) -> tuple[np.ndarray, ExtensionArray]:
+        null_encoding = 'mask' if use_na_sentinel else 'encode'
+        data = self._pa_array
+        pa_type = data.type
+        if pa_version_under11p0 and pa.types.is_duration(pa_type):
+            data = data.cast(pa.int64())
+        if pa.types.is_dictionary(data.type):
+            encoded = data
+        else:
+            encoded = data.dictionary_encode(null_encoding=null_encoding)
+        if encoded.length() == 0:
+            indices = np.array([], dtype=np.intp)
+            uniques = type(self)(pa.chunked_array([], type=encoded.type.value_type))
+        else:
+            combined = encoded.combine_chunks()
+            pa_indices = combined.indices
+            if pa_indices.null_count > 0:
+                pa_indices = pc.fill_null(pa_indices, -1)
+            indices = pa_indices.to_numpy(zero_copy_only=False, writable=True).astype(np.intp, copy=False)
+            uniques = type(self)(combined.dictionary)
+        if pa_version_under11p0 and pa.types.is_duration(pa_type):
+            uniques = cast(ArrowExtensionArray, uniques.astype(self.dtype))
+        return (indices, uniques)
+
+    def reshape(self, *args, **kwargs):
+        raise NotImplementedError(f'{type(self)} does not support reshape as backed by a 1D pyarrow.ChunkedArray.')
+
+    def round(self, decimals: int=0, *args, **kwargs) -> Self:
+        return type(self)(pc.round(self._pa_array, ndigits=decimals))
+
+    @doc(ExtensionArray.searchsorted)
+    def searchsorted(self, value: NumpyValueArrayLike | ExtensionArray, side: Literal['left', 'right']='left', sorter: NumpySorter | None=None) -> npt.NDArray[np.intp] | np.intp:
+        if self._hasna:
+            raise ValueError('searchsorted requires array to be sorted, which is impossible with NAs present.')
+        if isinstance(value, ExtensionArray):
+            value = value.astype(object)
+        dtype = None
+        if isinstance(self.dtype, ArrowDtype):
+            pa_dtype = self.dtype.pyarrow_dtype
+            if (pa.types.is_timestamp(pa_dtype) or pa.types.is_duration(pa_dtype)) and pa_dtype.unit == 'ns':
+                dtype = object
+        return self.to_numpy(dtype=dtype).searchsorted(value, side=side, sorter=sorter)
+
+    def take(self, indices: TakeIndexer, allow_fill: bool=False, fill_value: Any=None) -> ArrowExtensionArray:
+        indices_array = np.asanyarray(indices)
+        if len(self._pa_array) == 0 and (indices_array >= 0).any():
+            raise IndexError('cannot do a non-empty take')
+        if indices_array.size > 0 and indices_array.max() >= len(self._pa_array):
+            raise IndexError("out of bounds value in 'indices'.")
+        if allow_fill:
+            fill_mask = indices_array < 0
+            if fill_mask.any():
+                validate_indices(indices_array, len(self._pa_array))
+                indices_array = pa.array(indices_array, mask=fill_mask)
+                result = self._pa_array.take(indices_array)
+                if isna(fill_value):
+                    return type(self)(result)
+                result = type(self)(result)
+                result[fill_mask] = fill_value
+                return result
+            else:
+                return type(self)(self._pa_array.take(indices))
+        else:
+            if (indices_array < 0).any():
+                indices_array = np.copy(indices_array)
+                indices_array[indices_array < 0] += len(self._pa_array)
+            return type(self)(self._pa_array.take(indices_array))
+
+    def _maybe_convert_datelike_array(self):
+        pa_type = self._pa_array.type
+        if pa.types.is_timestamp(pa_type):
+            return self._to_datetimearray()
+        elif pa.types.is_duration(pa_type):
+            return self._to_timedeltaarray()
+        return self
+
+    def _to_datetimearray(self) -> DatetimeArray:
+        from pandas.core.arrays.datetimes import DatetimeArray, tz_to_dtype
+        pa_type = self._pa_array.type
+        assert pa.types.is_timestamp(pa_type)
+        np_dtype = np.dtype(f'M8[{pa_type.unit}]')
+        dtype = tz_to_dtype(pa_type.tz, pa_type.unit)
+        np_array = self._pa_array.to_numpy()
+        np_array = np_array.astype(np_dtype)
+        return DatetimeArray._simple_new(np_array, dtype=dtype)
+
+    def _to_timedeltaarray(self) -> TimedeltaArray:
+        from pandas.core.arrays.timedeltas import TimedeltaArray
+        pa_type = self._pa_array.type
+        assert pa.types.is_duration(pa_type)
+        np_dtype = np.dtype(f'm8[{pa_type.unit}]')
+        np_array = self._pa_array.to_numpy()
+        np_array = np_array.astype(np_dtype)
+        return TimedeltaArray._simple_new(np_array, dtype=np_dtype)
+
+    def _values_for_json(self) -> np.ndarray:
+        if is_numeric_dtype(self.dtype):
+            return np.asarray(self, dtype=object)
+        return super()._values_for_json()
+
+    @doc(ExtensionArray.to_numpy)
+    def to_numpy(self, dtype: npt.DTypeLike | None=None, copy: bool=False, na_value: object=lib.no_default) -> np.ndarray:
+        original_na_value = na_value
+        (dtype, na_value) = to_numpy_dtype_inference(self, dtype, na_value, self._hasna)
+        pa_type = self._pa_array.type
+        if not self._hasna or isna(na_value) or pa.types.is_null(pa_type):
+            data = self
+        else:
+            data = self.fillna(na_value)
+            copy = False
+        if pa.types.is_timestamp(pa_type) or pa.types.is_duration(pa_type):
+            if dtype != object and na_value is self.dtype.na_value:
+                na_value = lib.no_default
+            result = data._maybe_convert_datelike_array().to_numpy(dtype=dtype, na_value=na_value)
+        elif pa.types.is_time(pa_type) or pa.types.is_date(pa_type):
+            result = np.array(list(data), dtype=dtype)
+            if data._hasna:
+                result[data.isna()] = na_value
+        elif pa.types.is_null(pa_type):
+            if dtype is not None and isna(na_value):
+                na_value = None
+            result = np.full(len(data), fill_value=na_value, dtype=dtype)
+        elif not data._hasna or (pa.types.is_floating(pa_type) and (na_value is np.nan or (original_na_value is lib.no_default and is_float_dtype(dtype)))):
+            result = data._pa_array.to_numpy()
+            if dtype is not None:
+                result = result.astype(dtype, copy=False)
+            if copy:
+                result = result.copy()
+        else:
+            if dtype is None:
+                empty = pa.array([], type=pa_type).to_numpy(zero_copy_only=False)
+                if can_hold_element(empty, na_value):
+                    dtype = empty.dtype
+                else:
+                    dtype = np.object_
+            result = np.empty(len(data), dtype=dtype)
+            mask = data.isna()
+            result[mask] = na_value
+            result[~mask] = data[~mask]._pa_array.to_numpy()
+        return result
+
+    def map(self, mapper, na_action: Literal['ignore'] | None=None):
+        if is_numeric_dtype(self.dtype):
+            return map_array(self.to_numpy(), mapper, na_action=na_action)
+        else:
+            return super().map(mapper, na_action)
+
+    @doc(ExtensionArray.duplicated)
+    def duplicated(self, keep: Literal['first', 'last', False]='first') -> npt.NDArray[np.bool_]:
+        pa_type = self._pa_array.type
+        if pa.types.is_floating(pa_type) or pa.types.is_integer(pa_type):
+            values = self.to_numpy(na_value=0)
+        elif pa.types.is_boolean(pa_type):
+            values = self.to_numpy(na_value=False)
+        elif pa.types.is_temporal(pa_type):
+            if pa_type.bit_width == 32:
+                pa_type = pa.int32()
+            else:
+                pa_type = pa.int64()
+            arr = self.astype(ArrowDtype(pa_type))
+            values = arr.to_numpy(na_value=0)
+        else:
+            values = self.factorize()[0]
+        mask = self.isna() if self._hasna else None
+        return algos.duplicated(values, keep=keep, mask=mask)
+
+    def unique(self) -> Self:
+        pa_type = self._pa_array.type
+        if pa_version_under11p0 and pa.types.is_duration(pa_type):
+            data = self._pa_array.cast(pa.int64())
+        else:
+            data = self._pa_array
+        pa_result = pc.unique(data)
+        if pa_version_under11p0 and pa.types.is_duration(pa_type):
+            pa_result = pa_result.cast(pa_type)
+        return type(self)(pa_result)
+
+    def value_counts(self, dropna: bool=True) -> Series:
+        pa_type = self._pa_array.type
+        if pa_version_under11p0 and pa.types.is_duration(pa_type):
+            data = self._pa_array.cast(pa.int64())
+        else:
+            data = self._pa_array
+        from pandas import Index, Series
+        vc = data.value_counts()
+        values = vc.field(0)
+        counts = vc.field(1)
+        if dropna and data.null_count > 0:
+            mask = values.is_valid()
+            values = values.filter(mask)
+            counts = counts.filter(mask)
+        if pa_version_under11p0 and pa.types.is_duration(pa_type):
+            values = values.cast(pa_type)
+        counts = ArrowExtensionArray(counts)
+        index = Index(type(self)(values))
+        return Series(counts, index=index, name='count', copy=False)
+
+    @classmethod
+    def _concat_same_type(cls, to_concat) -> Self:
+        chunks = [array for ea in to_concat for array in ea._pa_array.iterchunks()]
+        if to_concat[0].dtype == 'string':
+            pa_dtype = pa.large_string()
+        else:
+            pa_dtype = to_concat[0].dtype.pyarrow_dtype
+        arr = pa.chunked_array(chunks, type=pa_dtype)
+        return cls(arr)
+
+    def _accumulate(self, name: str, *, skipna: bool=True, **kwargs) -> ArrowExtensionArray | ExtensionArray:
+        pyarrow_name = {'cummax': 'cumulative_max', 'cummin': 'cumulative_min', 'cumprod': 'cumulative_prod_checked', 'cumsum': 'cumulative_sum_checked'}.get(name, name)
+        pyarrow_meth = getattr(pc, pyarrow_name, None)
+        if pyarrow_meth is None:
+            return super()._accumulate(name, skipna=skipna, **kwargs)
+        data_to_accum = self._pa_array
+        pa_dtype = data_to_accum.type
+        convert_to_int = pa.types.is_temporal(pa_dtype) and name in ['cummax', 'cummin'] or (pa.types.is_duration(pa_dtype) and name == 'cumsum')
+        if convert_to_int:
+            if pa_dtype.bit_width == 32:
+                data_to_accum = data_to_accum.cast(pa.int32())
+            else:
+                data_to_accum = data_to_accum.cast(pa.int64())
+        result = pyarrow_meth(data_to_accum, skip_nulls=skipna, **kwargs)
+        if convert_to_int:
+            result = result.cast(pa_dtype)
+        return type(self)(result)
+
+    def _reduce_pyarrow(self, name: str, *, skipna: bool=True, **kwargs) -> pa.Scalar:
+        pa_type = self._pa_array.type
+        data_to_reduce = self._pa_array
+        cast_kwargs = {} if pa_version_under13p0 else {'safe': False}
+        if name in ['any', 'all'] and (pa.types.is_integer(pa_type) or pa.types.is_floating(pa_type) or pa.types.is_duration(pa_type) or pa.types.is_decimal(pa_type)):
+            if pa.types.is_duration(pa_type):
+                data_to_cmp = self._pa_array.cast(pa.int64())
+            else:
+                data_to_cmp = self._pa_array
+            not_eq = pc.not_equal(data_to_cmp, 0)
+            data_to_reduce = not_eq
+        elif name in ['min', 'max', 'sum'] and pa.types.is_duration(pa_type):
+            data_to_reduce = self._pa_array.cast(pa.int64())
+        elif name in ['median', 'mean', 'std', 'sem'] and pa.types.is_temporal(pa_type):
+            nbits = pa_type.bit_width
+            if nbits == 32:
+                data_to_reduce = self._pa_array.cast(pa.int32())
+            else:
+                data_to_reduce = self._pa_array.cast(pa.int64())
+        if name == 'sem':
+
+            def pyarrow_meth(data, skip_nulls, **kwargs):
+                numerator = pc.stddev(data, skip_nulls=skip_nulls, **kwargs)
+                denominator = pc.sqrt_checked(pc.count(self._pa_array))
+                return pc.divide_checked(numerator, denominator)
+        else:
+            pyarrow_name = {'median': 'quantile', 'prod': 'product', 'std': 'stddev', 'var': 'variance'}.get(name, name)
+            pyarrow_meth = getattr(pc, pyarrow_name, None)
+            if pyarrow_meth is None:
+                return super()._reduce(name, skipna=skipna, **kwargs)
+        if name in ['any', 'all'] and 'min_count' not in kwargs:
+            kwargs['min_count'] = 0
+        elif name == 'median':
+            kwargs['q'] = 0.5
+        try:
+            result = pyarrow_meth(data_to_reduce, skip_nulls=skipna, **kwargs)
+        except (AttributeError, NotImplementedError, TypeError) as err:
+            msg = f"'{type(self).__name__}' with dtype {self.dtype} does not support operation '{name}' with pyarrow version {pa.__version__}. '{name}' may be supported by upgrading pyarrow."
+            raise TypeError(msg) from err
+        if name == 'median':
+            result = result[0]
+        if name in ['min', 'max', 'sum'] and pa.types.is_duration(pa_type):
+            result = result.cast(pa_type)
+        if name in ['median', 'mean'] and pa.types.is_temporal(pa_type):
+            if not pa_version_under13p0:
+                nbits = pa_type.bit_width
+                if nbits == 32:
+                    result = result.cast(pa.int32(), **cast_kwargs)
+                else:
+                    result = result.cast(pa.int64(), **cast_kwargs)
+            result = result.cast(pa_type)
+        if name in ['std', 'sem'] and pa.types.is_temporal(pa_type):
+            result = result.cast(pa.int64(), **cast_kwargs)
+            if pa.types.is_duration(pa_type):
+                result = result.cast(pa_type)
+            elif pa.types.is_time(pa_type):
+                unit = get_unit_from_pa_dtype(pa_type)
+                result = result.cast(pa.duration(unit))
+            elif pa.types.is_date(pa_type):
+                result = result.cast(pa.duration('s'))
+            else:
+                result = result.cast(pa.duration(pa_type.unit))
+        return result
+
+    def _reduce(self, name: str, *, skipna: bool=True, keepdims: bool=False, **kwargs):
+        result = self._reduce_calc(name, skipna=skipna, keepdims=keepdims, **kwargs)
+        if isinstance(result, pa.Array):
+            return type(self)(result)
+        else:
+            return result
+
+    def _reduce_calc(self, name: str, *, skipna: bool=True, keepdims: bool=False, **kwargs):
+        pa_result = self._reduce_pyarrow(name, skipna=skipna, **kwargs)
+        if keepdims:
+            if isinstance(pa_result, pa.Scalar):
+                result = pa.array([pa_result.as_py()], type=pa_result.type)
+            else:
+                result = pa.array([pa_result], type=to_pyarrow_type(infer_dtype_from_scalar(pa_result)[0]))
+            return result
+        if pc.is_null(pa_result).as_py():
+            return self.dtype.na_value
+        elif isinstance(pa_result, pa.Scalar):
+            return pa_result.as_py()
+        else:
+            return pa_result
+
+    def _explode(self):
+        if not pa.types.is_list(self.dtype.pyarrow_dtype):
+            return super()._explode()
+        values = self
+        counts = pa.compute.list_value_length(values._pa_array)
+        counts = counts.fill_null(1).to_numpy()
+        fill_value = pa.scalar([None], type=self._pa_array.type)
+        mask = counts == 0
+        if mask.any():
+            values = values.copy()
+            values[mask] = fill_value
+            counts = counts.copy()
+            counts[mask] = 1
+        values = values.fillna(fill_value)
+        values = type(self)(pa.compute.list_flatten(values._pa_array))
+        return (values, counts)
+
+    def __setitem__(self, key, value) -> None:
+        if isinstance(key, tuple) and len(key) == 1:
+            key = key[0]
+        key = check_array_indexer(self, key)
+        value = self._maybe_convert_setitem_value(value)
+        if com.is_null_slice(key):
+            data = self._if_else(True, value, self._pa_array)
+        elif is_integer(key):
+            key = cast(int, key)
+            n = len(self)
+            if key < 0:
+                key += n
+            if not 0 <= key < n:
+                raise IndexError(f'index {key} is out of bounds for axis 0 with size {n}')
+            if isinstance(value, pa.Scalar):
+                value = value.as_py()
+            elif is_list_like(value):
+                raise ValueError('Length of indexer and values mismatch')
+            chunks = [*self._pa_array[:key].chunks, pa.array([value], type=self._pa_array.type, from_pandas=True), *self._pa_array[key + 1:].chunks]
+            data = pa.chunked_array(chunks).combine_chunks()
+        elif is_bool_dtype(key):
+            key = np.asarray(key, dtype=np.bool_)
+            data = self._replace_with_mask(self._pa_array, key, value)
+        elif is_scalar(value) or isinstance(value, pa.Scalar):
+            mask = np.zeros(len(self), dtype=np.bool_)
+            mask[key] = True
+            data = self._if_else(mask, value, self._pa_array)
+        else:
+            indices = np.arange(len(self))[key]
+            if len(indices) != len(value):
+                raise ValueError('Length of indexer and values mismatch')
+            if len(indices) == 0:
+                return
+            (_, argsort) = np.unique(indices, return_index=True)
+            indices = indices[argsort]
+            value = value.take(argsort)
+            mask = np.zeros(len(self), dtype=np.bool_)
+            mask[indices] = True
+            data = self._replace_with_mask(self._pa_array, mask, value)
+        if isinstance(data, pa.Array):
+            data = pa.chunked_array([data])
+        self._pa_array = data
+
+    def _rank_calc(self, *, axis: AxisInt=0, method: str='average', na_option: str='keep', ascending: bool=True, pct: bool=False):
+        if axis != 0:
+            ranked = super()._rank(axis=axis, method=method, na_option=na_option, ascending=ascending, pct=pct)
+            if method == 'average' or pct:
+                pa_type = pa.float64()
+            else:
+                pa_type = pa.uint64()
+            result = pa.array(ranked, type=pa_type, from_pandas=True)
+            return result
+        data = self._pa_array.combine_chunks()
+        sort_keys = 'ascending' if ascending else 'descending'
+        null_placement = 'at_start' if na_option == 'top' else 'at_end'
+        tiebreaker = 'min' if method == 'average' else method
+        result = pc.rank(data, sort_keys=sort_keys, null_placement=null_placement, tiebreaker=tiebreaker)
+        if na_option == 'keep':
+            mask = pc.is_null(self._pa_array)
+            null = pa.scalar(None, type=result.type)
+            result = pc.if_else(mask, null, result)
+        if method == 'average':
+            result_max = pc.rank(data, sort_keys=sort_keys, null_placement=null_placement, tiebreaker='max')
+            result_max = result_max.cast(pa.float64())
+            result_min = result.cast(pa.float64())
+            result = pc.divide(pc.add(result_min, result_max), 2)
+        if pct:
+            if not pa.types.is_floating(result.type):
+                result = result.cast(pa.float64())
+            if method == 'dense':
+                divisor = pc.max(result)
+            else:
+                divisor = pc.count(result)
+            result = pc.divide(result, divisor)
+        return result
+
+    def _rank(self, *, axis: AxisInt=0, method: str='average', na_option: str='keep', ascending: bool=True, pct: bool=False) -> Self:
+        return self._convert_rank_result(self._rank_calc(axis=axis, method=method, na_option=na_option, ascending=ascending, pct=pct))
+
+    def _quantile(self, qs: npt.NDArray[np.float64], interpolation: str) -> Self:
+        pa_dtype = self._pa_array.type
+        data = self._pa_array
+        if pa.types.is_temporal(pa_dtype):
+            nbits = pa_dtype.bit_width
+            if nbits == 32:
+                data = data.cast(pa.int32())
+            else:
+                data = data.cast(pa.int64())
+        result = pc.quantile(data, q=qs, interpolation=interpolation)
+        if pa.types.is_temporal(pa_dtype):
+            if pa.types.is_floating(result.type):
+                result = pc.floor(result)
+            nbits = pa_dtype.bit_width
+            if nbits == 32:
+                result = result.cast(pa.int32())
+            else:
+                result = result.cast(pa.int64())
+            result = result.cast(pa_dtype)
+        return type(self)(result)
+
+    def _mode(self, dropna: bool=True) -> Self:
+        pa_type = self._pa_array.type
+        if pa.types.is_temporal(pa_type):
+            nbits = pa_type.bit_width
+            if nbits == 32:
+                data = self._pa_array.cast(pa.int32())
+            elif nbits == 64:
+                data = self._pa_array.cast(pa.int64())
+            else:
+                raise NotImplementedError(pa_type)
+        else:
+            data = self._pa_array
+        if dropna:
+            data = data.drop_null()
+        res = pc.value_counts(data)
+        most_common = res.field('values').filter(pc.equal(res.field('counts'), pc.max(res.field('counts'))))
+        if pa.types.is_temporal(pa_type):
+            most_common = most_common.cast(pa_type)
+        most_common = most_common.take(pc.array_sort_indices(most_common))
+        return type(self)(most_common)
+
+    def _maybe_convert_setitem_value(self, value):
+        try:
+            value = self._box_pa(value, self._pa_array.type)
+        except pa.ArrowTypeError as err:
+            msg = f"Invalid value '{value!s}' for dtype {self.dtype}"
+            raise TypeError(msg) from err
+        return value
+
+    def interpolate(self, *, method: InterpolateOptions, axis: int, index, limit, limit_direction, limit_area, copy: bool, **kwargs) -> Self:
+        if not self.dtype._is_numeric:
+            raise ValueError('Values must be numeric.')
+        if not pa_version_under13p0 and method == 'linear' and (limit_area is None) and (limit is None) and (limit_direction == 'forward'):
+            values = self._pa_array.combine_chunks()
+            na_value = pa.array([None], type=values.type)
+            y_diff_2 = pc.fill_null_backward(pc.pairwise_diff_checked(values, period=2))
+            prev_values = pa.concat_arrays([na_value, values[:-2], na_value])
+            interps = pc.add_checked(prev_values, pc.divide_checked(y_diff_2, 2))
+            return type(self)(pc.coalesce(self._pa_array, interps))
+        mask = self.isna()
+        if self.dtype.kind == 'f':
+            data = self._pa_array.to_numpy()
+        elif self.dtype.kind in 'iu':
+            data = self.to_numpy(dtype='f8', na_value=0.0)
+        else:
+            raise NotImplementedError(f'interpolate is not implemented for dtype={self.dtype}')
+        missing.interpolate_2d_inplace(data, method=method, axis=0, index=index, limit=limit, limit_direction=limit_direction, limit_area=limit_area, mask=mask, **kwargs)
+        return type(self)(self._box_pa_array(pa.array(data, mask=mask)))
+
+    @classmethod
+    def _if_else(cls, cond: npt.NDArray[np.bool_] | bool, left: ArrayLike | Scalar, right: ArrayLike | Scalar) -> pa.Array:
+        try:
+            return pc.if_else(cond, left, right)
+        except pa.ArrowNotImplementedError:
+            pass
+
+        def _to_numpy_and_type(value) -> tuple[np.ndarray, pa.DataType | None]:
+            if isinstance(value, (pa.Array, pa.ChunkedArray)):
+                pa_type = value.type
+            elif isinstance(value, pa.Scalar):
+                pa_type = value.type
+                value = value.as_py()
+            else:
+                pa_type = None
+            return (np.array(value, dtype=object), pa_type)
+        (left, left_type) = _to_numpy_and_type(left)
+        (right, right_type) = _to_numpy_and_type(right)
+        pa_type = left_type or right_type
+        result = np.where(cond, left, right)
+        return pa.array(result, type=pa_type, from_pandas=True)
+
+    @classmethod
+    def _replace_with_mask(cls, values: pa.Array | pa.ChunkedArray, mask: npt.NDArray[np.bool_] | bool, replacements: ArrayLike | Scalar) -> pa.Array | pa.ChunkedArray:
+        if isinstance(replacements, pa.ChunkedArray):
+            replacements = replacements.combine_chunks()
+        if isinstance(values, pa.ChunkedArray) and pa.types.is_boolean(values.type):
+            values = values.combine_chunks()
+        try:
+            return pc.replace_with_mask(values, mask, replacements)
+        except pa.ArrowNotImplementedError:
+            pass
+        if isinstance(replacements, pa.Array):
+            replacements = np.array(replacements, dtype=object)
+        elif isinstance(replacements, pa.Scalar):
+            replacements = replacements.as_py()
+        result = np.array(values, dtype=object)
+        result[mask] = replacements
+        return pa.array(result, type=values.type, from_pandas=True)
+
+    def _to_masked(self):
+        pa_dtype = self._pa_array.type
+        if pa.types.is_floating(pa_dtype) or pa.types.is_integer(pa_dtype):
+            na_value = 1
+        elif pa.types.is_boolean(pa_dtype):
+            na_value = True
+        else:
+            raise NotImplementedError
+        dtype = _arrow_dtype_mapping()[pa_dtype]
+        mask = self.isna()
+        arr = self.to_numpy(dtype=dtype.numpy_dtype, na_value=na_value)
+        return dtype.construct_array_type()(arr, mask)
+
+    def _groupby_op(self, *, how: str, has_dropped_na: bool, min_count: int, ngroups: int, ids: npt.NDArray[np.intp], **kwargs):
+        if isinstance(self.dtype, StringDtype):
+            return super()._groupby_op(how=how, has_dropped_na=has_dropped_na, min_count=min_count, ngroups=ngroups, ids=ids, **kwargs)
+        values: ExtensionArray
+        pa_type = self._pa_array.type
+        if pa.types.is_timestamp(pa_type):
+            values = self._to_datetimearray()
+        elif pa.types.is_duration(pa_type):
+            values = self._to_timedeltaarray()
+        else:
+            values = self._to_masked()
+        result = values._groupby_op(how=how, has_dropped_na=has_dropped_na, min_count=min_count, ngroups=ngroups, ids=ids, **kwargs)
+        if isinstance(result, np.ndarray):
+            return result
+        return type(self)._from_sequence(result, copy=False)
+
+    def _apply_elementwise(self, func: Callable) -> list[list[Any]]:
+        return [[None if val is None else func(val) for val in chunk.to_numpy(zero_copy_only=False)] for chunk in self._pa_array.iterchunks()]
+
+    def _convert_bool_result(self, result):
+        return type(self)(result)
+
+    def _convert_int_result(self, result):
+        return type(self)(result)
+
+    def _convert_rank_result(self, result):
+        return type(self)(result)
+
+    def _str_count(self, pat: str, flags: int=0) -> Self:
+        if flags:
+            raise NotImplementedError(f'count not implemented with flags={flags!r}')
+        return type(self)(pc.count_substring_regex(self._pa_array, pat))
+
+    def _str_repeat(self, repeats: int | Sequence[int]) -> Self:
+        if not isinstance(repeats, int):
+            raise NotImplementedError(f'repeat is not implemented when repeats is {type(repeats).__name__}')
+        return type(self)(pc.binary_repeat(self._pa_array, repeats))
+
+    def _str_join(self, sep: str) -> Self:
+        if pa.types.is_string(self._pa_array.type) or pa.types.is_large_string(self._pa_array.type):
+            result = self._apply_elementwise(list)
+            result = pa.chunked_array(result, type=pa.list_(pa.string()))
+        else:
+            result = self._pa_array
+        return type(self)(pc.binary_join(result, sep))
+
+    def _str_partition(self, sep: str, expand: bool) -> Self:
+        predicate = lambda val: val.partition(sep)
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    def _str_rpartition(self, sep: str, expand: bool) -> Self:
+        predicate = lambda val: val.rpartition(sep)
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    def _str_casefold(self) -> Self:
+        predicate = lambda val: val.casefold()
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    def _str_encode(self, encoding: str, errors: str='strict') -> Self:
+        predicate = lambda val: val.encode(encoding, errors)
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    def _str_extract(self, pat: str, flags: int=0, expand: bool=True):
+        if flags:
+            raise NotImplementedError('Only flags=0 is implemented.')
+        groups = re.compile(pat).groupindex.keys()
+        if len(groups) == 0:
+            raise ValueError(f'pat={pat!r} must contain a symbolic group name.')
+        result = pc.extract_regex(self._pa_array, pat)
+        if expand:
+            return {col: type(self)(pc.struct_field(result, [i])) for (col, i) in zip(groups, range(result.type.num_fields))}
+        else:
+            return type(self)(pc.struct_field(result, [0]))
+
+    def _str_findall(self, pat: str, flags: int=0) -> Self:
+        regex = re.compile(pat, flags=flags)
+        predicate = lambda val: regex.findall(val)
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    def _str_get_dummies(self, sep: str='|', dtype: NpDtype | None=None):
+        if dtype is None:
+            dtype = np.bool_
+        split = pc.split_pattern(self._pa_array, sep)
+        flattened_values = pc.list_flatten(split)
+        uniques = flattened_values.unique()
+        uniques_sorted = uniques.take(pa.compute.array_sort_indices(uniques))
+        lengths = pc.list_value_length(split).fill_null(0).to_numpy()
+        n_rows = len(self)
+        n_cols = len(uniques)
+        indices = pc.index_in(flattened_values, uniques_sorted).to_numpy()
+        indices = indices + np.arange(n_rows).repeat(lengths) * n_cols
+        _dtype = pandas_dtype(dtype)
+        dummies_dtype: NpDtype
+        if isinstance(_dtype, np.dtype):
+            dummies_dtype = _dtype
+        else:
+            dummies_dtype = np.bool_
+        dummies = np.zeros(n_rows * n_cols, dtype=dummies_dtype)
+        if dtype == str:
+            dummies[:] = False
+        dummies[indices] = True
+        dummies = dummies.reshape((n_rows, n_cols))
+        result = type(self)(pa.array(list(dummies)))
+        return (result, uniques_sorted.to_pylist())
+
+    def _str_index(self, sub: str, start: int=0, end: int | None=None) -> Self:
+        predicate = lambda val: val.index(sub, start, end)
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    def _str_rindex(self, sub: str, start: int=0, end: int | None=None) -> Self:
+        predicate = lambda val: val.rindex(sub, start, end)
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    def _str_normalize(self, form: str) -> Self:
+        predicate = lambda val: unicodedata.normalize(form, val)
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    def _str_rfind(self, sub: str, start: int=0, end=None) -> Self:
+        predicate = lambda val: val.rfind(sub, start, end)
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    def _str_split(self, pat: str | None=None, n: int | None=-1, expand: bool=False, regex: bool | None=None) -> Self:
+        if n in {-1, 0}:
+            n = None
+        if pat is None:
+            split_func = pc.utf8_split_whitespace
+        elif regex:
+            split_func = functools.partial(pc.split_pattern_regex, pattern=pat)
+        else:
+            split_func = functools.partial(pc.split_pattern, pattern=pat)
+        return type(self)(split_func(self._pa_array, max_splits=n))
+
+    def _str_rsplit(self, pat: str | None=None, n: int | None=-1) -> Self:
+        if n in {-1, 0}:
+            n = None
+        if pat is None:
+            return type(self)(pc.utf8_split_whitespace(self._pa_array, max_splits=n, reverse=True))
+        return type(self)(pc.split_pattern(self._pa_array, pat, max_splits=n, reverse=True))
+
+    def _str_translate(self, table: dict[int, str]) -> Self:
+        predicate = lambda val: val.translate(table)
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    def _str_wrap(self, width: int, **kwargs) -> Self:
+        kwargs['width'] = width
+        tw = textwrap.TextWrapper(**kwargs)
+        predicate = lambda val: '\n'.join(tw.wrap(val))
+        result = self._apply_elementwise(predicate)
+        return type(self)(pa.chunked_array(result))
+
+    @property
+    def _dt_days(self) -> Self:
+        return type(self)(pa.array(self._to_timedeltaarray().components.days, from_pandas=True, type=pa.int32()))
+
+    @property
+    def _dt_hours(self) -> Self:
+        return type(self)(pa.array(self._to_timedeltaarray().components.hours, from_pandas=True, type=pa.int32()))
+
+    @property
+    def _dt_minutes(self) -> Self:
+        return type(self)(pa.array(self._to_timedeltaarray().components.minutes, from_pandas=True, type=pa.int32()))
+
+    @property
+    def _dt_seconds(self) -> Self:
+        return type(self)(pa.array(self._to_timedeltaarray().components.seconds, from_pandas=True, type=pa.int32()))
+
+    @property
+    def _dt_milliseconds(self) -> Self:
+        return type(self)(pa.array(self._to_timedeltaarray().components.milliseconds, from_pandas=True, type=pa.int32()))
+
+    @property
+    def _dt_microseconds(self) -> Self:
+        return type(self)(pa.array(self._to_timedeltaarray().components.microseconds, from_pandas=True, type=pa.int32()))
+
+    @property
+    def _dt_nanoseconds(self) -> Self:
+        return type(self)(pa.array(self._to_timedeltaarray().components.nanoseconds, from_pandas=True, type=pa.int32()))
+
+    def _dt_to_pytimedelta(self) -> np.ndarray:
+        data = self._pa_array.to_pylist()
+        if self._dtype.pyarrow_dtype.unit == 'ns':
+            data = [None if ts is None else ts.to_pytimedelta() for ts in data]
+        return np.array(data, dtype=object)
+
+    def _dt_total_seconds(self) -> Self:
+        return type(self)(pa.array(self._to_timedeltaarray().total_seconds(), from_pandas=True))
+
+    def _dt_as_unit(self, unit: str) -> Self:
+        if pa.types.is_date(self.dtype.pyarrow_dtype):
+            raise NotImplementedError('as_unit not implemented for date types')
+        pd_array = self._maybe_convert_datelike_array()
+        return type(self)(pa.array(pd_array.as_unit(unit), from_pandas=True))
+
+    @property
+    def _dt_year(self) -> Self:
+        return type(self)(pc.year(self._pa_array))
+
+    @property
+    def _dt_day(self) -> Self:
+        return type(self)(pc.day(self._pa_array))
+
+    @property
+    def _dt_day_of_week(self) -> Self:
+        return type(self)(pc.day_of_week(self._pa_array))
+    _dt_dayofweek = _dt_day_of_week
+    _dt_weekday = _dt_day_of_week
+
+    @property
+    def _dt_day_of_year(self) -> Self:
+        return type(self)(pc.day_of_year(self._pa_array))
+    _dt_dayofyear = _dt_day_of_year
+
+    @property
+    def _dt_hour(self) -> Self:
+        return type(self)(pc.hour(self._pa_array))
+
+    def _dt_isocalendar(self) -> Self:
+        return type(self)(pc.iso_calendar(self._pa_array))
+
+    @property
+    def _dt_is_leap_year(self) -> Self:
+        return type(self)(pc.is_leap_year(self._pa_array))
+
+    @property
+    def _dt_is_month_start(self) -> Self:
+        return type(self)(pc.equal(pc.day(self._pa_array), 1))
+
+    @property
+    def _dt_is_month_end(self) -> Self:
+        result = pc.equal(pc.days_between(pc.floor_temporal(self._pa_array, unit='day'), pc.ceil_temporal(self._pa_array, unit='month')), 1)
+        return type(self)(result)
+
+    @property
+    def _dt_is_year_start(self) -> Self:
+        return type(self)(pc.and_(pc.equal(pc.month(self._pa_array), 1), pc.equal(pc.day(self._pa_array), 1)))
+
+    @property
+    def _dt_is_year_end(self) -> Self:
+        return type(self)(pc.and_(pc.equal(pc.month(self._pa_array), 12), pc.equal(pc.day(self._pa_array), 31)))
+
+    @property
+    def _dt_is_quarter_start(self) -> Self:
+        result = pc.equal(pc.floor_temporal(self._pa_array, unit='quarter'), pc.floor_temporal(self._pa_array, unit='day'))
+        return type(self)(result)
+
+    @property
+    def _dt_is_quarter_end(self) -> Self:
+        result = pc.equal(pc.days_between(pc.floor_temporal(self._pa_array, unit='day'), pc.ceil_temporal(self._pa_array, unit='quarter')), 1)
+        return type(self)(result)
+
+    @property
+    def _dt_days_in_month(self) -> Self:
+        result = pc.days_between(pc.floor_temporal(self._pa_array, unit='month'), pc.ceil_temporal(self._pa_array, unit='month'))
+        return type(self)(result)
+    _dt_daysinmonth = _dt_days_in_month
+
+    @property
+    def _dt_microsecond(self) -> Self:
+        us = pc.microsecond(self._pa_array)
+        ms_to_us = pc.multiply(pc.millisecond(self._pa_array), 1000)
+        return type(self)(pc.add(us, ms_to_us))
+
+    @property
+    def _dt_minute(self) -> Self:
+        return type(self)(pc.minute(self._pa_array))
+
+    @property
+    def _dt_month(self) -> Self:
+        return type(self)(pc.month(self._pa_array))
+
+    @property
+    def _dt_nanosecond(self) -> Self:
+        return type(self)(pc.nanosecond(self._pa_array))
+
+    @property
+    def _dt_quarter(self) -> Self:
+        return type(self)(pc.quarter(self._pa_array))
+
+    @property
+    def _dt_second(self) -> Self:
+        return type(self)(pc.second(self._pa_array))
+
+    @property
+    def _dt_date(self) -> Self:
+        return type(self)(self._pa_array.cast(pa.date32()))
+
+    @property
+    def _dt_time(self) -> Self:
+        unit = self.dtype.pyarrow_dtype.unit if self.dtype.pyarrow_dtype.unit in {'us', 'ns'} else 'ns'
+        return type(self)(self._pa_array.cast(pa.time64(unit)))
+
+    @property
+    def _dt_tz(self):
+        return timezones.maybe_get_tz(self.dtype.pyarrow_dtype.tz)
+
+    @property
+    def _dt_unit(self):
+        return self.dtype.pyarrow_dtype.unit
+
+    def _dt_normalize(self) -> Self:
+        return type(self)(pc.floor_temporal(self._pa_array, 1, 'day'))
+
+    def _dt_strftime(self, format: str) -> Self:
+        return type(self)(pc.strftime(self._pa_array, format=format))
+
+    def _round_temporally(self, method: Literal['ceil', 'floor', 'round'], freq, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise') -> Self:
+        if ambiguous != 'raise':
+            raise NotImplementedError('ambiguous is not supported.')
+        if nonexistent != 'raise':
+            raise NotImplementedError('nonexistent is not supported.')
+        offset = to_offset(freq)
+        if offset is None:
+            raise ValueError(f'Must specify a valid frequency: {freq}')
+        pa_supported_unit = {'Y': 'year', 'YS': 'year', 'Q': 'quarter', 'QS': 'quarter', 'M': 'month', 'MS': 'month', 'W': 'week', 'D': 'day', 'h': 'hour', 'min': 'minute', 's': 'second', 'ms': 'millisecond', 'us': 'microsecond', 'ns': 'nanosecond'}
+        unit = pa_supported_unit.get(offset._prefix, None)
+        if unit is None:
+            raise ValueError(f'freq={freq!r} is not supported')
+        multiple = offset.n
+        rounding_method = getattr(pc, f'{method}_temporal')
+        return type(self)(rounding_method(self._pa_array, multiple=multiple, unit=unit))
+
+    def _dt_ceil(self, freq, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise') -> Self:
+        return self._round_temporally('ceil', freq, ambiguous, nonexistent)
+
+    def _dt_floor(self, freq, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise') -> Self:
+        return self._round_temporally('floor', freq, ambiguous, nonexistent)
+
+    def _dt_round(self, freq, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise') -> Self:
+        return self._round_temporally('round', freq, ambiguous, nonexistent)
+
+    def _dt_day_name(self, locale: str | None=None) -> Self:
+        if locale is None:
+            locale = 'C'
+        return type(self)(pc.strftime(self._pa_array, format='%A', locale=locale))
+
+    def _dt_month_name(self, locale: str | None=None) -> Self:
+        if locale is None:
+            locale = 'C'
+        return type(self)(pc.strftime(self._pa_array, format='%B', locale=locale))
+
+    def _dt_to_pydatetime(self) -> Series:
+        from pandas import Series
+        if pa.types.is_date(self.dtype.pyarrow_dtype):
+            raise ValueError(f'to_pydatetime cannot be called with {self.dtype.pyarrow_dtype} type. Convert to pyarrow timestamp type.')
+        data = self._pa_array.to_pylist()
+        if self._dtype.pyarrow_dtype.unit == 'ns':
+            data = [None if ts is None else ts.to_pydatetime(warn=False) for ts in data]
+        return Series(data, dtype=object)
+
+    def _dt_tz_localize(self, tz, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise') -> Self:
+        if ambiguous != 'raise':
+            raise NotImplementedError(f'ambiguous={ambiguous!r} is not supported')
+        nonexistent_pa = {'raise': 'raise', 'shift_backward': 'earliest', 'shift_forward': 'latest'}.get(nonexistent, None)
+        if nonexistent_pa is None:
+            raise NotImplementedError(f'nonexistent={nonexistent!r} is not supported')
+        if tz is None:
+            result = self._pa_array.cast(pa.timestamp(self.dtype.pyarrow_dtype.unit))
+        else:
+            result = pc.assume_timezone(self._pa_array, str(tz), ambiguous=ambiguous, nonexistent=nonexistent_pa)
+        return type(self)(result)
+
+    def _dt_tz_convert(self, tz) -> Self:
+        if self.dtype.pyarrow_dtype.tz is None:
+            raise TypeError('Cannot convert tz-naive timestamps, use tz_localize to localize')
+        current_unit = self.dtype.pyarrow_dtype.unit
+        result = self._pa_array.cast(pa.timestamp(current_unit, tz))
+        return type(self)(result)
+
+def transpose_homogeneous_pyarrow(arrays: Sequence[ArrowExtensionArray]) -> list[ArrowExtensionArray]:
+    arrays = list(arrays)
+    (nrows, ncols) = (len(arrays[0]), len(arrays))
+    indices = np.arange(nrows * ncols).reshape(ncols, nrows).T.reshape(-1)
+    arr = pa.chunked_array([chunk for arr in arrays for chunk in arr._pa_array.chunks])
+    arr = arr.take(indices)
+    return [ArrowExtensionArray(arr.slice(i * ncols, ncols)) for i in range(nrows)]
+
+# File: pandas-main/pandas/core/arrays/arrow/extension_types.py
+from __future__ import annotations
+import json
+from typing import TYPE_CHECKING
+import pyarrow
+from pandas.compat import pa_version_under14p1
+from pandas.core.dtypes.dtypes import IntervalDtype, PeriodDtype
+from pandas.core.arrays.interval import VALID_CLOSED
+if TYPE_CHECKING:
+    from pandas._typing import IntervalClosedType
+
+class ArrowPeriodType(pyarrow.ExtensionType):
+
+    def __init__(self, freq) -> None:
+        self._freq = freq
+        pyarrow.ExtensionType.__init__(self, pyarrow.int64(), 'pandas.period')
+
+    @property
+    def freq(self):
+        return self._freq
+
+    def __arrow_ext_serialize__(self) -> bytes:
+        metadata = {'freq': self.freq}
+        return json.dumps(metadata).encode()
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized) -> ArrowPeriodType:
+        metadata = json.loads(serialized.decode())
+        return ArrowPeriodType(metadata['freq'])
+
+    def __eq__(self, other):
+        if isinstance(other, pyarrow.BaseExtensionType):
+            return type(self) == type(other) and self.freq == other.freq
+        else:
+            return NotImplemented
+
+    def __ne__(self, other) -> bool:
+        return not self == other
+
+    def __hash__(self) -> int:
+        return hash((str(self), self.freq))
+
+    def to_pandas_dtype(self) -> PeriodDtype:
+        return PeriodDtype(freq=self.freq)
+_period_type = ArrowPeriodType('D')
+pyarrow.register_extension_type(_period_type)
+
+class ArrowIntervalType(pyarrow.ExtensionType):
+
+    def __init__(self, subtype, closed: IntervalClosedType) -> None:
+        assert closed in VALID_CLOSED
+        self._closed: IntervalClosedType = closed
+        if not isinstance(subtype, pyarrow.DataType):
+            subtype = pyarrow.type_for_alias(str(subtype))
+        self._subtype = subtype
+        storage_type = pyarrow.struct([('left', subtype), ('right', subtype)])
+        pyarrow.ExtensionType.__init__(self, storage_type, 'pandas.interval')
+
+    @property
+    def subtype(self):
+        return self._subtype
+
+    @property
+    def closed(self) -> IntervalClosedType:
+        return self._closed
+
+    def __arrow_ext_serialize__(self) -> bytes:
+        metadata = {'subtype': str(self.subtype), 'closed': self.closed}
+        return json.dumps(metadata).encode()
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized) -> ArrowIntervalType:
+        metadata = json.loads(serialized.decode())
+        subtype = pyarrow.type_for_alias(metadata['subtype'])
+        closed = metadata['closed']
+        return ArrowIntervalType(subtype, closed)
+
+    def __eq__(self, other):
+        if isinstance(other, pyarrow.BaseExtensionType):
+            return type(self) == type(other) and self.subtype == other.subtype and (self.closed == other.closed)
+        else:
+            return NotImplemented
+
+    def __ne__(self, other) -> bool:
+        return not self == other
+
+    def __hash__(self) -> int:
+        return hash((str(self), str(self.subtype), self.closed))
+
+    def to_pandas_dtype(self) -> IntervalDtype:
+        return IntervalDtype(self.subtype.to_pandas_dtype(), self.closed)
+_interval_type = ArrowIntervalType(pyarrow.int64(), 'left')
+pyarrow.register_extension_type(_interval_type)
+_ERROR_MSG = "Disallowed deserialization of 'arrow.py_extension_type':\nstorage_type = {storage_type}\nserialized = {serialized}\npickle disassembly:\n{pickle_disassembly}\n\nReading of untrusted Parquet or Feather files with a PyExtensionType column\nallows arbitrary code execution.\nIf you trust this file, you can enable reading the extension type by one of:\n\n- upgrading to pyarrow >= 14.0.1, and call `pa.PyExtensionType.set_auto_load(True)`\n- install pyarrow-hotfix (`pip install pyarrow-hotfix`) and disable it by running\n  `import pyarrow_hotfix; pyarrow_hotfix.uninstall()`\n\nWe strongly recommend updating your Parquet/Feather files to use extension types\nderived from `pyarrow.ExtensionType` instead, and register this type explicitly.\n"
+
+def patch_pyarrow() -> None:
+    if not pa_version_under14p1:
+        return
+    if getattr(pyarrow, '_hotfix_installed', False):
+        return
+
+    class ForbiddenExtensionType(pyarrow.ExtensionType):
+
+        def __arrow_ext_serialize__(self) -> bytes:
+            return b''
+
+        @classmethod
+        def __arrow_ext_deserialize__(cls, storage_type, serialized):
+            import io
+            import pickletools
+            out = io.StringIO()
+            pickletools.dis(serialized, out)
+            raise RuntimeError(_ERROR_MSG.format(storage_type=storage_type, serialized=serialized, pickle_disassembly=out.getvalue()))
+    pyarrow.unregister_extension_type('arrow.py_extension_type')
+    pyarrow.register_extension_type(ForbiddenExtensionType(pyarrow.null(), 'arrow.py_extension_type'))
+    pyarrow._hotfix_installed = True
+patch_pyarrow()
+
+# File: pandas-main/pandas/core/arrays/base.py
+""""""
+from __future__ import annotations
+import operator
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast, overload
+import warnings
+import numpy as np
+from pandas._libs import algos as libalgos, lib
+from pandas.compat import set_function_name
+from pandas.compat.numpy import function as nv
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import Appender, Substitution, cache_readonly
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import validate_bool_kwarg, validate_insert_loc
+from pandas.core.dtypes.cast import maybe_cast_pointwise_result
+from pandas.core.dtypes.common import is_list_like, is_scalar, pandas_dtype
+from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCIndex, ABCSeries
+from pandas.core.dtypes.missing import isna
+from pandas.core import arraylike, missing, roperator
+from pandas.core.algorithms import duplicated, factorize_array, isin, map_array, mode, rank, unique
+from pandas.core.array_algos.quantile import quantile_with_mask
+from pandas.core.missing import _fill_limit_area_1d
+from pandas.core.sorting import nargminmax, nargsort
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator, Sequence
+    from pandas._libs.missing import NAType
+    from pandas._typing import ArrayLike, AstypeArg, AxisInt, Dtype, DtypeObj, FillnaOptions, InterpolateOptions, NumpySorter, NumpyValueArrayLike, PositionalIndexer, ScalarIndexer, Self, SequenceIndexer, Shape, SortKind, TakeIndexer, npt
+    from pandas import Index
+_extension_array_shared_docs: dict[str, str] = {}
+
+class ExtensionArray:
+    _typ = 'extension'
+    __pandas_priority__ = 1000
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype: Dtype | None=None, copy: bool=False) -> Self:
+        raise AbstractMethodError(cls)
+
+    @classmethod
+    def _from_scalars(cls, scalars, *, dtype: DtypeObj) -> Self:
+        try:
+            return cls._from_sequence(scalars, dtype=dtype, copy=False)
+        except (ValueError, TypeError):
+            raise
+        except Exception:
+            warnings.warn('_from_scalars should only raise ValueError or TypeError. Consider overriding _from_scalars where appropriate.', stacklevel=find_stack_level())
+            raise
+
+    @classmethod
+    def _from_sequence_of_strings(cls, strings, *, dtype: ExtensionDtype, copy: bool=False) -> Self:
+        raise AbstractMethodError(cls)
+
+    @classmethod
+    def _from_factorized(cls, values, original):
+        raise AbstractMethodError(cls)
+
+    @overload
+    def __getitem__(self, item: ScalarIndexer) -> Any:
+        ...
+
+    @overload
+    def __getitem__(self, item: SequenceIndexer) -> Self:
+        ...
+
+    def __getitem__(self, item: PositionalIndexer) -> Self | Any:
+        raise AbstractMethodError(self)
+
+    def __setitem__(self, key, value) -> None:
+        raise NotImplementedError(f'{type(self)} does not implement __setitem__.')
+
+    def __len__(self) -> int:
+        raise AbstractMethodError(self)
+
+    def __iter__(self) -> Iterator[Any]:
+        for i in range(len(self)):
+            yield self[i]
+
+    def __contains__(self, item: object) -> bool | np.bool_:
+        if is_scalar(item) and isna(item):
+            if not self._can_hold_na:
+                return False
+            elif item is self.dtype.na_value or isinstance(item, self.dtype.type):
+                return self._hasna
+            else:
+                return False
+        else:
+            return (item == self).any()
+
+    def __eq__(self, other: object) -> ArrayLike:
+        raise AbstractMethodError(self)
+
+    def __ne__(self, other: object) -> ArrayLike:
+        return ~(self == other)
+
+    def to_numpy(self, dtype: npt.DTypeLike | None=None, copy: bool=False, na_value: object=lib.no_default) -> np.ndarray:
+        result = np.asarray(self, dtype=dtype)
+        if copy or na_value is not lib.no_default:
+            result = result.copy()
+        if na_value is not lib.no_default:
+            result[self.isna()] = na_value
+        return result
+
+    @property
+    def dtype(self) -> ExtensionDtype:
+        raise AbstractMethodError(self)
+
+    @property
+    def shape(self) -> Shape:
+        return (len(self),)
+
+    @property
+    def size(self) -> int:
+        return np.prod(self.shape)
+
+    @property
+    def ndim(self) -> int:
+        return 1
+
+    @property
+    def nbytes(self) -> int:
+        raise AbstractMethodError(self)
+
+    @overload
+    def astype(self, dtype: npt.DTypeLike, copy: bool=...) -> np.ndarray:
+        ...
+
+    @overload
+    def astype(self, dtype: ExtensionDtype, copy: bool=...) -> ExtensionArray:
+        ...
+
+    @overload
+    def astype(self, dtype: AstypeArg, copy: bool=...) -> ArrayLike:
+        ...
+
+    def astype(self, dtype: AstypeArg, copy: bool=True) -> ArrayLike:
+        dtype = pandas_dtype(dtype)
+        if dtype == self.dtype:
+            if not copy:
+                return self
+            else:
+                return self.copy()
+        if isinstance(dtype, ExtensionDtype):
+            cls = dtype.construct_array_type()
+            return cls._from_sequence(self, dtype=dtype, copy=copy)
+        elif lib.is_np_dtype(dtype, 'M'):
+            from pandas.core.arrays import DatetimeArray
+            return DatetimeArray._from_sequence(self, dtype=dtype, copy=copy)
+        elif lib.is_np_dtype(dtype, 'm'):
+            from pandas.core.arrays import TimedeltaArray
+            return TimedeltaArray._from_sequence(self, dtype=dtype, copy=copy)
+        if not copy:
+            return np.asarray(self, dtype=dtype)
+        else:
+            return np.array(self, dtype=dtype, copy=copy)
+
+    def isna(self) -> np.ndarray | ExtensionArraySupportsAnyAll:
+        raise AbstractMethodError(self)
+
+    @property
+    def _hasna(self) -> bool:
+        return bool(self.isna().any())
+
+    def _values_for_argsort(self) -> np.ndarray:
+        return np.array(self)
+
+    def argsort(self, *, ascending: bool=True, kind: SortKind='quicksort', na_position: str='last', **kwargs) -> np.ndarray:
+        ascending = nv.validate_argsort_with_ascending(ascending, (), kwargs)
+        values = self._values_for_argsort()
+        return nargsort(values, kind=kind, ascending=ascending, na_position=na_position, mask=np.asarray(self.isna()))
+
+    def argmin(self, skipna: bool=True) -> int:
+        validate_bool_kwarg(skipna, 'skipna')
+        if not skipna and self._hasna:
+            raise ValueError('Encountered an NA value with skipna=False')
+        return nargminmax(self, 'argmin')
+
+    def argmax(self, skipna: bool=True) -> int:
+        validate_bool_kwarg(skipna, 'skipna')
+        if not skipna and self._hasna:
+            raise ValueError('Encountered an NA value with skipna=False')
+        return nargminmax(self, 'argmax')
+
+    def interpolate(self, *, method: InterpolateOptions, axis: int, index: Index, limit, limit_direction, limit_area, copy: bool, **kwargs) -> Self:
+        raise NotImplementedError(f'{type(self).__name__} does not implement interpolate')
+
+    def _pad_or_backfill(self, *, method: FillnaOptions, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None, copy: bool=True) -> Self:
+        mask = self.isna()
+        if mask.any():
+            meth = missing.clean_fill_method(method)
+            npmask = np.asarray(mask)
+            if limit_area is not None and (not npmask.all()):
+                _fill_limit_area_1d(npmask, limit_area)
+            if meth == 'pad':
+                indexer = libalgos.get_fill_indexer(npmask, limit=limit)
+                return self.take(indexer, allow_fill=True)
+            else:
+                indexer = libalgos.get_fill_indexer(npmask[::-1], limit=limit)[::-1]
+                return self[::-1].take(indexer, allow_fill=True)
+        else:
+            if not copy:
+                return self
+            new_values = self.copy()
+        return new_values
+
+    def fillna(self, value: object | ArrayLike, limit: int | None=None, copy: bool=True) -> Self:
+        mask = self.isna()
+        if limit is not None and limit < len(self):
+            modify = mask.cumsum() > limit
+            if modify.any():
+                mask = mask.copy()
+                mask[modify] = False
+        value = missing.check_value_size(value, mask, len(self))
+        if mask.any():
+            if not copy:
+                new_values = self[:]
+            else:
+                new_values = self.copy()
+            new_values[mask] = value
+        elif not copy:
+            new_values = self[:]
+        else:
+            new_values = self.copy()
+        return new_values
+
+    def dropna(self) -> Self:
+        return self[~self.isna()]
+
+    def duplicated(self, keep: Literal['first', 'last', False]='first') -> npt.NDArray[np.bool_]:
+        mask = self.isna().astype(np.bool_, copy=False)
+        return duplicated(values=self, keep=keep, mask=mask)
+
+    def shift(self, periods: int=1, fill_value: object=None) -> ExtensionArray:
+        if not len(self) or periods == 0:
+            return self.copy()
+        if isna(fill_value):
+            fill_value = self.dtype.na_value
+        empty = self._from_sequence([fill_value] * min(abs(periods), len(self)), dtype=self.dtype)
+        if periods > 0:
+            a = empty
+            b = self[:-periods]
+        else:
+            a = self[abs(periods):]
+            b = empty
+        return self._concat_same_type([a, b])
+
+    def unique(self) -> Self:
+        uniques = unique(self.astype(object))
+        return self._from_sequence(uniques, dtype=self.dtype)
+
+    def searchsorted(self, value: NumpyValueArrayLike | ExtensionArray, side: Literal['left', 'right']='left', sorter: NumpySorter | None=None) -> npt.NDArray[np.intp] | np.intp:
+        arr = self.astype(object)
+        if isinstance(value, ExtensionArray):
+            value = value.astype(object)
+        return arr.searchsorted(value, side=side, sorter=sorter)
+
+    def equals(self, other: object) -> bool:
+        if type(self) != type(other):
+            return False
+        other = cast(ExtensionArray, other)
+        if self.dtype != other.dtype:
+            return False
+        elif len(self) != len(other):
+            return False
+        else:
+            equal_values = self == other
+            if isinstance(equal_values, ExtensionArray):
+                equal_values = equal_values.fillna(False)
+            equal_na = self.isna() & other.isna()
+            return bool((equal_values | equal_na).all())
+
+    def isin(self, values: ArrayLike) -> npt.NDArray[np.bool_]:
+        return isin(np.asarray(self), values)
+
+    def _values_for_factorize(self) -> tuple[np.ndarray, Any]:
+        return (self.astype(object), np.nan)
+
+    def factorize(self, use_na_sentinel: bool=True) -> tuple[np.ndarray, ExtensionArray]:
+        (arr, na_value) = self._values_for_factorize()
+        (codes, uniques) = factorize_array(arr, use_na_sentinel=use_na_sentinel, na_value=na_value)
+        uniques_ea = self._from_factorized(uniques, self)
+        return (codes, uniques_ea)
+    _extension_array_shared_docs['repeat'] = "\n        Repeat elements of a %(klass)s.\n\n        Returns a new %(klass)s where each element of the current %(klass)s\n        is repeated consecutively a given number of times.\n\n        Parameters\n        ----------\n        repeats : int or array of ints\n            The number of repetitions for each element. This should be a\n            non-negative integer. Repeating 0 times will return an empty\n            %(klass)s.\n        axis : None\n            Must be ``None``. Has no effect but is accepted for compatibility\n            with numpy.\n\n        Returns\n        -------\n        %(klass)s\n            Newly created %(klass)s with repeated elements.\n\n        See Also\n        --------\n        Series.repeat : Equivalent function for Series.\n        Index.repeat : Equivalent function for Index.\n        numpy.repeat : Similar method for :class:`numpy.ndarray`.\n        ExtensionArray.take : Take arbitrary positions.\n\n        Examples\n        --------\n        >>> cat = pd.Categorical(['a', 'b', 'c'])\n        >>> cat\n        ['a', 'b', 'c']\n        Categories (3, object): ['a', 'b', 'c']\n        >>> cat.repeat(2)\n        ['a', 'a', 'b', 'b', 'c', 'c']\n        Categories (3, object): ['a', 'b', 'c']\n        >>> cat.repeat([1, 2, 3])\n        ['a', 'b', 'b', 'c', 'c', 'c']\n        Categories (3, object): ['a', 'b', 'c']\n        "
+
+    @Substitution(klass='ExtensionArray')
+    @Appender(_extension_array_shared_docs['repeat'])
+    def repeat(self, repeats: int | Sequence[int], axis: AxisInt | None=None) -> Self:
+        nv.validate_repeat((), {'axis': axis})
+        ind = np.arange(len(self)).repeat(repeats)
+        return self.take(ind)
+
+    def take(self, indices: TakeIndexer, *, allow_fill: bool=False, fill_value: Any=None) -> Self:
+        raise AbstractMethodError(self)
+
+    def copy(self) -> Self:
+        raise AbstractMethodError(self)
+
+    def view(self, dtype: Dtype | None=None) -> ArrayLike:
+        if dtype is not None:
+            raise NotImplementedError(dtype)
+        return self[:]
+
+    def __repr__(self) -> str:
+        if self.ndim > 1:
+            return self._repr_2d()
+        from pandas.io.formats.printing import format_object_summary
+        data = format_object_summary(self, self._formatter(), indent_for_name=False).rstrip(', \n')
+        class_name = f'<{type(self).__name__}>\n'
+        footer = self._get_repr_footer()
+        return f'{class_name}{data}\n{footer}'
+
+    def _get_repr_footer(self) -> str:
+        if self.ndim > 1:
+            return f'Shape: {self.shape}, dtype: {self.dtype}'
+        return f'Length: {len(self)}, dtype: {self.dtype}'
+
+    def _repr_2d(self) -> str:
+        from pandas.io.formats.printing import format_object_summary
+        lines = [format_object_summary(x, self._formatter(), indent_for_name=False).rstrip(', \n') for x in self]
+        data = ',\n'.join(lines)
+        class_name = f'<{type(self).__name__}>'
+        footer = self._get_repr_footer()
+        return f'{class_name}\n[\n{data}\n]\n{footer}'
+
+    def _formatter(self, boxed: bool=False) -> Callable[[Any], str | None]:
+        if boxed:
+            return str
+        return repr
+
+    def transpose(self, *axes: int) -> Self:
+        return self[:]
+
+    @property
+    def T(self) -> Self:
+        return self.transpose()
+
+    def ravel(self, order: Literal['C', 'F', 'A', 'K'] | None='C') -> Self:
+        return self
+
+    @classmethod
+    def _concat_same_type(cls, to_concat: Sequence[Self]) -> Self:
+        raise AbstractMethodError(cls)
+
+    @cache_readonly
+    def _can_hold_na(self) -> bool:
+        return self.dtype._can_hold_na
+
+    def _accumulate(self, name: str, *, skipna: bool=True, **kwargs) -> ExtensionArray:
+        raise NotImplementedError(f'cannot perform {name} with type {self.dtype}')
+
+    def _reduce(self, name: str, *, skipna: bool=True, keepdims: bool=False, **kwargs):
+        meth = getattr(self, name, None)
+        if meth is None:
+            raise TypeError(f"'{type(self).__name__}' with dtype {self.dtype} does not support operation '{name}'")
+        result = meth(skipna=skipna, **kwargs)
+        if keepdims:
+            if name in ['min', 'max']:
+                result = self._from_sequence([result], dtype=self.dtype)
+            else:
+                result = np.array([result])
+        return result
+    __hash__: ClassVar[None]
+
+    def _values_for_json(self) -> np.ndarray:
+        return np.asarray(self)
+
+    def _hash_pandas_object(self, *, encoding: str, hash_key: str, categorize: bool) -> npt.NDArray[np.uint64]:
+        from pandas.core.util.hashing import hash_array
+        (values, _) = self._values_for_factorize()
+        return hash_array(values, encoding=encoding, hash_key=hash_key, categorize=categorize)
+
+    def _explode(self) -> tuple[Self, npt.NDArray[np.uint64]]:
+        values = self.copy()
+        counts = np.ones(shape=(len(self),), dtype=np.uint64)
+        return (values, counts)
+
+    def tolist(self) -> list:
+        if self.ndim > 1:
+            return [x.tolist() for x in self]
+        return list(self)
+
+    def delete(self, loc: PositionalIndexer) -> Self:
+        indexer = np.delete(np.arange(len(self)), loc)
+        return self.take(indexer)
+
+    def insert(self, loc: int, item) -> Self:
+        loc = validate_insert_loc(loc, len(self))
+        item_arr = type(self)._from_sequence([item], dtype=self.dtype)
+        return type(self)._concat_same_type([self[:loc], item_arr, self[loc:]])
+
+    def _putmask(self, mask: npt.NDArray[np.bool_], value) -> None:
+        if is_list_like(value):
+            val = value[mask]
+        else:
+            val = value
+        self[mask] = val
+
+    def _where(self, mask: npt.NDArray[np.bool_], value) -> Self:
+        result = self.copy()
+        if is_list_like(value):
+            val = value[~mask]
+        else:
+            val = value
+        result[~mask] = val
+        return result
+
+    def _rank(self, *, axis: AxisInt=0, method: str='average', na_option: str='keep', ascending: bool=True, pct: bool=False):
+        if axis != 0:
+            raise NotImplementedError
+        return rank(self, axis=axis, method=method, na_option=na_option, ascending=ascending, pct=pct)
+
+    @classmethod
+    def _empty(cls, shape: Shape, dtype: ExtensionDtype):
+        obj = cls._from_sequence([], dtype=dtype)
+        taker = np.broadcast_to(np.intp(-1), shape)
+        result = obj.take(taker, allow_fill=True)
+        if not isinstance(result, cls) or dtype != result.dtype:
+            raise NotImplementedError(f"Default 'empty' implementation is invalid for dtype='{dtype}'")
+        return result
+
+    def _quantile(self, qs: npt.NDArray[np.float64], interpolation: str) -> Self:
+        mask = np.asarray(self.isna())
+        arr = np.asarray(self)
+        fill_value = np.nan
+        res_values = quantile_with_mask(arr, mask, fill_value, qs, interpolation)
+        return type(self)._from_sequence(res_values)
+
+    def _mode(self, dropna: bool=True) -> Self:
+        return mode(self, dropna=dropna)
+
+    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
+        if any((isinstance(other, (ABCSeries, ABCIndex, ABCDataFrame)) for other in inputs)):
+            return NotImplemented
+        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(self, ufunc, method, *inputs, **kwargs)
+        if result is not NotImplemented:
+            return result
+        if 'out' in kwargs:
+            return arraylike.dispatch_ufunc_with_out(self, ufunc, method, *inputs, **kwargs)
+        if method == 'reduce':
+            result = arraylike.dispatch_reduction_ufunc(self, ufunc, method, *inputs, **kwargs)
+            if result is not NotImplemented:
+                return result
+        return arraylike.default_array_ufunc(self, ufunc, method, *inputs, **kwargs)
+
+    def map(self, mapper, na_action: Literal['ignore'] | None=None):
+        return map_array(self, mapper, na_action=na_action)
+
+    def _groupby_op(self, *, how: str, has_dropped_na: bool, min_count: int, ngroups: int, ids: npt.NDArray[np.intp], **kwargs) -> ArrayLike:
+        from pandas.core.arrays.string_ import StringDtype
+        from pandas.core.groupby.ops import WrappedCythonOp
+        kind = WrappedCythonOp.get_kind_from_how(how)
+        op = WrappedCythonOp(how=how, kind=kind, has_dropped_na=has_dropped_na)
+        if isinstance(self.dtype, StringDtype):
+            if op.how not in ['any', 'all']:
+                op._get_cython_function(op.kind, op.how, np.dtype(object), False)
+            npvalues = self.to_numpy(object, na_value=np.nan)
+        else:
+            raise NotImplementedError(f'function is not implemented for this dtype: {self.dtype}')
+        res_values = op._cython_op_ndim_compat(npvalues, min_count=min_count, ngroups=ngroups, comp_ids=ids, mask=None, **kwargs)
+        if op.how in op.cast_blocklist:
+            return res_values
+        if isinstance(self.dtype, StringDtype):
+            dtype = self.dtype
+            string_array_cls = dtype.construct_array_type()
+            return string_array_cls._from_sequence(res_values, dtype=dtype)
+        else:
+            raise NotImplementedError
+
+class ExtensionArraySupportsAnyAll(ExtensionArray):
+
+    @overload
+    def any(self, *, skipna: Literal[True]=...) -> bool:
+        ...
+
+    @overload
+    def any(self, *, skipna: bool) -> bool | NAType:
+        ...
+
+    def any(self, *, skipna: bool=True) -> bool | NAType:
+        raise AbstractMethodError(self)
+
+    @overload
+    def all(self, *, skipna: Literal[True]=...) -> bool:
+        ...
+
+    @overload
+    def all(self, *, skipna: bool) -> bool | NAType:
+        ...
+
+    def all(self, *, skipna: bool=True) -> bool | NAType:
+        raise AbstractMethodError(self)
+
+class ExtensionOpsMixin:
+
+    @classmethod
+    def _create_arithmetic_method(cls, op):
+        raise AbstractMethodError(cls)
+
+    @classmethod
+    def _add_arithmetic_ops(cls) -> None:
+        setattr(cls, '__add__', cls._create_arithmetic_method(operator.add))
+        setattr(cls, '__radd__', cls._create_arithmetic_method(roperator.radd))
+        setattr(cls, '__sub__', cls._create_arithmetic_method(operator.sub))
+        setattr(cls, '__rsub__', cls._create_arithmetic_method(roperator.rsub))
+        setattr(cls, '__mul__', cls._create_arithmetic_method(operator.mul))
+        setattr(cls, '__rmul__', cls._create_arithmetic_method(roperator.rmul))
+        setattr(cls, '__pow__', cls._create_arithmetic_method(operator.pow))
+        setattr(cls, '__rpow__', cls._create_arithmetic_method(roperator.rpow))
+        setattr(cls, '__mod__', cls._create_arithmetic_method(operator.mod))
+        setattr(cls, '__rmod__', cls._create_arithmetic_method(roperator.rmod))
+        setattr(cls, '__floordiv__', cls._create_arithmetic_method(operator.floordiv))
+        setattr(cls, '__rfloordiv__', cls._create_arithmetic_method(roperator.rfloordiv))
+        setattr(cls, '__truediv__', cls._create_arithmetic_method(operator.truediv))
+        setattr(cls, '__rtruediv__', cls._create_arithmetic_method(roperator.rtruediv))
+        setattr(cls, '__divmod__', cls._create_arithmetic_method(divmod))
+        setattr(cls, '__rdivmod__', cls._create_arithmetic_method(roperator.rdivmod))
+
+    @classmethod
+    def _create_comparison_method(cls, op):
+        raise AbstractMethodError(cls)
+
+    @classmethod
+    def _add_comparison_ops(cls) -> None:
+        setattr(cls, '__eq__', cls._create_comparison_method(operator.eq))
+        setattr(cls, '__ne__', cls._create_comparison_method(operator.ne))
+        setattr(cls, '__lt__', cls._create_comparison_method(operator.lt))
+        setattr(cls, '__gt__', cls._create_comparison_method(operator.gt))
+        setattr(cls, '__le__', cls._create_comparison_method(operator.le))
+        setattr(cls, '__ge__', cls._create_comparison_method(operator.ge))
+
+    @classmethod
+    def _create_logical_method(cls, op):
+        raise AbstractMethodError(cls)
+
+    @classmethod
+    def _add_logical_ops(cls) -> None:
+        setattr(cls, '__and__', cls._create_logical_method(operator.and_))
+        setattr(cls, '__rand__', cls._create_logical_method(roperator.rand_))
+        setattr(cls, '__or__', cls._create_logical_method(operator.or_))
+        setattr(cls, '__ror__', cls._create_logical_method(roperator.ror_))
+        setattr(cls, '__xor__', cls._create_logical_method(operator.xor))
+        setattr(cls, '__rxor__', cls._create_logical_method(roperator.rxor))
+
+class ExtensionScalarOpsMixin(ExtensionOpsMixin):
+
+    @classmethod
+    def _create_method(cls, op, coerce_to_dtype: bool=True, result_dtype=None):
+
+        def _binop(self, other):
+
+            def convert_values(param):
+                if isinstance(param, ExtensionArray) or is_list_like(param):
+                    ovalues = param
+                else:
+                    ovalues = [param] * len(self)
+                return ovalues
+            if isinstance(other, (ABCSeries, ABCIndex, ABCDataFrame)):
+                return NotImplemented
+            lvalues = self
+            rvalues = convert_values(other)
+            res = [op(a, b) for (a, b) in zip(lvalues, rvalues)]
+
+            def _maybe_convert(arr):
+                if coerce_to_dtype:
+                    res = maybe_cast_pointwise_result(arr, self.dtype, same_dtype=False)
+                    if not isinstance(res, type(self)):
+                        res = np.asarray(arr)
+                else:
+                    res = np.asarray(arr, dtype=result_dtype)
+                return res
+            if op.__name__ in {'divmod', 'rdivmod'}:
+                (a, b) = zip(*res)
+                return (_maybe_convert(a), _maybe_convert(b))
+            return _maybe_convert(res)
+        op_name = f'__{op.__name__}__'
+        return set_function_name(_binop, op_name, cls)
+
+    @classmethod
+    def _create_arithmetic_method(cls, op):
+        return cls._create_method(op)
+
+    @classmethod
+    def _create_comparison_method(cls, op):
+        return cls._create_method(op, coerce_to_dtype=False, result_dtype=bool)
+
+# File: pandas-main/pandas/core/arrays/boolean.py
+from __future__ import annotations
+import numbers
+from typing import TYPE_CHECKING, ClassVar, cast
+import numpy as np
+from pandas._libs import lib, missing as libmissing
+from pandas.core.dtypes.common import is_list_like
+from pandas.core.dtypes.dtypes import register_extension_dtype
+from pandas.core.dtypes.missing import isna
+from pandas.core import ops
+from pandas.core.array_algos import masked_accumulations
+from pandas.core.arrays.masked import BaseMaskedArray, BaseMaskedDtype
+if TYPE_CHECKING:
+    import pyarrow
+    from pandas._typing import DtypeObj, Self, npt, type_t
+    from pandas.core.dtypes.dtypes import ExtensionDtype
+
+@register_extension_dtype
+class BooleanDtype(BaseMaskedDtype):
+    name: ClassVar[str] = 'boolean'
+    _internal_fill_value = False
+
+    @property
+    def type(self) -> type:
+        return np.bool_
+
+    @property
+    def kind(self) -> str:
+        return 'b'
+
+    @property
+    def numpy_dtype(self) -> np.dtype:
+        return np.dtype('bool')
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[BooleanArray]:
+        return BooleanArray
+
+    def __repr__(self) -> str:
+        return 'BooleanDtype'
+
+    @property
+    def _is_boolean(self) -> bool:
+        return True
+
+    @property
+    def _is_numeric(self) -> bool:
+        return True
+
+    def __from_arrow__(self, array: pyarrow.Array | pyarrow.ChunkedArray) -> BooleanArray:
+        import pyarrow
+        if array.type != pyarrow.bool_() and (not pyarrow.types.is_null(array.type)):
+            raise TypeError(f'Expected array of boolean type, got {array.type} instead')
+        if isinstance(array, pyarrow.Array):
+            chunks = [array]
+            length = len(array)
+        else:
+            chunks = array.chunks
+            length = array.length()
+        if pyarrow.types.is_null(array.type):
+            mask = np.ones(length, dtype=bool)
+            data = np.empty(length, dtype=bool)
+            return BooleanArray(data, mask)
+        results = []
+        for arr in chunks:
+            buflist = arr.buffers()
+            data = pyarrow.BooleanArray.from_buffers(arr.type, len(arr), [None, buflist[1]], offset=arr.offset).to_numpy(zero_copy_only=False)
+            if arr.null_count != 0:
+                mask = pyarrow.BooleanArray.from_buffers(arr.type, len(arr), [None, buflist[0]], offset=arr.offset).to_numpy(zero_copy_only=False)
+                mask = ~mask
+            else:
+                mask = np.zeros(len(arr), dtype=bool)
+            bool_arr = BooleanArray(data, mask)
+            results.append(bool_arr)
+        if not results:
+            return BooleanArray(np.array([], dtype=np.bool_), np.array([], dtype=np.bool_))
+        else:
+            return BooleanArray._concat_same_type(results)
+
+def coerce_to_array(values, mask=None, copy: bool=False) -> tuple[np.ndarray, np.ndarray]:
+    if isinstance(values, BooleanArray):
+        if mask is not None:
+            raise ValueError('cannot pass mask for BooleanArray input')
+        (values, mask) = (values._data, values._mask)
+        if copy:
+            values = values.copy()
+            mask = mask.copy()
+        return (values, mask)
+    mask_values = None
+    if isinstance(values, np.ndarray) and values.dtype == np.bool_:
+        if copy:
+            values = values.copy()
+    elif isinstance(values, np.ndarray) and values.dtype.kind in 'iufcb':
+        mask_values = isna(values)
+        values_bool = np.zeros(len(values), dtype=bool)
+        values_bool[~mask_values] = values[~mask_values].astype(bool)
+        if not np.all(values_bool[~mask_values].astype(values.dtype) == values[~mask_values]):
+            raise TypeError('Need to pass bool-like values')
+        values = values_bool
+    else:
+        values_object = np.asarray(values, dtype=object)
+        inferred_dtype = lib.infer_dtype(values_object, skipna=True)
+        integer_like = ('floating', 'integer', 'mixed-integer-float')
+        if inferred_dtype not in ('boolean', 'empty') + integer_like:
+            raise TypeError('Need to pass bool-like values')
+        mask_values = cast('npt.NDArray[np.bool_]', isna(values_object))
+        values = np.zeros(len(values), dtype=bool)
+        values[~mask_values] = values_object[~mask_values].astype(bool)
+        if inferred_dtype in integer_like and (not np.all(values[~mask_values].astype(float) == values_object[~mask_values].astype(float))):
+            raise TypeError('Need to pass bool-like values')
+    if mask is None and mask_values is None:
+        mask = np.zeros(values.shape, dtype=bool)
+    elif mask is None:
+        mask = mask_values
+    elif isinstance(mask, np.ndarray) and mask.dtype == np.bool_:
+        if mask_values is not None:
+            mask = mask | mask_values
+        elif copy:
+            mask = mask.copy()
+    else:
+        mask = np.array(mask, dtype=bool)
+        if mask_values is not None:
+            mask = mask | mask_values
+    if values.shape != mask.shape:
+        raise ValueError('values.shape and mask.shape must match')
+    return (values, mask)
+
+class BooleanArray(BaseMaskedArray):
+    _TRUE_VALUES = {'True', 'TRUE', 'true', '1', '1.0'}
+    _FALSE_VALUES = {'False', 'FALSE', 'false', '0', '0.0'}
+
+    @classmethod
+    def _simple_new(cls, values: np.ndarray, mask: npt.NDArray[np.bool_]) -> Self:
+        result = super()._simple_new(values, mask)
+        result._dtype = BooleanDtype()
+        return result
+
+    def __init__(self, values: np.ndarray, mask: np.ndarray, copy: bool=False) -> None:
+        if not (isinstance(values, np.ndarray) and values.dtype == np.bool_):
+            raise TypeError("values should be boolean numpy array. Use the 'pd.array' function instead")
+        self._dtype = BooleanDtype()
+        super().__init__(values, mask, copy=copy)
+
+    @property
+    def dtype(self) -> BooleanDtype:
+        return self._dtype
+
+    @classmethod
+    def _from_sequence_of_strings(cls, strings: list[str], *, dtype: ExtensionDtype, copy: bool=False, true_values: list[str] | None=None, false_values: list[str] | None=None, none_values: list[str] | None=None) -> BooleanArray:
+        true_values_union = cls._TRUE_VALUES.union(true_values or [])
+        false_values_union = cls._FALSE_VALUES.union(false_values or [])
+        if none_values is None:
+            none_values = []
+
+        def map_string(s) -> bool | None:
+            if s in true_values_union:
+                return True
+            elif s in false_values_union:
+                return False
+            elif s in none_values:
+                return None
+            else:
+                raise ValueError(f'{s} cannot be cast to bool')
+        scalars = np.array(strings, dtype=object)
+        mask = isna(scalars)
+        scalars[~mask] = list(map(map_string, scalars[~mask]))
+        return cls._from_sequence(scalars, dtype=dtype, copy=copy)
+    _HANDLED_TYPES = (np.ndarray, numbers.Number, bool, np.bool_)
+
+    @classmethod
+    def _coerce_to_array(cls, value, *, dtype: DtypeObj, copy: bool=False) -> tuple[np.ndarray, np.ndarray]:
+        if dtype:
+            assert dtype == 'boolean'
+        return coerce_to_array(value, copy=copy)
+
+    def _logical_method(self, other, op):
+        assert op.__name__ in {'or_', 'ror_', 'and_', 'rand_', 'xor', 'rxor'}
+        other_is_scalar = lib.is_scalar(other)
+        mask = None
+        if isinstance(other, BooleanArray):
+            (other, mask) = (other._data, other._mask)
+        elif is_list_like(other):
+            other = np.asarray(other, dtype='bool')
+            if other.ndim > 1:
+                raise NotImplementedError('can only perform ops with 1-d structures')
+            (other, mask) = coerce_to_array(other, copy=False)
+        elif isinstance(other, np.bool_):
+            other = other.item()
+        if other_is_scalar and other is not libmissing.NA and (not lib.is_bool(other)):
+            raise TypeError(f"'other' should be pandas.NA or a bool. Got {type(other).__name__} instead.")
+        if not other_is_scalar and len(self) != len(other):
+            raise ValueError('Lengths must match')
+        if op.__name__ in {'or_', 'ror_'}:
+            (result, mask) = ops.kleene_or(self._data, other, self._mask, mask)
+        elif op.__name__ in {'and_', 'rand_'}:
+            (result, mask) = ops.kleene_and(self._data, other, self._mask, mask)
+        else:
+            (result, mask) = ops.kleene_xor(self._data, other, self._mask, mask)
+        return self._maybe_mask_result(result, mask)
+
+    def _accumulate(self, name: str, *, skipna: bool=True, **kwargs) -> BaseMaskedArray:
+        data = self._data
+        mask = self._mask
+        if name in ('cummin', 'cummax'):
+            op = getattr(masked_accumulations, name)
+            (data, mask) = op(data, mask, skipna=skipna, **kwargs)
+            return self._simple_new(data, mask)
+        else:
+            from pandas.core.arrays import IntegerArray
+            return IntegerArray(data.astype(int), mask)._accumulate(name, skipna=skipna, **kwargs)
+
+# File: pandas-main/pandas/core/arrays/categorical.py
+from __future__ import annotations
+from csv import QUOTE_NONNUMERIC
+from functools import partial
+import operator
+from shutil import get_terminal_size
+from typing import TYPE_CHECKING, Literal, cast, overload
+import numpy as np
+from pandas._config import get_option
+from pandas._libs import NaT, algos as libalgos, lib
+from pandas._libs.arrays import NDArrayBacked
+from pandas.compat.numpy import function as nv
+from pandas.util._validators import validate_bool_kwarg
+from pandas.core.dtypes.cast import coerce_indexer_dtype, find_common_type
+from pandas.core.dtypes.common import ensure_int64, ensure_platform_int, is_any_real_numeric_dtype, is_bool_dtype, is_dict_like, is_hashable, is_integer_dtype, is_list_like, is_scalar, needs_i8_conversion, pandas_dtype
+from pandas.core.dtypes.dtypes import ArrowDtype, CategoricalDtype, CategoricalDtypeType, ExtensionDtype
+from pandas.core.dtypes.generic import ABCIndex, ABCSeries
+from pandas.core.dtypes.missing import is_valid_na_for_dtype, isna
+from pandas.core import algorithms, arraylike, ops
+from pandas.core.accessor import PandasDelegate, delegate_names
+from pandas.core.algorithms import factorize, take_nd
+from pandas.core.arrays._mixins import NDArrayBackedExtensionArray, ravel_compat
+from pandas.core.base import ExtensionArray, NoNewAttributesMixin, PandasObject
+import pandas.core.common as com
+from pandas.core.construction import extract_array, sanitize_array
+from pandas.core.ops.common import unpack_zerodim_and_defer
+from pandas.core.sorting import nargsort
+from pandas.core.strings.object_array import ObjectStringArrayMixin
+from pandas.io.formats import console
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Iterator, Sequence
+    from pandas._typing import ArrayLike, AstypeArg, AxisInt, Dtype, DtypeObj, NpDtype, Ordered, Self, Shape, SortKind, npt
+    from pandas import DataFrame, Index, Series
+
+def _cat_compare_op(op):
+    opname = f'__{op.__name__}__'
+    fill_value = op is operator.ne
+
+    @unpack_zerodim_and_defer(opname)
+    def func(self, other):
+        hashable = is_hashable(other)
+        if is_list_like(other) and len(other) != len(self) and (not hashable):
+            raise ValueError('Lengths must match.')
+        if not self.ordered:
+            if opname in ['__lt__', '__gt__', '__le__', '__ge__']:
+                raise TypeError('Unordered Categoricals can only compare equality or not')
+        if isinstance(other, Categorical):
+            msg = "Categoricals can only be compared if 'categories' are the same."
+            if not self._categories_match_up_to_permutation(other):
+                raise TypeError(msg)
+            if not self.ordered and (not self.categories.equals(other.categories)):
+                other_codes = recode_for_categories(other.codes, other.categories, self.categories, copy=False)
+            else:
+                other_codes = other._codes
+            ret = op(self._codes, other_codes)
+            mask = (self._codes == -1) | (other_codes == -1)
+            if mask.any():
+                ret[mask] = fill_value
+            return ret
+        if hashable:
+            if other in self.categories:
+                i = self._unbox_scalar(other)
+                ret = op(self._codes, i)
+                if opname not in {'__eq__', '__ge__', '__gt__'}:
+                    mask = self._codes == -1
+                    ret[mask] = fill_value
+                return ret
+            else:
+                return ops.invalid_comparison(self, other, op)
+        else:
+            if opname not in ['__eq__', '__ne__']:
+                raise TypeError(f"Cannot compare a Categorical for op {opname} with type {type(other)}.\nIf you want to compare values, use 'np.asarray(cat) <op> other'.")
+            if isinstance(other, ExtensionArray) and needs_i8_conversion(other.dtype):
+                return op(other, self)
+            return getattr(np.array(self), opname)(np.array(other))
+    func.__name__ = opname
+    return func
+
+def contains(cat, key, container) -> bool:
+    hash(key)
+    try:
+        loc = cat.categories.get_loc(key)
+    except (KeyError, TypeError):
+        return False
+    if is_scalar(loc):
+        return loc in container
+    else:
+        return any((loc_ in container for loc_ in loc))
+
+class Categorical(NDArrayBackedExtensionArray, PandasObject, ObjectStringArrayMixin):
+    __array_priority__ = 1000
+    _hidden_attrs = PandasObject._hidden_attrs | frozenset(['tolist'])
+    _typ = 'categorical'
+    _dtype: CategoricalDtype
+
+    @classmethod
+    def _simple_new(cls, codes: np.ndarray, dtype: CategoricalDtype) -> Self:
+        codes = coerce_indexer_dtype(codes, dtype.categories)
+        dtype = CategoricalDtype(ordered=False).update_dtype(dtype)
+        return super()._simple_new(codes, dtype)
+
+    def __init__(self, values, categories=None, ordered=None, dtype: Dtype | None=None, copy: bool=True) -> None:
+        dtype = CategoricalDtype._from_values_or_dtype(values, categories, ordered, dtype)
+        if not is_list_like(values):
+            raise TypeError('Categorical input must be list-like')
+        null_mask = np.array(False)
+        vdtype = getattr(values, 'dtype', None)
+        if isinstance(vdtype, CategoricalDtype):
+            if dtype.categories is None:
+                dtype = CategoricalDtype(values.categories, dtype.ordered)
+        elif isinstance(values, range):
+            from pandas.core.indexes.range import RangeIndex
+            values = RangeIndex(values)
+        elif not isinstance(values, (ABCIndex, ABCSeries, ExtensionArray)):
+            values = com.convert_to_list_like(values)
+            if isinstance(values, list) and len(values) == 0:
+                values = np.array([], dtype=object)
+            elif isinstance(values, np.ndarray):
+                if values.ndim > 1:
+                    raise NotImplementedError('> 1 ndim Categorical are not supported at this time')
+                values = sanitize_array(values, None)
+            else:
+                arr = sanitize_array(values, None)
+                null_mask = isna(arr)
+                if null_mask.any():
+                    arr_list = [values[idx] for idx in np.where(~null_mask)[0]]
+                    if arr_list or arr.dtype == 'object':
+                        sanitize_dtype = None
+                    else:
+                        sanitize_dtype = arr.dtype
+                    arr = sanitize_array(arr_list, None, dtype=sanitize_dtype)
+                values = arr
+        if dtype.categories is None:
+            if isinstance(values.dtype, ArrowDtype) and issubclass(values.dtype.type, CategoricalDtypeType):
+                arr = values._pa_array.combine_chunks()
+                categories = arr.dictionary.to_pandas(types_mapper=ArrowDtype)
+                codes = arr.indices.to_numpy()
+                dtype = CategoricalDtype(categories, values.dtype.pyarrow_dtype.ordered)
+            else:
+                if not isinstance(values, ABCIndex):
+                    values = sanitize_array(values, None)
+                try:
+                    (codes, categories) = factorize(values, sort=True)
+                except TypeError as err:
+                    (codes, categories) = factorize(values, sort=False)
+                    if dtype.ordered:
+                        raise TypeError("'values' is not ordered, please explicitly specify the categories order by passing in a categories argument.") from err
+                dtype = CategoricalDtype(categories, dtype.ordered)
+        elif isinstance(values.dtype, CategoricalDtype):
+            old_codes = extract_array(values)._codes
+            codes = recode_for_categories(old_codes, values.dtype.categories, dtype.categories, copy=copy)
+        else:
+            codes = _get_codes_for_values(values, dtype.categories)
+        if null_mask.any():
+            full_codes = -np.ones(null_mask.shape, dtype=codes.dtype)
+            full_codes[~null_mask] = codes
+            codes = full_codes
+        dtype = CategoricalDtype(ordered=False).update_dtype(dtype)
+        arr = coerce_indexer_dtype(codes, dtype.categories)
+        super().__init__(arr, dtype)
+
+    @property
+    def dtype(self) -> CategoricalDtype:
+        return self._dtype
+
+    @property
+    def _internal_fill_value(self) -> int:
+        dtype = self._ndarray.dtype
+        return dtype.type(-1)
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype: Dtype | None=None, copy: bool=False) -> Self:
+        return cls(scalars, dtype=dtype, copy=copy)
+
+    @classmethod
+    def _from_scalars(cls, scalars, *, dtype: DtypeObj) -> Self:
+        if dtype is None:
+            raise NotImplementedError
+        res = cls._from_sequence(scalars, dtype=dtype)
+        mask = isna(scalars)
+        if not (mask == res.isna()).all():
+            raise ValueError
+        return res
+
+    @overload
+    def astype(self, dtype: npt.DTypeLike, copy: bool=...) -> np.ndarray:
+        ...
+
+    @overload
+    def astype(self, dtype: ExtensionDtype, copy: bool=...) -> ExtensionArray:
+        ...
+
+    @overload
+    def astype(self, dtype: AstypeArg, copy: bool=...) -> ArrayLike:
+        ...
+
+    def astype(self, dtype: AstypeArg, copy: bool=True) -> ArrayLike:
+        dtype = pandas_dtype(dtype)
+        result: Categorical | np.ndarray
+        if self.dtype is dtype:
+            result = self.copy() if copy else self
+        elif isinstance(dtype, CategoricalDtype):
+            dtype = self.dtype.update_dtype(dtype)
+            self = self.copy() if copy else self
+            result = self._set_dtype(dtype)
+        elif isinstance(dtype, ExtensionDtype):
+            return super().astype(dtype, copy=copy)
+        elif dtype.kind in 'iu' and self.isna().any():
+            raise ValueError('Cannot convert float NaN to integer')
+        elif len(self.codes) == 0 or len(self.categories) == 0:
+            result = np.array(self, dtype=dtype, copy=copy)
+        else:
+            new_cats = self.categories._values
+            try:
+                new_cats = new_cats.astype(dtype=dtype, copy=copy)
+                fill_value = self.categories._na_value
+                if not is_valid_na_for_dtype(fill_value, dtype):
+                    fill_value = lib.item_from_zerodim(np.array(self.categories._na_value).astype(dtype))
+            except (TypeError, ValueError) as err:
+                msg = f'Cannot cast {self.categories.dtype} dtype to {dtype}'
+                raise ValueError(msg) from err
+            result = take_nd(new_cats, ensure_platform_int(self._codes), fill_value=fill_value)
+        return result
+
+    @classmethod
+    def _from_inferred_categories(cls, inferred_categories, inferred_codes, dtype, true_values=None) -> Self:
+        from pandas import Index, to_datetime, to_numeric, to_timedelta
+        cats = Index(inferred_categories)
+        known_categories = isinstance(dtype, CategoricalDtype) and dtype.categories is not None
+        if known_categories:
+            if is_any_real_numeric_dtype(dtype.categories.dtype):
+                cats = to_numeric(inferred_categories, errors='coerce')
+            elif lib.is_np_dtype(dtype.categories.dtype, 'M'):
+                cats = to_datetime(inferred_categories, errors='coerce')
+            elif lib.is_np_dtype(dtype.categories.dtype, 'm'):
+                cats = to_timedelta(inferred_categories, errors='coerce')
+            elif is_bool_dtype(dtype.categories.dtype):
+                if true_values is None:
+                    true_values = ['True', 'TRUE', 'true']
+                cats = cats.isin(true_values)
+        if known_categories:
+            categories = dtype.categories
+            codes = recode_for_categories(inferred_codes, cats, categories)
+        elif not cats.is_monotonic_increasing:
+            unsorted = cats.copy()
+            categories = cats.sort_values()
+            codes = recode_for_categories(inferred_codes, unsorted, categories)
+            dtype = CategoricalDtype(categories, ordered=False)
+        else:
+            dtype = CategoricalDtype(cats, ordered=False)
+            codes = inferred_codes
+        return cls._simple_new(codes, dtype=dtype)
+
+    @classmethod
+    def from_codes(cls, codes, categories=None, ordered=None, dtype: Dtype | None=None, validate: bool=True) -> Self:
+        dtype = CategoricalDtype._from_values_or_dtype(categories=categories, ordered=ordered, dtype=dtype)
+        if dtype.categories is None:
+            msg = "The categories must be provided in 'categories' or 'dtype'. Both were None."
+            raise ValueError(msg)
+        if validate:
+            codes = cls._validate_codes_for_dtype(codes, dtype=dtype)
+        return cls._simple_new(codes, dtype=dtype)
+
+    @property
+    def categories(self) -> Index:
+        return self.dtype.categories
+
+    @property
+    def ordered(self) -> Ordered:
+        return self.dtype.ordered
+
+    @property
+    def codes(self) -> np.ndarray:
+        v = self._codes.view()
+        v.flags.writeable = False
+        return v
+
+    def _set_categories(self, categories, fastpath: bool=False) -> None:
+        if fastpath:
+            new_dtype = CategoricalDtype._from_fastpath(categories, self.ordered)
+        else:
+            new_dtype = CategoricalDtype(categories, ordered=self.ordered)
+        if not fastpath and self.dtype.categories is not None and (len(new_dtype.categories) != len(self.dtype.categories)):
+            raise ValueError('new categories need to have the same number of items as the old categories!')
+        super().__init__(self._ndarray, new_dtype)
+
+    def _set_dtype(self, dtype: CategoricalDtype) -> Self:
+        codes = recode_for_categories(self.codes, self.categories, dtype.categories)
+        return type(self)._simple_new(codes, dtype=dtype)
+
+    def set_ordered(self, value: bool) -> Self:
+        new_dtype = CategoricalDtype(self.categories, ordered=value)
+        cat = self.copy()
+        NDArrayBacked.__init__(cat, cat._ndarray, new_dtype)
+        return cat
+
+    def as_ordered(self) -> Self:
+        return self.set_ordered(True)
+
+    def as_unordered(self) -> Self:
+        return self.set_ordered(False)
+
+    def set_categories(self, new_categories, ordered=None, rename: bool=False) -> Self:
+        if ordered is None:
+            ordered = self.dtype.ordered
+        new_dtype = CategoricalDtype(new_categories, ordered=ordered)
+        cat = self.copy()
+        if rename:
+            if cat.dtype.categories is not None and len(new_dtype.categories) < len(cat.dtype.categories):
+                cat._codes[cat._codes >= len(new_dtype.categories)] = -1
+            codes = cat._codes
+        else:
+            codes = recode_for_categories(cat.codes, cat.categories, new_dtype.categories)
+        NDArrayBacked.__init__(cat, codes, new_dtype)
+        return cat
+
+    def rename_categories(self, new_categories) -> Self:
+        if is_dict_like(new_categories):
+            new_categories = [new_categories.get(item, item) for item in self.categories]
+        elif callable(new_categories):
+            new_categories = [new_categories(item) for item in self.categories]
+        cat = self.copy()
+        cat._set_categories(new_categories)
+        return cat
+
+    def reorder_categories(self, new_categories, ordered=None) -> Self:
+        if len(self.categories) != len(new_categories) or not self.categories.difference(new_categories).empty:
+            raise ValueError('items in new_categories are not the same as in old categories')
+        return self.set_categories(new_categories, ordered=ordered)
+
+    def add_categories(self, new_categories) -> Self:
+        if not is_list_like(new_categories):
+            new_categories = [new_categories]
+        already_included = set(new_categories) & set(self.dtype.categories)
+        if len(already_included) != 0:
+            raise ValueError(f'new categories must not include old categories: {already_included}')
+        if hasattr(new_categories, 'dtype'):
+            from pandas import Series
+            dtype = find_common_type([self.dtype.categories.dtype, new_categories.dtype])
+            new_categories = Series(list(self.dtype.categories) + list(new_categories), dtype=dtype)
+        else:
+            new_categories = list(self.dtype.categories) + list(new_categories)
+        new_dtype = CategoricalDtype(new_categories, self.ordered)
+        cat = self.copy()
+        codes = coerce_indexer_dtype(cat._ndarray, new_dtype.categories)
+        NDArrayBacked.__init__(cat, codes, new_dtype)
+        return cat
+
+    def remove_categories(self, removals) -> Self:
+        from pandas import Index
+        if not is_list_like(removals):
+            removals = [removals]
+        removals = Index(removals).unique().dropna()
+        new_categories = self.dtype.categories.difference(removals, sort=False) if self.dtype.ordered is True else self.dtype.categories.difference(removals)
+        not_included = removals.difference(self.dtype.categories)
+        if len(not_included) != 0:
+            not_included = set(not_included)
+            raise ValueError(f'removals must all be in old categories: {not_included}')
+        return self.set_categories(new_categories, ordered=self.ordered, rename=False)
+
+    def remove_unused_categories(self) -> Self:
+        (idx, inv) = np.unique(self._codes, return_inverse=True)
+        if idx.size != 0 and idx[0] == -1:
+            (idx, inv) = (idx[1:], inv - 1)
+        new_categories = self.dtype.categories.take(idx)
+        new_dtype = CategoricalDtype._from_fastpath(new_categories, ordered=self.ordered)
+        new_codes = coerce_indexer_dtype(inv, new_dtype.categories)
+        cat = self.copy()
+        NDArrayBacked.__init__(cat, new_codes, new_dtype)
+        return cat
+
+    def map(self, mapper, na_action: Literal['ignore'] | None=None):
+        assert callable(mapper) or is_dict_like(mapper)
+        new_categories = self.categories.map(mapper)
+        has_nans = np.any(self._codes == -1)
+        na_val = np.nan
+        if na_action is None and has_nans:
+            na_val = mapper(np.nan) if callable(mapper) else mapper.get(np.nan, np.nan)
+        if new_categories.is_unique and (not new_categories.hasnans) and (na_val is np.nan):
+            new_dtype = CategoricalDtype(new_categories, ordered=self.ordered)
+            return self.from_codes(self._codes.copy(), dtype=new_dtype, validate=False)
+        if has_nans:
+            new_categories = new_categories.insert(len(new_categories), na_val)
+        return np.take(new_categories, self._codes)
+    __eq__ = _cat_compare_op(operator.eq)
+    __ne__ = _cat_compare_op(operator.ne)
+    __lt__ = _cat_compare_op(operator.lt)
+    __gt__ = _cat_compare_op(operator.gt)
+    __le__ = _cat_compare_op(operator.le)
+    __ge__ = _cat_compare_op(operator.ge)
+
+    def _validate_setitem_value(self, value):
+        if not is_hashable(value):
+            return self._validate_listlike(value)
+        else:
+            return self._validate_scalar(value)
+
+    def _validate_scalar(self, fill_value):
+        if is_valid_na_for_dtype(fill_value, self.categories.dtype):
+            fill_value = -1
+        elif fill_value in self.categories:
+            fill_value = self._unbox_scalar(fill_value)
+        else:
+            raise TypeError(f'Cannot setitem on a Categorical with a new category ({fill_value}), set the categories first') from None
+        return fill_value
+
+    @classmethod
+    def _validate_codes_for_dtype(cls, codes, *, dtype: CategoricalDtype) -> np.ndarray:
+        if isinstance(codes, ExtensionArray) and is_integer_dtype(codes.dtype):
+            if isna(codes).any():
+                raise ValueError('codes cannot contain NA values')
+            codes = codes.to_numpy(dtype=np.int64)
+        else:
+            codes = np.asarray(codes)
+        if len(codes) and codes.dtype.kind not in 'iu':
+            raise ValueError('codes need to be array-like integers')
+        if len(codes) and (codes.max() >= len(dtype.categories) or codes.min() < -1):
+            raise ValueError('codes need to be between -1 and len(categories)-1')
+        return codes
+
+    @ravel_compat
+    def __array__(self, dtype: NpDtype | None=None, copy: bool | None=None) -> np.ndarray:
+        ret = take_nd(self.categories._values, self._codes)
+        if dtype and np.dtype(dtype) != self.categories.dtype:
+            return np.asarray(ret, dtype)
+        return np.asarray(ret)
+
+    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
+        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(self, ufunc, method, *inputs, **kwargs)
+        if result is not NotImplemented:
+            return result
+        if 'out' in kwargs:
+            return arraylike.dispatch_ufunc_with_out(self, ufunc, method, *inputs, **kwargs)
+        if method == 'reduce':
+            result = arraylike.dispatch_reduction_ufunc(self, ufunc, method, *inputs, **kwargs)
+            if result is not NotImplemented:
+                return result
+        raise TypeError(f'Object with dtype {self.dtype} cannot perform the numpy op {ufunc.__name__}')
+
+    def __setstate__(self, state) -> None:
+        if not isinstance(state, dict):
+            return super().__setstate__(state)
+        if '_dtype' not in state:
+            state['_dtype'] = CategoricalDtype(state['_categories'], state['_ordered'])
+        if '_codes' in state and '_ndarray' not in state:
+            state['_ndarray'] = state.pop('_codes')
+        super().__setstate__(state)
+
+    @property
+    def nbytes(self) -> int:
+        return self._codes.nbytes + self.dtype.categories.values.nbytes
+
+    def memory_usage(self, deep: bool=False) -> int:
+        return self._codes.nbytes + self.dtype.categories.memory_usage(deep=deep)
+
+    def isna(self) -> npt.NDArray[np.bool_]:
+        return self._codes == -1
+    isnull = isna
+
+    def notna(self) -> npt.NDArray[np.bool_]:
+        return ~self.isna()
+    notnull = notna
+
+    def value_counts(self, dropna: bool=True) -> Series:
+        from pandas import CategoricalIndex, Series
+        (code, cat) = (self._codes, self.categories)
+        (ncat, mask) = (len(cat), code >= 0)
+        (ix, clean) = (np.arange(ncat), mask.all())
+        if dropna or clean:
+            obs = code if clean else code[mask]
+            count = np.bincount(obs, minlength=ncat or 0)
+        else:
+            count = np.bincount(np.where(mask, code, ncat))
+            ix = np.append(ix, -1)
+        ix = coerce_indexer_dtype(ix, self.dtype.categories)
+        ix_categorical = self._from_backing_data(ix)
+        return Series(count, index=CategoricalIndex(ix_categorical), dtype='int64', name='count', copy=False)
+
+    @classmethod
+    def _empty(cls, shape: Shape, dtype: CategoricalDtype) -> Self:
+        arr = cls._from_sequence([], dtype=dtype)
+        backing = np.zeros(shape, dtype=arr._ndarray.dtype)
+        return arr._from_backing_data(backing)
+
+    def _internal_get_values(self) -> ArrayLike:
+        if needs_i8_conversion(self.categories.dtype):
+            return self.categories.take(self._codes, fill_value=NaT)._values
+        elif is_integer_dtype(self.categories.dtype) and -1 in self._codes:
+            return self.categories.astype('object').take(self._codes, fill_value=np.nan)._values
+        return np.array(self)
+
+    def check_for_ordered(self, op) -> None:
+        if not self.ordered:
+            raise TypeError(f'Categorical is not ordered for operation {op}\nyou can use .as_ordered() to change the Categorical to an ordered one\n')
+
+    def argsort(self, *, ascending: bool=True, kind: SortKind='quicksort', **kwargs) -> npt.NDArray[np.intp]:
+        return super().argsort(ascending=ascending, kind=kind, **kwargs)
+
+    @overload
+    def sort_values(self, *, inplace: Literal[False]=..., ascending: bool=..., na_position: str=...) -> Self:
+        ...
+
+    @overload
+    def sort_values(self, *, inplace: Literal[True], ascending: bool=..., na_position: str=...) -> None:
+        ...
+
+    def sort_values(self, *, inplace: bool=False, ascending: bool=True, na_position: str='last') -> Self | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if na_position not in ['last', 'first']:
+            raise ValueError(f'invalid na_position: {na_position!r}')
+        sorted_idx = nargsort(self, ascending=ascending, na_position=na_position)
+        if not inplace:
+            codes = self._codes[sorted_idx]
+            return self._from_backing_data(codes)
+        self._codes[:] = self._codes[sorted_idx]
+        return None
+
+    def _rank(self, *, axis: AxisInt=0, method: str='average', na_option: str='keep', ascending: bool=True, pct: bool=False):
+        if axis != 0:
+            raise NotImplementedError
+        vff = self._values_for_rank()
+        return algorithms.rank(vff, axis=axis, method=method, na_option=na_option, ascending=ascending, pct=pct)
+
+    def _values_for_rank(self) -> np.ndarray:
+        from pandas import Series
+        if self.ordered:
+            values = self.codes
+            mask = values == -1
+            if mask.any():
+                values = values.astype('float64')
+                values[mask] = np.nan
+        elif is_any_real_numeric_dtype(self.categories.dtype):
+            values = np.array(self)
+        else:
+            values = np.array(self.rename_categories(Series(self.categories, copy=False).rank().values))
+        return values
+
+    def _hash_pandas_object(self, *, encoding: str, hash_key: str, categorize: bool) -> npt.NDArray[np.uint64]:
+        from pandas.core.util.hashing import hash_array
+        values = np.asarray(self.categories._values)
+        hashed = hash_array(values, encoding, hash_key, categorize=False)
+        mask = self.isna()
+        if len(hashed):
+            result = hashed.take(self._codes)
+        else:
+            result = np.zeros(len(mask), dtype='uint64')
+        if mask.any():
+            result[mask] = lib.u8max
+        return result
+
+    @property
+    def _codes(self) -> np.ndarray:
+        return self._ndarray
+
+    def _box_func(self, i: int):
+        if i == -1:
+            return np.nan
+        return self.categories[i]
+
+    def _unbox_scalar(self, key) -> int:
+        code = self.categories.get_loc(key)
+        code = self._ndarray.dtype.type(code)
+        return code
+
+    def __iter__(self) -> Iterator:
+        if self.ndim == 1:
+            return iter(self._internal_get_values().tolist())
+        else:
+            return (self[n] for n in range(len(self)))
+
+    def __contains__(self, key) -> bool:
+        if is_valid_na_for_dtype(key, self.categories.dtype):
+            return bool(self.isna().any())
+        return contains(self, key, container=self._codes)
+
+    def _formatter(self, boxed: bool=False) -> None:
+        return None
+
+    def _repr_categories(self) -> list[str]:
+        max_categories = 10 if get_option('display.max_categories') == 0 else get_option('display.max_categories')
+        from pandas.io.formats import format as fmt
+        format_array = partial(fmt.format_array, formatter=None, quoting=QUOTE_NONNUMERIC)
+        if len(self.categories) > max_categories:
+            num = max_categories // 2
+            head = format_array(self.categories[:num]._values)
+            tail = format_array(self.categories[-num:]._values)
+            category_strs = head + ['...'] + tail
+        else:
+            category_strs = format_array(self.categories._values)
+        category_strs = [x.strip() for x in category_strs]
+        return category_strs
+
+    def _get_repr_footer(self) -> str:
+        category_strs = self._repr_categories()
+        dtype = str(self.categories.dtype)
+        levheader = f'Categories ({len(self.categories)}, {dtype}): '
+        (width, _) = get_terminal_size()
+        max_width = get_option('display.width') or width
+        if console.in_ipython_frontend():
+            max_width = 0
+        levstring = ''
+        start = True
+        cur_col_len = len(levheader)
+        (sep_len, sep) = (3, ' < ') if self.ordered else (2, ', ')
+        linesep = f'{sep.rstrip()}\n'
+        for val in category_strs:
+            if max_width != 0 and cur_col_len + sep_len + len(val) > max_width:
+                levstring += linesep + ' ' * (len(levheader) + 1)
+                cur_col_len = len(levheader) + 1
+            elif not start:
+                levstring += sep
+                cur_col_len += len(val)
+            levstring += val
+            start = False
+        return f"{levheader}[{levstring.replace(' < ... < ', ' ... ')}]"
+
+    def _get_values_repr(self) -> str:
+        from pandas.io.formats import format as fmt
+        assert len(self) > 0
+        vals = self._internal_get_values()
+        fmt_values = fmt.format_array(vals, None, float_format=None, na_rep='NaN', quoting=QUOTE_NONNUMERIC)
+        fmt_values = [i.strip() for i in fmt_values]
+        joined = ', '.join(fmt_values)
+        result = '[' + joined + ']'
+        return result
+
+    def __repr__(self) -> str:
+        footer = self._get_repr_footer()
+        length = len(self)
+        max_len = 10
+        if length > max_len:
+            num = max_len // 2
+            head = self[:num]._get_values_repr()
+            tail = self[-(max_len - num):]._get_values_repr()
+            body = f'{head[:-1]}, ..., {tail[1:]}'
+            length_info = f'Length: {len(self)}'
+            result = f'{body}\n{length_info}\n{footer}'
+        elif length > 0:
+            body = self._get_values_repr()
+            result = f'{body}\n{footer}'
+        else:
+            body = '[]'
+            result = f'{body}, {footer}'
+        return result
+
+    def _validate_listlike(self, value):
+        value = extract_array(value, extract_numpy=True)
+        if isinstance(value, Categorical):
+            if self.dtype != value.dtype:
+                raise TypeError('Cannot set a Categorical with another, without identical categories')
+            value = self._encode_with_my_categories(value)
+            return value._codes
+        from pandas import Index
+        to_add = Index._with_infer(value, tupleize_cols=False).difference(self.categories)
+        if len(to_add) and (not isna(to_add).all()):
+            raise TypeError('Cannot setitem on a Categorical with a new category, set the categories first')
+        codes = self.categories.get_indexer(value)
+        return codes.astype(self._ndarray.dtype, copy=False)
+
+    def _reverse_indexer(self) -> dict[Hashable, npt.NDArray[np.intp]]:
+        categories = self.categories
+        (r, counts) = libalgos.groupsort_indexer(ensure_platform_int(self.codes), categories.size)
+        counts = ensure_int64(counts).cumsum()
+        _result = (r[start:end] for (start, end) in zip(counts, counts[1:]))
+        return dict(zip(categories, _result))
+
+    def _reduce(self, name: str, *, skipna: bool=True, keepdims: bool=False, **kwargs):
+        result = super()._reduce(name, skipna=skipna, keepdims=keepdims, **kwargs)
+        if name in ['argmax', 'argmin']:
+            return result
+        if keepdims:
+            return type(self)(result, dtype=self.dtype)
+        else:
+            return result
+
+    def min(self, *, skipna: bool=True, **kwargs):
+        nv.validate_minmax_axis(kwargs.get('axis', 0))
+        nv.validate_min((), kwargs)
+        self.check_for_ordered('min')
+        if not len(self._codes):
+            return self.dtype.na_value
+        good = self._codes != -1
+        if not good.all():
+            if skipna and good.any():
+                pointer = self._codes[good].min()
+            else:
+                return np.nan
+        else:
+            pointer = self._codes.min()
+        return self._wrap_reduction_result(None, pointer)
+
+    def max(self, *, skipna: bool=True, **kwargs):
+        nv.validate_minmax_axis(kwargs.get('axis', 0))
+        nv.validate_max((), kwargs)
+        self.check_for_ordered('max')
+        if not len(self._codes):
+            return self.dtype.na_value
+        good = self._codes != -1
+        if not good.all():
+            if skipna and good.any():
+                pointer = self._codes[good].max()
+            else:
+                return np.nan
+        else:
+            pointer = self._codes.max()
+        return self._wrap_reduction_result(None, pointer)
+
+    def _mode(self, dropna: bool=True) -> Categorical:
+        codes = self._codes
+        mask = None
+        if dropna:
+            mask = self.isna()
+        res_codes = algorithms.mode(codes, mask=mask)
+        res_codes = cast(np.ndarray, res_codes)
+        assert res_codes.dtype == codes.dtype
+        res = self._from_backing_data(res_codes)
+        return res
+
+    def unique(self) -> Self:
+        return super().unique()
+
+    def equals(self, other: object) -> bool:
+        if not isinstance(other, Categorical):
+            return False
+        elif self._categories_match_up_to_permutation(other):
+            other = self._encode_with_my_categories(other)
+            return np.array_equal(self._codes, other._codes)
+        return False
+
+    def _accumulate(self, name: str, skipna: bool=True, **kwargs) -> Self:
+        func: Callable
+        if name == 'cummin':
+            func = np.minimum.accumulate
+        elif name == 'cummax':
+            func = np.maximum.accumulate
+        else:
+            raise TypeError(f'Accumulation {name} not supported for {type(self)}')
+        self.check_for_ordered(name)
+        codes = self.codes.copy()
+        mask = self.isna()
+        if func == np.minimum.accumulate:
+            codes[mask] = np.iinfo(codes.dtype.type).max
+        if not skipna:
+            mask = np.maximum.accumulate(mask)
+        codes = func(codes)
+        codes[mask] = -1
+        return self._simple_new(codes, dtype=self._dtype)
+
+    @classmethod
+    def _concat_same_type(cls, to_concat: Sequence[Self], axis: AxisInt=0) -> Self:
+        from pandas.core.dtypes.concat import union_categoricals
+        first = to_concat[0]
+        if axis >= first.ndim:
+            raise ValueError(f'axis {axis} is out of bounds for array of dimension {first.ndim}')
+        if axis == 1:
+            if not all((x.ndim == 2 for x in to_concat)):
+                raise ValueError
+            tc_flat = []
+            for obj in to_concat:
+                tc_flat.extend([obj[:, i] for i in range(obj.shape[1])])
+            res_flat = cls._concat_same_type(tc_flat, axis=0)
+            result = res_flat.reshape(len(first), -1, order='F')
+            return result
+        result = union_categoricals(to_concat)
+        return result
+
+    def _encode_with_my_categories(self, other: Categorical) -> Categorical:
+        codes = recode_for_categories(other.codes, other.categories, self.categories, copy=False)
+        return self._from_backing_data(codes)
+
+    def _categories_match_up_to_permutation(self, other: Categorical) -> bool:
+        return hash(self.dtype) == hash(other.dtype)
+
+    def describe(self) -> DataFrame:
+        counts = self.value_counts(dropna=False)
+        freqs = counts / counts.sum()
+        from pandas import Index
+        from pandas.core.reshape.concat import concat
+        result = concat([counts, freqs], ignore_index=True, axis=1)
+        result.columns = Index(['counts', 'freqs'])
+        result.index.name = 'categories'
+        return result
+
+    def isin(self, values: ArrayLike) -> npt.NDArray[np.bool_]:
+        null_mask = np.asarray(isna(values))
+        code_values = self.categories.get_indexer_for(values)
+        code_values = code_values[null_mask | (code_values >= 0)]
+        return algorithms.isin(self.codes, code_values)
+
+    def _str_map(self, f, na_value=np.nan, dtype=np.dtype('object'), convert: bool=True):
+        from pandas.core.arrays import NumpyExtensionArray
+        categories = self.categories
+        codes = self.codes
+        result = NumpyExtensionArray(categories.to_numpy())._str_map(f, na_value, dtype)
+        return take_nd(result, codes, fill_value=na_value)
+
+    def _str_get_dummies(self, sep: str='|', dtype: NpDtype | None=None):
+        from pandas.core.arrays import NumpyExtensionArray
+        return NumpyExtensionArray(self.astype(str))._str_get_dummies(sep, dtype)
+
+    def _groupby_op(self, *, how: str, has_dropped_na: bool, min_count: int, ngroups: int, ids: npt.NDArray[np.intp], **kwargs):
+        from pandas.core.groupby.ops import WrappedCythonOp
+        kind = WrappedCythonOp.get_kind_from_how(how)
+        op = WrappedCythonOp(how=how, kind=kind, has_dropped_na=has_dropped_na)
+        dtype = self.dtype
+        if how in ['sum', 'prod', 'cumsum', 'cumprod', 'skew']:
+            raise TypeError(f'{dtype} type does not support {how} operations')
+        if how in ['min', 'max', 'rank', 'idxmin', 'idxmax'] and (not dtype.ordered):
+            raise TypeError(f'Cannot perform {how} with non-ordered Categorical')
+        if how not in ['rank', 'any', 'all', 'first', 'last', 'min', 'max', 'idxmin', 'idxmax']:
+            if kind == 'transform':
+                raise TypeError(f'{dtype} type does not support {how} operations')
+            raise TypeError(f"{dtype} dtype does not support aggregation '{how}'")
+        result_mask = None
+        mask = self.isna()
+        if how == 'rank':
+            assert self.ordered
+            npvalues = self._ndarray
+        elif how in ['first', 'last', 'min', 'max', 'idxmin', 'idxmax']:
+            npvalues = self._ndarray
+            result_mask = np.zeros(ngroups, dtype=bool)
+        else:
+            npvalues = self.astype(bool)
+        res_values = op._cython_op_ndim_compat(npvalues, min_count=min_count, ngroups=ngroups, comp_ids=ids, mask=mask, result_mask=result_mask, **kwargs)
+        if how in op.cast_blocklist:
+            return res_values
+        elif how in ['first', 'last', 'min', 'max']:
+            res_values[result_mask == 1] = -1
+        return self._from_backing_data(res_values)
+
+@delegate_names(delegate=Categorical, accessors=['categories', 'ordered'], typ='property')
+@delegate_names(delegate=Categorical, accessors=['rename_categories', 'reorder_categories', 'add_categories', 'remove_categories', 'remove_unused_categories', 'set_categories', 'as_ordered', 'as_unordered'], typ='method')
+class CategoricalAccessor(PandasDelegate, PandasObject, NoNewAttributesMixin):
+
+    def __init__(self, data) -> None:
+        self._validate(data)
+        self._parent = data.values
+        self._index = data.index
+        self._name = data.name
+        self._freeze()
+
+    @staticmethod
+    def _validate(data) -> None:
+        if not isinstance(data.dtype, CategoricalDtype):
+            raise AttributeError("Can only use .cat accessor with a 'category' dtype")
+
+    def _delegate_property_get(self, name: str):
+        return getattr(self._parent, name)
+
+    def _delegate_property_set(self, name: str, new_values) -> None:
+        setattr(self._parent, name, new_values)
+
+    @property
+    def codes(self) -> Series:
+        from pandas import Series
+        return Series(self._parent.codes, index=self._index)
+
+    def _delegate_method(self, name: str, *args, **kwargs):
+        from pandas import Series
+        method = getattr(self._parent, name)
+        res = method(*args, **kwargs)
+        if res is not None:
+            return Series(res, index=self._index, name=self._name)
+
+def _get_codes_for_values(values: Index | Series | ExtensionArray | np.ndarray, categories: Index) -> np.ndarray:
+    codes = categories.get_indexer_for(values)
+    return coerce_indexer_dtype(codes, categories)
+
+def recode_for_categories(codes: np.ndarray, old_categories, new_categories, copy: bool=True) -> np.ndarray:
+    if len(old_categories) == 0:
+        if copy:
+            return codes.copy()
+        return codes
+    elif new_categories.equals(old_categories):
+        if copy:
+            return codes.copy()
+        return codes
+    indexer = coerce_indexer_dtype(new_categories.get_indexer_for(old_categories), new_categories)
+    new_codes = take_nd(indexer, codes, fill_value=-1)
+    return new_codes
+
+def factorize_from_iterable(values) -> tuple[np.ndarray, Index]:
+    from pandas import CategoricalIndex
+    if not is_list_like(values):
+        raise TypeError('Input must be list-like')
+    categories: Index
+    vdtype = getattr(values, 'dtype', None)
+    if isinstance(vdtype, CategoricalDtype):
+        values = extract_array(values)
+        cat_codes = np.arange(len(values.categories), dtype=values.codes.dtype)
+        cat = Categorical.from_codes(cat_codes, dtype=values.dtype, validate=False)
+        categories = CategoricalIndex(cat)
+        codes = values.codes
+    else:
+        cat = Categorical(values, ordered=False)
+        categories = cat.categories
+        codes = cat.codes
+    return (codes, categories)
+
+def factorize_from_iterables(iterables) -> tuple[list[np.ndarray], list[Index]]:
+    if len(iterables) == 0:
+        return ([], [])
+    (codes, categories) = zip(*(factorize_from_iterable(it) for it in iterables))
+    return (list(codes), list(categories))
+
+# File: pandas-main/pandas/core/arrays/datetimelike.py
+from __future__ import annotations
+from datetime import datetime, timedelta
+from functools import wraps
+import operator
+from typing import TYPE_CHECKING, Any, Literal, Union, cast, final, overload
+import warnings
+import numpy as np
+from pandas._config import using_string_dtype
+from pandas._config.config import get_option
+from pandas._libs import algos, lib
+from pandas._libs.tslibs import BaseOffset, IncompatibleFrequency, NaT, NaTType, Period, Resolution, Tick, Timedelta, Timestamp, add_overflowsafe, astype_overflowsafe, get_unit_from_dtype, iNaT, ints_to_pydatetime, ints_to_pytimedelta, periods_per_day, to_offset
+from pandas._libs.tslibs.fields import RoundTo, round_nsint64
+from pandas._libs.tslibs.np_datetime import compare_mismatched_resolutions
+from pandas._libs.tslibs.timedeltas import get_unit_for_round
+from pandas._libs.tslibs.timestamps import integer_op_not_supported
+from pandas._typing import ArrayLike, AxisInt, DatetimeLikeScalar, Dtype, DtypeObj, F, InterpolateOptions, NpDtype, PositionalIndexer2D, PositionalIndexerTuple, ScalarIndexer, Self, SequenceIndexer, TakeIndexer, TimeAmbiguous, TimeNonexistent, npt
+from pandas.compat.numpy import function as nv
+from pandas.errors import AbstractMethodError, InvalidComparison, PerformanceWarning
+from pandas.util._decorators import Appender, Substitution, cache_readonly
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
+from pandas.core.dtypes.common import is_all_strings, is_integer_dtype, is_list_like, is_object_dtype, is_string_dtype, pandas_dtype
+from pandas.core.dtypes.dtypes import ArrowDtype, CategoricalDtype, DatetimeTZDtype, ExtensionDtype, PeriodDtype
+from pandas.core.dtypes.generic import ABCCategorical, ABCMultiIndex
+from pandas.core.dtypes.missing import is_valid_na_for_dtype, isna
+from pandas.core import algorithms, missing, nanops, ops
+from pandas.core.algorithms import isin, map_array, unique1d
+from pandas.core.array_algos import datetimelike_accumulations
+from pandas.core.arraylike import OpsMixin
+from pandas.core.arrays._mixins import NDArrayBackedExtensionArray, ravel_compat
+from pandas.core.arrays.arrow.array import ArrowExtensionArray
+from pandas.core.arrays.base import ExtensionArray
+from pandas.core.arrays.integer import IntegerArray
+import pandas.core.common as com
+from pandas.core.construction import array as pd_array, ensure_wrapped_if_datetimelike, extract_array
+from pandas.core.indexers import check_array_indexer, check_setitem_lengths
+from pandas.core.ops.common import unpack_zerodim_and_defer
+from pandas.core.ops.invalid import invalid_comparison, make_invalid_op
+from pandas.tseries import frequencies
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator, Sequence
+    from pandas import Index
+    from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray
+DTScalarOrNaT = Union[DatetimeLikeScalar, NaTType]
+
+def _make_unpacked_invalid_op(op_name: str):
+    op = make_invalid_op(op_name)
+    return unpack_zerodim_and_defer(op_name)(op)
+
+def _period_dispatch(meth: F) -> F:
+
+    @wraps(meth)
+    def new_meth(self, *args, **kwargs):
+        if not isinstance(self.dtype, PeriodDtype):
+            return meth(self, *args, **kwargs)
+        arr = self.view('M8[ns]')
+        result = meth(arr, *args, **kwargs)
+        if result is NaT:
+            return NaT
+        elif isinstance(result, Timestamp):
+            return self._box_func(result._value)
+        res_i8 = result.view('i8')
+        return self._from_backing_data(res_i8)
+    return cast(F, new_meth)
+
+class DatetimeLikeArrayMixin(OpsMixin, NDArrayBackedExtensionArray):
+    _infer_matches: tuple[str, ...]
+    _is_recognized_dtype: Callable[[DtypeObj], bool]
+    _recognized_scalars: tuple[type, ...]
+    _ndarray: np.ndarray
+    freq: BaseOffset | None
+
+    @cache_readonly
+    def _can_hold_na(self) -> bool:
+        return True
+
+    def __init__(self, data, dtype: Dtype | None=None, freq=None, copy: bool=False) -> None:
+        raise AbstractMethodError(self)
+
+    @property
+    def _scalar_type(self) -> type[DatetimeLikeScalar]:
+        raise AbstractMethodError(self)
+
+    def _scalar_from_string(self, value: str) -> DTScalarOrNaT:
+        raise AbstractMethodError(self)
+
+    def _unbox_scalar(self, value: DTScalarOrNaT) -> np.int64 | np.datetime64 | np.timedelta64:
+        raise AbstractMethodError(self)
+
+    def _check_compatible_with(self, other: DTScalarOrNaT) -> None:
+        raise AbstractMethodError(self)
+
+    def _box_func(self, x):
+        raise AbstractMethodError(self)
+
+    def _box_values(self, values) -> np.ndarray:
+        return lib.map_infer(values, self._box_func, convert=False)
+
+    def __iter__(self) -> Iterator:
+        if self.ndim > 1:
+            return (self[n] for n in range(len(self)))
+        else:
+            return (self._box_func(v) for v in self.asi8)
+
+    @property
+    def asi8(self) -> npt.NDArray[np.int64]:
+        return self._ndarray.view('i8')
+
+    def _format_native_types(self, *, na_rep: str | float='NaT', date_format=None) -> npt.NDArray[np.object_]:
+        raise AbstractMethodError(self)
+
+    def _formatter(self, boxed: bool=False) -> Callable[[object], str]:
+        return "'{}'".format
+
+    def __array__(self, dtype: NpDtype | None=None, copy: bool | None=None) -> np.ndarray:
+        if is_object_dtype(dtype):
+            return np.array(list(self), dtype=object)
+        return self._ndarray
+
+    @overload
+    def __getitem__(self, key: ScalarIndexer) -> DTScalarOrNaT:
+        ...
+
+    @overload
+    def __getitem__(self, key: SequenceIndexer | PositionalIndexerTuple) -> Self:
+        ...
+
+    def __getitem__(self, key: PositionalIndexer2D) -> Self | DTScalarOrNaT:
+        result = cast('Union[Self, DTScalarOrNaT]', super().__getitem__(key))
+        if lib.is_scalar(result):
+            return result
+        else:
+            result = cast(Self, result)
+        result._freq = self._get_getitem_freq(key)
+        return result
+
+    def _get_getitem_freq(self, key) -> BaseOffset | None:
+        is_period = isinstance(self.dtype, PeriodDtype)
+        if is_period:
+            freq = self.freq
+        elif self.ndim != 1:
+            freq = None
+        else:
+            key = check_array_indexer(self, key)
+            freq = None
+            if isinstance(key, slice):
+                if self.freq is not None and key.step is not None:
+                    freq = key.step * self.freq
+                else:
+                    freq = self.freq
+            elif key is Ellipsis:
+                freq = self.freq
+            elif com.is_bool_indexer(key):
+                new_key = lib.maybe_booleans_to_slice(key.view(np.uint8))
+                if isinstance(new_key, slice):
+                    return self._get_getitem_freq(new_key)
+        return freq
+
+    def __setitem__(self, key: int | Sequence[int] | Sequence[bool] | slice, value: NaTType | Any | Sequence[Any]) -> None:
+        no_op = check_setitem_lengths(key, value, self)
+        super().__setitem__(key, value)
+        if no_op:
+            return
+        self._maybe_clear_freq()
+
+    def _maybe_clear_freq(self) -> None:
+        pass
+
+    def astype(self, dtype, copy: bool=True):
+        dtype = pandas_dtype(dtype)
+        if dtype == object:
+            if self.dtype.kind == 'M':
+                self = cast('DatetimeArray', self)
+                i8data = self.asi8
+                converted = ints_to_pydatetime(i8data, tz=self.tz, box='timestamp', reso=self._creso)
+                return converted
+            elif self.dtype.kind == 'm':
+                return ints_to_pytimedelta(self._ndarray, box=True)
+            return self._box_values(self.asi8.ravel()).reshape(self.shape)
+        elif isinstance(dtype, ExtensionDtype):
+            return super().astype(dtype, copy=copy)
+        elif is_string_dtype(dtype):
+            return self._format_native_types()
+        elif dtype.kind in 'iu':
+            values = self.asi8
+            if dtype != np.int64:
+                raise TypeError(f"Converting from {self.dtype} to {dtype} is not supported. Do obj.astype('int64').astype(dtype) instead")
+            if copy:
+                values = values.copy()
+            return values
+        elif dtype.kind in 'mM' and self.dtype != dtype or dtype.kind == 'f':
+            msg = f'Cannot cast {type(self).__name__} to dtype {dtype}'
+            raise TypeError(msg)
+        else:
+            return np.asarray(self, dtype=dtype)
+
+    @overload
+    def view(self) -> Self:
+        ...
+
+    @overload
+    def view(self, dtype: Literal['M8[ns]']) -> DatetimeArray:
+        ...
+
+    @overload
+    def view(self, dtype: Literal['m8[ns]']) -> TimedeltaArray:
+        ...
+
+    @overload
+    def view(self, dtype: Dtype | None=...) -> ArrayLike:
+        ...
+
+    def view(self, dtype: Dtype | None=None) -> ArrayLike:
+        return super().view(dtype)
+
+    def _validate_comparison_value(self, other):
+        if isinstance(other, str):
+            try:
+                other = self._scalar_from_string(other)
+            except (ValueError, IncompatibleFrequency) as err:
+                raise InvalidComparison(other) from err
+        if isinstance(other, self._recognized_scalars) or other is NaT:
+            other = self._scalar_type(other)
+            try:
+                self._check_compatible_with(other)
+            except (TypeError, IncompatibleFrequency) as err:
+                raise InvalidComparison(other) from err
+        elif not is_list_like(other):
+            raise InvalidComparison(other)
+        elif len(other) != len(self):
+            raise ValueError('Lengths must match')
+        else:
+            try:
+                other = self._validate_listlike(other, allow_object=True)
+                self._check_compatible_with(other)
+            except (TypeError, IncompatibleFrequency) as err:
+                if is_object_dtype(getattr(other, 'dtype', None)):
+                    pass
+                else:
+                    raise InvalidComparison(other) from err
+        return other
+
+    def _validate_scalar(self, value, *, allow_listlike: bool=False, unbox: bool=True):
+        if isinstance(value, self._scalar_type):
+            pass
+        elif isinstance(value, str):
+            try:
+                value = self._scalar_from_string(value)
+            except ValueError as err:
+                msg = self._validation_error_message(value, allow_listlike)
+                raise TypeError(msg) from err
+        elif is_valid_na_for_dtype(value, self.dtype):
+            value = NaT
+        elif isna(value):
+            msg = self._validation_error_message(value, allow_listlike)
+            raise TypeError(msg)
+        elif isinstance(value, self._recognized_scalars):
+            value = self._scalar_type(value)
+        else:
+            msg = self._validation_error_message(value, allow_listlike)
+            raise TypeError(msg)
+        if not unbox:
+            return value
+        return self._unbox_scalar(value)
+
+    def _validation_error_message(self, value, allow_listlike: bool=False) -> str:
+        if hasattr(value, 'dtype') and getattr(value, 'ndim', 0) > 0:
+            msg_got = f'{value.dtype} array'
+        else:
+            msg_got = f"'{type(value).__name__}'"
+        if allow_listlike:
+            msg = f"value should be a '{self._scalar_type.__name__}', 'NaT', or array of those. Got {msg_got} instead."
+        else:
+            msg = f"value should be a '{self._scalar_type.__name__}' or 'NaT'. Got {msg_got} instead."
+        return msg
+
+    def _validate_listlike(self, value, allow_object: bool=False):
+        if isinstance(value, type(self)):
+            if self.dtype.kind in 'mM' and (not allow_object) and (self.unit != value.unit):
+                value = value.as_unit(self.unit, round_ok=False)
+            return value
+        if isinstance(value, list) and len(value) == 0:
+            return type(self)._from_sequence([], dtype=self.dtype)
+        if hasattr(value, 'dtype') and value.dtype == object:
+            if lib.infer_dtype(value) in self._infer_matches:
+                try:
+                    value = type(self)._from_sequence(value)
+                except (ValueError, TypeError) as err:
+                    if allow_object:
+                        return value
+                    msg = self._validation_error_message(value, True)
+                    raise TypeError(msg) from err
+        value = extract_array(value, extract_numpy=True)
+        value = pd_array(value)
+        value = extract_array(value, extract_numpy=True)
+        if is_all_strings(value):
+            try:
+                value = type(self)._from_sequence(value, dtype=self.dtype)
+            except ValueError:
+                pass
+        if isinstance(value.dtype, CategoricalDtype):
+            if value.categories.dtype == self.dtype:
+                value = value._internal_get_values()
+                value = extract_array(value, extract_numpy=True)
+        if allow_object and is_object_dtype(value.dtype):
+            pass
+        elif not type(self)._is_recognized_dtype(value.dtype):
+            msg = self._validation_error_message(value, True)
+            raise TypeError(msg)
+        if self.dtype.kind in 'mM' and (not allow_object):
+            value = value.as_unit(self.unit, round_ok=False)
+        return value
+
+    def _validate_setitem_value(self, value):
+        if is_list_like(value):
+            value = self._validate_listlike(value)
+        else:
+            return self._validate_scalar(value, allow_listlike=True)
+        return self._unbox(value)
+
+    @final
+    def _unbox(self, other) -> np.int64 | np.datetime64 | np.timedelta64 | np.ndarray:
+        if lib.is_scalar(other):
+            other = self._unbox_scalar(other)
+        else:
+            self._check_compatible_with(other)
+            other = other._ndarray
+        return other
+
+    @ravel_compat
+    def map(self, mapper, na_action: Literal['ignore'] | None=None):
+        from pandas import Index
+        result = map_array(self, mapper, na_action=na_action)
+        result = Index(result)
+        if isinstance(result, ABCMultiIndex):
+            return result.to_numpy()
+        else:
+            return result.array
+
+    def isin(self, values: ArrayLike) -> npt.NDArray[np.bool_]:
+        if values.dtype.kind in 'fiuc':
+            return np.zeros(self.shape, dtype=bool)
+        values = ensure_wrapped_if_datetimelike(values)
+        if not isinstance(values, type(self)):
+            if values.dtype == object:
+                values = lib.maybe_convert_objects(values, convert_non_numeric=True, dtype_if_all_nat=self.dtype)
+                if values.dtype != object:
+                    return self.isin(values)
+                else:
+                    return isin(self.astype(object), values)
+            return np.zeros(self.shape, dtype=bool)
+        if self.dtype.kind in 'mM':
+            self = cast('DatetimeArray | TimedeltaArray', self)
+            values = values.as_unit(self.unit)
+        try:
+            self._check_compatible_with(values)
+        except (TypeError, ValueError):
+            return np.zeros(self.shape, dtype=bool)
+        return isin(self.asi8, values.asi8)
+
+    def isna(self) -> npt.NDArray[np.bool_]:
+        return self._isnan
+
+    @property
+    def _isnan(self) -> npt.NDArray[np.bool_]:
+        return self.asi8 == iNaT
+
+    @property
+    def _hasna(self) -> bool:
+        return bool(self._isnan.any())
+
+    def _maybe_mask_results(self, result: np.ndarray, fill_value=iNaT, convert=None) -> np.ndarray:
+        if self._hasna:
+            if convert:
+                result = result.astype(convert)
+            if fill_value is None:
+                fill_value = np.nan
+            np.putmask(result, self._isnan, fill_value)
+        return result
+
+    @property
+    def freqstr(self) -> str | None:
+        if self.freq is None:
+            return None
+        return self.freq.freqstr
+
+    @property
+    def inferred_freq(self) -> str | None:
+        if self.ndim != 1:
+            return None
+        try:
+            return frequencies.infer_freq(self)
+        except ValueError:
+            return None
+
+    @property
+    def _resolution_obj(self) -> Resolution | None:
+        freqstr = self.freqstr
+        if freqstr is None:
+            return None
+        try:
+            return Resolution.get_reso_from_freqstr(freqstr)
+        except KeyError:
+            return None
+
+    @property
+    def resolution(self) -> str:
+        return self._resolution_obj.attrname
+
+    @property
+    def _is_monotonic_increasing(self) -> bool:
+        return algos.is_monotonic(self.asi8, timelike=True)[0]
+
+    @property
+    def _is_monotonic_decreasing(self) -> bool:
+        return algos.is_monotonic(self.asi8, timelike=True)[1]
+
+    @property
+    def _is_unique(self) -> bool:
+        return len(unique1d(self.asi8.ravel('K'))) == self.size
+
+    def _cmp_method(self, other, op):
+        if self.ndim > 1 and getattr(other, 'shape', None) == self.shape:
+            return op(self.ravel(), other.ravel()).reshape(self.shape)
+        try:
+            other = self._validate_comparison_value(other)
+        except InvalidComparison:
+            return invalid_comparison(self, other, op)
+        dtype = getattr(other, 'dtype', None)
+        if is_object_dtype(dtype):
+            result = ops.comp_method_OBJECT_ARRAY(op, np.asarray(self.astype(object)), other)
+            return result
+        if other is NaT:
+            if op is operator.ne:
+                result = np.ones(self.shape, dtype=bool)
+            else:
+                result = np.zeros(self.shape, dtype=bool)
+            return result
+        if not isinstance(self.dtype, PeriodDtype):
+            self = cast(TimelikeOps, self)
+            if self._creso != other._creso:
+                if not isinstance(other, type(self)):
+                    try:
+                        other = other.as_unit(self.unit, round_ok=False)
+                    except ValueError:
+                        other_arr = np.array(other.asm8)
+                        return compare_mismatched_resolutions(self._ndarray, other_arr, op)
+                else:
+                    other_arr = other._ndarray
+                    return compare_mismatched_resolutions(self._ndarray, other_arr, op)
+        other_vals = self._unbox(other)
+        result = op(self._ndarray.view('i8'), other_vals.view('i8'))
+        o_mask = isna(other)
+        mask = self._isnan | o_mask
+        if mask.any():
+            nat_result = op is operator.ne
+            np.putmask(result, mask, nat_result)
+        return result
+    __pow__ = _make_unpacked_invalid_op('__pow__')
+    __rpow__ = _make_unpacked_invalid_op('__rpow__')
+    __mul__ = _make_unpacked_invalid_op('__mul__')
+    __rmul__ = _make_unpacked_invalid_op('__rmul__')
+    __truediv__ = _make_unpacked_invalid_op('__truediv__')
+    __rtruediv__ = _make_unpacked_invalid_op('__rtruediv__')
+    __floordiv__ = _make_unpacked_invalid_op('__floordiv__')
+    __rfloordiv__ = _make_unpacked_invalid_op('__rfloordiv__')
+    __mod__ = _make_unpacked_invalid_op('__mod__')
+    __rmod__ = _make_unpacked_invalid_op('__rmod__')
+    __divmod__ = _make_unpacked_invalid_op('__divmod__')
+    __rdivmod__ = _make_unpacked_invalid_op('__rdivmod__')
+
+    @final
+    def _get_i8_values_and_mask(self, other) -> tuple[int | npt.NDArray[np.int64], None | npt.NDArray[np.bool_]]:
+        if isinstance(other, Period):
+            i8values = other.ordinal
+            mask = None
+        elif isinstance(other, (Timestamp, Timedelta)):
+            i8values = other._value
+            mask = None
+        else:
+            mask = other._isnan
+            i8values = other.asi8
+        return (i8values, mask)
+
+    @final
+    def _get_arithmetic_result_freq(self, other) -> BaseOffset | None:
+        if isinstance(self.dtype, PeriodDtype):
+            return self.freq
+        elif not lib.is_scalar(other):
+            return None
+        elif isinstance(self.freq, Tick):
+            return self.freq
+        return None
+
+    @final
+    def _add_datetimelike_scalar(self, other) -> DatetimeArray:
+        if not lib.is_np_dtype(self.dtype, 'm'):
+            raise TypeError(f'cannot add {type(self).__name__} and {type(other).__name__}')
+        self = cast('TimedeltaArray', self)
+        from pandas.core.arrays import DatetimeArray
+        from pandas.core.arrays.datetimes import tz_to_dtype
+        assert other is not NaT
+        if isna(other):
+            result = self._ndarray + NaT.to_datetime64().astype(f'M8[{self.unit}]')
+            return DatetimeArray._simple_new(result, dtype=result.dtype)
+        other = Timestamp(other)
+        (self, other) = self._ensure_matching_resos(other)
+        self = cast('TimedeltaArray', self)
+        (other_i8, o_mask) = self._get_i8_values_and_mask(other)
+        result = add_overflowsafe(self.asi8, np.asarray(other_i8, dtype='i8'))
+        res_values = result.view(f'M8[{self.unit}]')
+        dtype = tz_to_dtype(tz=other.tz, unit=self.unit)
+        res_values = result.view(f'M8[{self.unit}]')
+        new_freq = self._get_arithmetic_result_freq(other)
+        return DatetimeArray._simple_new(res_values, dtype=dtype, freq=new_freq)
+
+    @final
+    def _add_datetime_arraylike(self, other: DatetimeArray) -> DatetimeArray:
+        if not lib.is_np_dtype(self.dtype, 'm'):
+            raise TypeError(f'cannot add {type(self).__name__} and {type(other).__name__}')
+        return other + self
+
+    @final
+    def _sub_datetimelike_scalar(self, other: datetime | np.datetime64) -> TimedeltaArray:
+        if self.dtype.kind != 'M':
+            raise TypeError(f'cannot subtract a datelike from a {type(self).__name__}')
+        self = cast('DatetimeArray', self)
+        if isna(other):
+            return self - NaT
+        ts = Timestamp(other)
+        (self, ts) = self._ensure_matching_resos(ts)
+        return self._sub_datetimelike(ts)
+
+    @final
+    def _sub_datetime_arraylike(self, other: DatetimeArray) -> TimedeltaArray:
+        if self.dtype.kind != 'M':
+            raise TypeError(f'cannot subtract a datelike from a {type(self).__name__}')
+        if len(self) != len(other):
+            raise ValueError('cannot add indices of unequal length')
+        self = cast('DatetimeArray', self)
+        (self, other) = self._ensure_matching_resos(other)
+        return self._sub_datetimelike(other)
+
+    @final
+    def _sub_datetimelike(self, other: Timestamp | DatetimeArray) -> TimedeltaArray:
+        self = cast('DatetimeArray', self)
+        from pandas.core.arrays import TimedeltaArray
+        try:
+            self._assert_tzawareness_compat(other)
+        except TypeError as err:
+            new_message = str(err).replace('compare', 'subtract')
+            raise type(err)(new_message) from err
+        (other_i8, o_mask) = self._get_i8_values_and_mask(other)
+        res_values = add_overflowsafe(self.asi8, np.asarray(-other_i8, dtype='i8'))
+        res_m8 = res_values.view(f'timedelta64[{self.unit}]')
+        new_freq = self._get_arithmetic_result_freq(other)
+        new_freq = cast('Tick | None', new_freq)
+        return TimedeltaArray._simple_new(res_m8, dtype=res_m8.dtype, freq=new_freq)
+
+    @final
+    def _add_period(self, other: Period) -> PeriodArray:
+        if not lib.is_np_dtype(self.dtype, 'm'):
+            raise TypeError(f'cannot add Period to a {type(self).__name__}')
+        from pandas.core.arrays.period import PeriodArray
+        i8vals = np.broadcast_to(other.ordinal, self.shape)
+        dtype = PeriodDtype(other.freq)
+        parr = PeriodArray(i8vals, dtype=dtype)
+        return parr + self
+
+    def _add_offset(self, offset):
+        raise AbstractMethodError(self)
+
+    def _add_timedeltalike_scalar(self, other):
+        if isna(other):
+            new_values = np.empty(self.shape, dtype='i8').view(self._ndarray.dtype)
+            new_values.fill(iNaT)
+            return type(self)._simple_new(new_values, dtype=self.dtype)
+        self = cast('DatetimeArray | TimedeltaArray', self)
+        other = Timedelta(other)
+        (self, other) = self._ensure_matching_resos(other)
+        return self._add_timedeltalike(other)
+
+    def _add_timedelta_arraylike(self, other: TimedeltaArray) -> Self:
+        if len(self) != len(other):
+            raise ValueError('cannot add indices of unequal length')
+        (self, other) = cast('DatetimeArray | TimedeltaArray', self)._ensure_matching_resos(other)
+        return self._add_timedeltalike(other)
+
+    @final
+    def _add_timedeltalike(self, other: Timedelta | TimedeltaArray) -> Self:
+        (other_i8, o_mask) = self._get_i8_values_and_mask(other)
+        new_values = add_overflowsafe(self.asi8, np.asarray(other_i8, dtype='i8'))
+        res_values = new_values.view(self._ndarray.dtype)
+        new_freq = self._get_arithmetic_result_freq(other)
+        return type(self)._simple_new(res_values, dtype=self.dtype, freq=new_freq)
+
+    @final
+    def _add_nat(self) -> Self:
+        if isinstance(self.dtype, PeriodDtype):
+            raise TypeError(f'Cannot add {type(self).__name__} and {type(NaT).__name__}')
+        result = np.empty(self.shape, dtype=np.int64)
+        result.fill(iNaT)
+        result = result.view(self._ndarray.dtype)
+        return type(self)._simple_new(result, dtype=self.dtype, freq=None)
+
+    @final
+    def _sub_nat(self) -> np.ndarray:
+        result = np.empty(self.shape, dtype=np.int64)
+        result.fill(iNaT)
+        if self.dtype.kind in 'mM':
+            self = cast('DatetimeArray| TimedeltaArray', self)
+            return result.view(f'timedelta64[{self.unit}]')
+        else:
+            return result.view('timedelta64[ns]')
+
+    @final
+    def _sub_periodlike(self, other: Period | PeriodArray) -> npt.NDArray[np.object_]:
+        if not isinstance(self.dtype, PeriodDtype):
+            raise TypeError(f'cannot subtract {type(other).__name__} from {type(self).__name__}')
+        self = cast('PeriodArray', self)
+        self._check_compatible_with(other)
+        (other_i8, o_mask) = self._get_i8_values_and_mask(other)
+        new_i8_data = add_overflowsafe(self.asi8, np.asarray(-other_i8, dtype='i8'))
+        new_data = np.array([self.freq.base * x for x in new_i8_data])
+        if o_mask is None:
+            mask = self._isnan
+        else:
+            mask = self._isnan | o_mask
+        new_data[mask] = NaT
+        return new_data
+
+    @final
+    def _addsub_object_array(self, other: npt.NDArray[np.object_], op) -> np.ndarray:
+        assert op in [operator.add, operator.sub]
+        if len(other) == 1 and self.ndim == 1:
+            return op(self, other[0])
+        if get_option('performance_warnings'):
+            warnings.warn(f'Adding/subtracting object-dtype array to {type(self).__name__} not vectorized.', PerformanceWarning, stacklevel=find_stack_level())
+        assert self.shape == other.shape, (self.shape, other.shape)
+        res_values = op(self.astype('O'), np.asarray(other))
+        return res_values
+
+    def _accumulate(self, name: str, *, skipna: bool=True, **kwargs) -> Self:
+        if name not in {'cummin', 'cummax'}:
+            raise TypeError(f'Accumulation {name} not supported for {type(self)}')
+        op = getattr(datetimelike_accumulations, name)
+        result = op(self.copy(), skipna=skipna, **kwargs)
+        return type(self)._simple_new(result, dtype=self.dtype)
+
+    @unpack_zerodim_and_defer('__add__')
+    def __add__(self, other):
+        other_dtype = getattr(other, 'dtype', None)
+        other = ensure_wrapped_if_datetimelike(other)
+        if other is NaT:
+            result: np.ndarray | DatetimeLikeArrayMixin = self._add_nat()
+        elif isinstance(other, (Tick, timedelta, np.timedelta64)):
+            result = self._add_timedeltalike_scalar(other)
+        elif isinstance(other, BaseOffset):
+            result = self._add_offset(other)
+        elif isinstance(other, (datetime, np.datetime64)):
+            result = self._add_datetimelike_scalar(other)
+        elif isinstance(other, Period) and lib.is_np_dtype(self.dtype, 'm'):
+            result = self._add_period(other)
+        elif lib.is_integer(other):
+            if not isinstance(self.dtype, PeriodDtype):
+                raise integer_op_not_supported(self)
+            obj = cast('PeriodArray', self)
+            result = obj._addsub_int_array_or_scalar(other * obj.dtype._n, operator.add)
+        elif lib.is_np_dtype(other_dtype, 'm'):
+            result = self._add_timedelta_arraylike(other)
+        elif is_object_dtype(other_dtype):
+            result = self._addsub_object_array(other, operator.add)
+        elif lib.is_np_dtype(other_dtype, 'M') or isinstance(other_dtype, DatetimeTZDtype):
+            return self._add_datetime_arraylike(other)
+        elif is_integer_dtype(other_dtype):
+            if not isinstance(self.dtype, PeriodDtype):
+                raise integer_op_not_supported(self)
+            obj = cast('PeriodArray', self)
+            result = obj._addsub_int_array_or_scalar(other * obj.dtype._n, operator.add)
+        else:
+            return NotImplemented
+        if isinstance(result, np.ndarray) and lib.is_np_dtype(result.dtype, 'm'):
+            from pandas.core.arrays import TimedeltaArray
+            return TimedeltaArray._from_sequence(result)
+        return result
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    @unpack_zerodim_and_defer('__sub__')
+    def __sub__(self, other):
+        other_dtype = getattr(other, 'dtype', None)
+        other = ensure_wrapped_if_datetimelike(other)
+        if other is NaT:
+            result: np.ndarray | DatetimeLikeArrayMixin = self._sub_nat()
+        elif isinstance(other, (Tick, timedelta, np.timedelta64)):
+            result = self._add_timedeltalike_scalar(-other)
+        elif isinstance(other, BaseOffset):
+            result = self._add_offset(-other)
+        elif isinstance(other, (datetime, np.datetime64)):
+            result = self._sub_datetimelike_scalar(other)
+        elif lib.is_integer(other):
+            if not isinstance(self.dtype, PeriodDtype):
+                raise integer_op_not_supported(self)
+            obj = cast('PeriodArray', self)
+            result = obj._addsub_int_array_or_scalar(other * obj.dtype._n, operator.sub)
+        elif isinstance(other, Period):
+            result = self._sub_periodlike(other)
+        elif lib.is_np_dtype(other_dtype, 'm'):
+            result = self._add_timedelta_arraylike(-other)
+        elif is_object_dtype(other_dtype):
+            result = self._addsub_object_array(other, operator.sub)
+        elif lib.is_np_dtype(other_dtype, 'M') or isinstance(other_dtype, DatetimeTZDtype):
+            result = self._sub_datetime_arraylike(other)
+        elif isinstance(other_dtype, PeriodDtype):
+            result = self._sub_periodlike(other)
+        elif is_integer_dtype(other_dtype):
+            if not isinstance(self.dtype, PeriodDtype):
+                raise integer_op_not_supported(self)
+            obj = cast('PeriodArray', self)
+            result = obj._addsub_int_array_or_scalar(other * obj.dtype._n, operator.sub)
+        else:
+            return NotImplemented
+        if isinstance(result, np.ndarray) and lib.is_np_dtype(result.dtype, 'm'):
+            from pandas.core.arrays import TimedeltaArray
+            return TimedeltaArray._from_sequence(result)
+        return result
+
+    def __rsub__(self, other):
+        other_dtype = getattr(other, 'dtype', None)
+        other_is_dt64 = lib.is_np_dtype(other_dtype, 'M') or isinstance(other_dtype, DatetimeTZDtype)
+        if other_is_dt64 and lib.is_np_dtype(self.dtype, 'm'):
+            if lib.is_scalar(other):
+                return Timestamp(other) - self
+            if not isinstance(other, DatetimeLikeArrayMixin):
+                from pandas.core.arrays import DatetimeArray
+                other = DatetimeArray._from_sequence(other)
+            return other - self
+        elif self.dtype.kind == 'M' and hasattr(other, 'dtype') and (not other_is_dt64):
+            raise TypeError(f'cannot subtract {type(self).__name__} from {type(other).__name__}')
+        elif isinstance(self.dtype, PeriodDtype) and lib.is_np_dtype(other_dtype, 'm'):
+            raise TypeError(f'cannot subtract {type(self).__name__} from {other.dtype}')
+        elif lib.is_np_dtype(self.dtype, 'm'):
+            self = cast('TimedeltaArray', self)
+            return -self + other
+        return -(self - other)
+
+    def __iadd__(self, other) -> Self:
+        result = self + other
+        self[:] = result[:]
+        if not isinstance(self.dtype, PeriodDtype):
+            self._freq = result.freq
+        return self
+
+    def __isub__(self, other) -> Self:
+        result = self - other
+        self[:] = result[:]
+        if not isinstance(self.dtype, PeriodDtype):
+            self._freq = result.freq
+        return self
+
+    @_period_dispatch
+    def _quantile(self, qs: npt.NDArray[np.float64], interpolation: str) -> Self:
+        return super()._quantile(qs=qs, interpolation=interpolation)
+
+    @_period_dispatch
+    def min(self, *, axis: AxisInt | None=None, skipna: bool=True, **kwargs):
+        nv.validate_min((), kwargs)
+        nv.validate_minmax_axis(axis, self.ndim)
+        result = nanops.nanmin(self._ndarray, axis=axis, skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    @_period_dispatch
+    def max(self, *, axis: AxisInt | None=None, skipna: bool=True, **kwargs):
+        nv.validate_max((), kwargs)
+        nv.validate_minmax_axis(axis, self.ndim)
+        result = nanops.nanmax(self._ndarray, axis=axis, skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def mean(self, *, skipna: bool=True, axis: AxisInt | None=0):
+        if isinstance(self.dtype, PeriodDtype):
+            raise TypeError(f"mean is not implemented for {type(self).__name__} since the meaning is ambiguous.  An alternative is obj.to_timestamp(how='start').mean()")
+        result = nanops.nanmean(self._ndarray, axis=axis, skipna=skipna, mask=self.isna())
+        return self._wrap_reduction_result(axis, result)
+
+    @_period_dispatch
+    def median(self, *, axis: AxisInt | None=None, skipna: bool=True, **kwargs):
+        nv.validate_median((), kwargs)
+        if axis is not None and abs(axis) >= self.ndim:
+            raise ValueError('abs(axis) must be less than ndim')
+        result = nanops.nanmedian(self._ndarray, axis=axis, skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def _mode(self, dropna: bool=True):
+        mask = None
+        if dropna:
+            mask = self.isna()
+        i8modes = algorithms.mode(self.view('i8'), mask=mask)
+        npmodes = i8modes.view(self._ndarray.dtype)
+        npmodes = cast(np.ndarray, npmodes)
+        return self._from_backing_data(npmodes)
+
+    def _groupby_op(self, *, how: str, has_dropped_na: bool, min_count: int, ngroups: int, ids: npt.NDArray[np.intp], **kwargs):
+        dtype = self.dtype
+        if dtype.kind == 'M':
+            if how in ['sum', 'prod', 'cumsum', 'cumprod', 'var', 'skew']:
+                raise TypeError(f"datetime64 type does not support operation '{how}'")
+            if how in ['any', 'all']:
+                raise TypeError(f"'{how}' with datetime64 dtypes is no longer supported. Use (obj != pd.Timestamp(0)).{how}() instead.")
+        elif isinstance(dtype, PeriodDtype):
+            if how in ['sum', 'prod', 'cumsum', 'cumprod', 'var', 'skew']:
+                raise TypeError(f'Period type does not support {how} operations')
+            if how in ['any', 'all']:
+                raise TypeError(f"'{how}' with PeriodDtype is no longer supported. Use (obj != pd.Period(0, freq)).{how}() instead.")
+        elif how in ['prod', 'cumprod', 'skew', 'var']:
+            raise TypeError(f'timedelta64 type does not support {how} operations')
+        npvalues = self._ndarray.view('M8[ns]')
+        from pandas.core.groupby.ops import WrappedCythonOp
+        kind = WrappedCythonOp.get_kind_from_how(how)
+        op = WrappedCythonOp(how=how, kind=kind, has_dropped_na=has_dropped_na)
+        res_values = op._cython_op_ndim_compat(npvalues, min_count=min_count, ngroups=ngroups, comp_ids=ids, mask=None, **kwargs)
+        if op.how in op.cast_blocklist:
+            return res_values
+        assert res_values.dtype == 'M8[ns]'
+        if how in ['std', 'sem']:
+            from pandas.core.arrays import TimedeltaArray
+            if isinstance(self.dtype, PeriodDtype):
+                raise TypeError("'std' and 'sem' are not valid for PeriodDtype")
+            self = cast('DatetimeArray | TimedeltaArray', self)
+            new_dtype = f'm8[{self.unit}]'
+            res_values = res_values.view(new_dtype)
+            return TimedeltaArray._simple_new(res_values, dtype=res_values.dtype)
+        res_values = res_values.view(self._ndarray.dtype)
+        return self._from_backing_data(res_values)
+
+class DatelikeOps(DatetimeLikeArrayMixin):
+
+    @Substitution(URL='https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior')
+    def strftime(self, date_format: str) -> npt.NDArray[np.object_]:
+        result = self._format_native_types(date_format=date_format, na_rep=np.nan)
+        if using_string_dtype():
+            from pandas import StringDtype
+            return pd_array(result, dtype=StringDtype(na_value=np.nan))
+        return result.astype(object, copy=False)
+_round_doc = '\n    Perform {op} operation on the data to the specified `freq`.\n\n    Parameters\n    ----------\n    freq : str or Offset\n        The frequency level to {op} the index to. Must be a fixed\n        frequency like \'s\' (second) not \'ME\' (month end). See\n        :ref:`frequency aliases <timeseries.offset_aliases>` for\n        a list of possible `freq` values.\n    ambiguous : \'infer\', bool-ndarray, \'NaT\', default \'raise\'\n        Only relevant for DatetimeIndex:\n\n        - \'infer\' will attempt to infer fall dst-transition hours based on\n          order\n        - bool-ndarray where True signifies a DST time, False designates\n          a non-DST time (note that this flag is only applicable for\n          ambiguous times)\n        - \'NaT\' will return NaT where there are ambiguous times\n        - \'raise\' will raise a ValueError if there are ambiguous\n          times.\n\n    nonexistent : \'shift_forward\', \'shift_backward\', \'NaT\', timedelta, default \'raise\'\n        A nonexistent time does not exist in a particular timezone\n        where clocks moved forward due to DST.\n\n        - \'shift_forward\' will shift the nonexistent time forward to the\n          closest existing time\n        - \'shift_backward\' will shift the nonexistent time backward to the\n          closest existing time\n        - \'NaT\' will return NaT where there are nonexistent times\n        - timedelta objects will shift nonexistent times by the timedelta\n        - \'raise\' will raise a ValueError if there are\n          nonexistent times.\n\n    Returns\n    -------\n    DatetimeIndex, TimedeltaIndex, or Series\n        Index of the same type for a DatetimeIndex or TimedeltaIndex,\n        or a Series with the same index for a Series.\n\n    Raises\n    ------\n    ValueError if the `freq` cannot be converted.\n\n    See Also\n    --------\n    DatetimeIndex.floor : Perform floor operation on the data to the specified `freq`.\n    DatetimeIndex.snap : Snap time stamps to nearest occurring frequency.\n\n    Notes\n    -----\n    If the timestamps have a timezone, {op}ing will take place relative to the\n    local ("wall") time and re-localized to the same timezone. When {op}ing\n    near daylight savings time, use ``nonexistent`` and ``ambiguous`` to\n    control the re-localization behavior.\n\n    Examples\n    --------\n    **DatetimeIndex**\n\n    >>> rng = pd.date_range(\'1/1/2018 11:59:00\', periods=3, freq=\'min\')\n    >>> rng\n    DatetimeIndex([\'2018-01-01 11:59:00\', \'2018-01-01 12:00:00\',\n                   \'2018-01-01 12:01:00\'],\n                  dtype=\'datetime64[ns]\', freq=\'min\')\n    '
+_round_example = '>>> rng.round(\'h\')\n    DatetimeIndex([\'2018-01-01 12:00:00\', \'2018-01-01 12:00:00\',\n                   \'2018-01-01 12:00:00\'],\n                  dtype=\'datetime64[ns]\', freq=None)\n\n    **Series**\n\n    >>> pd.Series(rng).dt.round("h")\n    0   2018-01-01 12:00:00\n    1   2018-01-01 12:00:00\n    2   2018-01-01 12:00:00\n    dtype: datetime64[ns]\n\n    When rounding near a daylight savings time transition, use ``ambiguous`` or\n    ``nonexistent`` to control how the timestamp should be re-localized.\n\n    >>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")\n\n    >>> rng_tz.floor("2h", ambiguous=False)\n    DatetimeIndex([\'2021-10-31 02:00:00+01:00\'],\n                  dtype=\'datetime64[s, Europe/Amsterdam]\', freq=None)\n\n    >>> rng_tz.floor("2h", ambiguous=True)\n    DatetimeIndex([\'2021-10-31 02:00:00+02:00\'],\n                  dtype=\'datetime64[s, Europe/Amsterdam]\', freq=None)\n    '
+_floor_example = '>>> rng.floor(\'h\')\n    DatetimeIndex([\'2018-01-01 11:00:00\', \'2018-01-01 12:00:00\',\n                   \'2018-01-01 12:00:00\'],\n                  dtype=\'datetime64[ns]\', freq=None)\n\n    **Series**\n\n    >>> pd.Series(rng).dt.floor("h")\n    0   2018-01-01 11:00:00\n    1   2018-01-01 12:00:00\n    2   2018-01-01 12:00:00\n    dtype: datetime64[ns]\n\n    When rounding near a daylight savings time transition, use ``ambiguous`` or\n    ``nonexistent`` to control how the timestamp should be re-localized.\n\n    >>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")\n\n    >>> rng_tz.floor("2h", ambiguous=False)\n    DatetimeIndex([\'2021-10-31 02:00:00+01:00\'],\n                 dtype=\'datetime64[s, Europe/Amsterdam]\', freq=None)\n\n    >>> rng_tz.floor("2h", ambiguous=True)\n    DatetimeIndex([\'2021-10-31 02:00:00+02:00\'],\n                  dtype=\'datetime64[s, Europe/Amsterdam]\', freq=None)\n    '
+_ceil_example = '>>> rng.ceil(\'h\')\n    DatetimeIndex([\'2018-01-01 12:00:00\', \'2018-01-01 12:00:00\',\n                   \'2018-01-01 13:00:00\'],\n                  dtype=\'datetime64[ns]\', freq=None)\n\n    **Series**\n\n    >>> pd.Series(rng).dt.ceil("h")\n    0   2018-01-01 12:00:00\n    1   2018-01-01 12:00:00\n    2   2018-01-01 13:00:00\n    dtype: datetime64[ns]\n\n    When rounding near a daylight savings time transition, use ``ambiguous`` or\n    ``nonexistent`` to control how the timestamp should be re-localized.\n\n    >>> rng_tz = pd.DatetimeIndex(["2021-10-31 01:30:00"], tz="Europe/Amsterdam")\n\n    >>> rng_tz.ceil("h", ambiguous=False)\n    DatetimeIndex([\'2021-10-31 02:00:00+01:00\'],\n                  dtype=\'datetime64[s, Europe/Amsterdam]\', freq=None)\n\n    >>> rng_tz.ceil("h", ambiguous=True)\n    DatetimeIndex([\'2021-10-31 02:00:00+02:00\'],\n                  dtype=\'datetime64[s, Europe/Amsterdam]\', freq=None)\n    '
+
+class TimelikeOps(DatetimeLikeArrayMixin):
+
+    @classmethod
+    def _validate_dtype(cls, values, dtype):
+        raise AbstractMethodError(cls)
+
+    @property
+    def freq(self):
+        return self._freq
+
+    @freq.setter
+    def freq(self, value) -> None:
+        if value is not None:
+            value = to_offset(value)
+            self._validate_frequency(self, value)
+            if self.dtype.kind == 'm' and (not isinstance(value, Tick)):
+                raise TypeError('TimedeltaArray/Index freq must be a Tick')
+            if self.ndim > 1:
+                raise ValueError('Cannot set freq with ndim > 1')
+        self._freq = value
+
+    @final
+    def _maybe_pin_freq(self, freq, validate_kwds: dict) -> None:
+        if freq is None:
+            self._freq = None
+        elif freq == 'infer':
+            if self._freq is None:
+                self._freq = to_offset(self.inferred_freq)
+        elif freq is lib.no_default:
+            pass
+        elif self._freq is None:
+            freq = to_offset(freq)
+            type(self)._validate_frequency(self, freq, **validate_kwds)
+            self._freq = freq
+        else:
+            freq = to_offset(freq)
+            _validate_inferred_freq(freq, self._freq)
+
+    @final
+    @classmethod
+    def _validate_frequency(cls, index, freq: BaseOffset, **kwargs) -> None:
+        inferred = index.inferred_freq
+        if index.size == 0 or inferred == freq.freqstr:
+            return None
+        try:
+            on_freq = cls._generate_range(start=index[0], end=None, periods=len(index), freq=freq, unit=index.unit, **kwargs)
+            if not np.array_equal(index.asi8, on_freq.asi8):
+                raise ValueError
+        except ValueError as err:
+            if 'non-fixed' in str(err):
+                raise err
+            raise ValueError(f'Inferred frequency {inferred} from passed values does not conform to passed frequency {freq.freqstr}') from err
+
+    @classmethod
+    def _generate_range(cls, start, end, periods: int | None, freq, *args, **kwargs) -> Self:
+        raise AbstractMethodError(cls)
+
+    @cache_readonly
+    def _creso(self) -> int:
+        return get_unit_from_dtype(self._ndarray.dtype)
+
+    @cache_readonly
+    def unit(self) -> str:
+        return dtype_to_unit(self.dtype)
+
+    def as_unit(self, unit: str, round_ok: bool=True) -> Self:
+        if unit not in ['s', 'ms', 'us', 'ns']:
+            raise ValueError("Supported units are 's', 'ms', 'us', 'ns'")
+        dtype = np.dtype(f'{self.dtype.kind}8[{unit}]')
+        new_values = astype_overflowsafe(self._ndarray, dtype, round_ok=round_ok)
+        if isinstance(self.dtype, np.dtype):
+            new_dtype = new_values.dtype
+        else:
+            tz = cast('DatetimeArray', self).tz
+            new_dtype = DatetimeTZDtype(tz=tz, unit=unit)
+        return type(self)._simple_new(new_values, dtype=new_dtype, freq=self.freq)
+
+    def _ensure_matching_resos(self, other):
+        if self._creso != other._creso:
+            if self._creso < other._creso:
+                self = self.as_unit(other.unit)
+            else:
+                other = other.as_unit(self.unit)
+        return (self, other)
+
+    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
+        if ufunc in [np.isnan, np.isinf, np.isfinite] and len(inputs) == 1 and (inputs[0] is self):
+            return getattr(ufunc, method)(self._ndarray, **kwargs)
+        return super().__array_ufunc__(ufunc, method, *inputs, **kwargs)
+
+    def _round(self, freq, mode, ambiguous, nonexistent):
+        if isinstance(self.dtype, DatetimeTZDtype):
+            self = cast('DatetimeArray', self)
+            naive = self.tz_localize(None)
+            result = naive._round(freq, mode, ambiguous, nonexistent)
+            return result.tz_localize(self.tz, ambiguous=ambiguous, nonexistent=nonexistent)
+        values = self.view('i8')
+        values = cast(np.ndarray, values)
+        nanos = get_unit_for_round(freq, self._creso)
+        if nanos == 0:
+            return self.copy()
+        result_i8 = round_nsint64(values, mode, nanos)
+        result = self._maybe_mask_results(result_i8, fill_value=iNaT)
+        result = result.view(self._ndarray.dtype)
+        return self._simple_new(result, dtype=self.dtype)
+
+    @Appender((_round_doc + _round_example).format(op='round'))
+    def round(self, freq, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise') -> Self:
+        return self._round(freq, RoundTo.NEAREST_HALF_EVEN, ambiguous, nonexistent)
+
+    @Appender((_round_doc + _floor_example).format(op='floor'))
+    def floor(self, freq, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise') -> Self:
+        return self._round(freq, RoundTo.MINUS_INFTY, ambiguous, nonexistent)
+
+    @Appender((_round_doc + _ceil_example).format(op='ceil'))
+    def ceil(self, freq, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise') -> Self:
+        return self._round(freq, RoundTo.PLUS_INFTY, ambiguous, nonexistent)
+
+    def any(self, *, axis: AxisInt | None=None, skipna: bool=True) -> bool:
+        return nanops.nanany(self._ndarray, axis=axis, skipna=skipna, mask=self.isna())
+
+    def all(self, *, axis: AxisInt | None=None, skipna: bool=True) -> bool:
+        return nanops.nanall(self._ndarray, axis=axis, skipna=skipna, mask=self.isna())
+
+    def _maybe_clear_freq(self) -> None:
+        self._freq = None
+
+    def _with_freq(self, freq) -> Self:
+        if freq is None:
+            pass
+        elif len(self) == 0 and isinstance(freq, BaseOffset):
+            if self.dtype.kind == 'm' and (not isinstance(freq, Tick)):
+                raise TypeError('TimedeltaArray/Index freq must be a Tick')
+        else:
+            assert freq == 'infer'
+            freq = to_offset(self.inferred_freq)
+        arr = self.view()
+        arr._freq = freq
+        return arr
+
+    def _values_for_json(self) -> np.ndarray:
+        if isinstance(self.dtype, np.dtype):
+            return self._ndarray
+        return super()._values_for_json()
+
+    def factorize(self, use_na_sentinel: bool=True, sort: bool=False):
+        if self.freq is not None:
+            if sort and self.freq.n < 0:
+                codes = np.arange(len(self) - 1, -1, -1, dtype=np.intp)
+                uniques = self[::-1]
+            else:
+                codes = np.arange(len(self), dtype=np.intp)
+                uniques = self.copy()
+            return (codes, uniques)
+        if sort:
+            raise NotImplementedError(f"The 'sort' keyword in {type(self).__name__}.factorize is ignored unless arr.freq is not None. To factorize with sort, call pd.factorize(obj, sort=True) instead.")
+        return super().factorize(use_na_sentinel=use_na_sentinel)
+
+    @classmethod
+    def _concat_same_type(cls, to_concat: Sequence[Self], axis: AxisInt=0) -> Self:
+        new_obj = super()._concat_same_type(to_concat, axis)
+        obj = to_concat[0]
+        if axis == 0:
+            to_concat = [x for x in to_concat if len(x)]
+            if obj.freq is not None and all((x.freq == obj.freq for x in to_concat)):
+                pairs = zip(to_concat[:-1], to_concat[1:])
+                if all((pair[0][-1] + obj.freq == pair[1][0] for pair in pairs)):
+                    new_freq = obj.freq
+                    new_obj._freq = new_freq
+        return new_obj
+
+    def copy(self, order: str='C') -> Self:
+        new_obj = super().copy(order=order)
+        new_obj._freq = self.freq
+        return new_obj
+
+    def interpolate(self, *, method: InterpolateOptions, axis: int, index: Index, limit, limit_direction, limit_area, copy: bool, **kwargs) -> Self:
+        if method != 'linear':
+            raise NotImplementedError
+        if not copy:
+            out_data = self._ndarray
+        else:
+            out_data = self._ndarray.copy()
+        missing.interpolate_2d_inplace(out_data, method=method, axis=axis, index=index, limit=limit, limit_direction=limit_direction, limit_area=limit_area, **kwargs)
+        if not copy:
+            return self
+        return type(self)._simple_new(out_data, dtype=self.dtype)
+
+    def take(self, indices: TakeIndexer, *, allow_fill: bool=False, fill_value: Any=None, axis: AxisInt=0) -> Self:
+        result = super().take(indices=indices, allow_fill=allow_fill, fill_value=fill_value, axis=axis)
+        indices = np.asarray(indices, dtype=np.intp)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(self))
+        if isinstance(maybe_slice, slice):
+            freq = self._get_getitem_freq(maybe_slice)
+            result._freq = freq
+        return result
+
+    @property
+    def _is_dates_only(self) -> bool:
+        if not lib.is_np_dtype(self.dtype):
+            return False
+        values_int = self.asi8
+        consider_values = values_int != iNaT
+        reso = get_unit_from_dtype(self.dtype)
+        ppd = periods_per_day(reso)
+        even_days = np.logical_and(consider_values, values_int % ppd != 0).sum() == 0
+        return even_days
+
+def ensure_arraylike_for_datetimelike(data, copy: bool, cls_name: str) -> tuple[ArrayLike, bool]:
+    if not hasattr(data, 'dtype'):
+        if not isinstance(data, (list, tuple)) and np.ndim(data) == 0:
+            data = list(data)
+        data = construct_1d_object_array_from_listlike(data)
+        copy = False
+    elif isinstance(data, ABCMultiIndex):
+        raise TypeError(f'Cannot create a {cls_name} from a MultiIndex.')
+    else:
+        data = extract_array(data, extract_numpy=True)
+    if isinstance(data, IntegerArray) or (isinstance(data, ArrowExtensionArray) and data.dtype.kind in 'iu'):
+        data = data.to_numpy('int64', na_value=iNaT)
+        copy = False
+    elif isinstance(data, ArrowExtensionArray):
+        data = data._maybe_convert_datelike_array()
+        data = data.to_numpy()
+        copy = False
+    elif not isinstance(data, (np.ndarray, ExtensionArray)):
+        data = np.asarray(data)
+    elif isinstance(data, ABCCategorical):
+        data = data.categories.take(data.codes, fill_value=NaT)._values
+        copy = False
+    return (data, copy)
+
+@overload
+def validate_periods(periods: None) -> None:
+    ...
+
+@overload
+def validate_periods(periods: int) -> int:
+    ...
+
+def validate_periods(periods: int | None) -> int | None:
+    if periods is not None and (not lib.is_integer(periods)):
+        raise TypeError(f'periods must be an integer, got {periods}')
+    return periods
+
+def _validate_inferred_freq(freq: BaseOffset | None, inferred_freq: BaseOffset | None) -> BaseOffset | None:
+    if inferred_freq is not None:
+        if freq is not None and freq != inferred_freq:
+            raise ValueError(f'Inferred frequency {inferred_freq} from passed values does not conform to passed frequency {freq.freqstr}')
+        if freq is None:
+            freq = inferred_freq
+    return freq
+
+def dtype_to_unit(dtype: DatetimeTZDtype | np.dtype | ArrowDtype) -> str:
+    if isinstance(dtype, DatetimeTZDtype):
+        return dtype.unit
+    elif isinstance(dtype, ArrowDtype):
+        if dtype.kind not in 'mM':
+            raise ValueError(f'dtype={dtype!r} does not have a resolution.')
+        return dtype.pyarrow_dtype.unit
+    return np.datetime_data(dtype)[0]
+
+# File: pandas-main/pandas/core/arrays/datetimes.py
+from __future__ import annotations
+from datetime import datetime, timedelta, tzinfo
+from typing import TYPE_CHECKING, TypeVar, cast, overload
+import warnings
+import numpy as np
+from pandas._config import using_string_dtype
+from pandas._config.config import get_option
+from pandas._libs import lib, tslib
+from pandas._libs.tslibs import BaseOffset, NaT, NaTType, Resolution, Timestamp, astype_overflowsafe, fields, get_resolution, get_supported_dtype, get_unit_from_dtype, ints_to_pydatetime, is_date_array_normalized, is_supported_dtype, is_unitless, normalize_i8_timestamps, timezones, to_offset, tz_convert_from_utc, tzconversion
+from pandas._libs.tslibs.dtypes import abbrev_to_npy_unit
+from pandas.errors import PerformanceWarning
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import validate_inclusive
+from pandas.core.dtypes.common import DT64NS_DTYPE, INT64_DTYPE, is_bool_dtype, is_float_dtype, is_string_dtype, pandas_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype, ExtensionDtype, PeriodDtype
+from pandas.core.dtypes.missing import isna
+from pandas.core.arrays import datetimelike as dtl
+from pandas.core.arrays._ranges import generate_regular_range
+import pandas.core.common as com
+from pandas.tseries.frequencies import get_period_alias
+from pandas.tseries.offsets import Day, Tick
+if TYPE_CHECKING:
+    from collections.abc import Generator, Iterator
+    from pandas._typing import ArrayLike, DateTimeErrorChoices, DtypeObj, IntervalClosedType, Self, TimeAmbiguous, TimeNonexistent, npt
+    from pandas import DataFrame, Timedelta
+    from pandas.core.arrays import PeriodArray
+    _TimestampNoneT1 = TypeVar('_TimestampNoneT1', Timestamp, None)
+    _TimestampNoneT2 = TypeVar('_TimestampNoneT2', Timestamp, None)
+_ITER_CHUNKSIZE = 10000
+
+@overload
+def tz_to_dtype(tz: tzinfo, unit: str=...) -> DatetimeTZDtype:
+    ...
+
+@overload
+def tz_to_dtype(tz: None, unit: str=...) -> np.dtype[np.datetime64]:
+    ...
+
+def tz_to_dtype(tz: tzinfo | None, unit: str='ns') -> np.dtype[np.datetime64] | DatetimeTZDtype:
+    if tz is None:
+        return np.dtype(f'M8[{unit}]')
+    else:
+        return DatetimeTZDtype(tz=tz, unit=unit)
+
+def _field_accessor(name: str, field: str, docstring: str | None=None):
+
+    def f(self):
+        values = self._local_timestamps()
+        if field in self._bool_ops:
+            result: np.ndarray
+            if field.endswith(('start', 'end')):
+                freq = self.freq
+                month_kw = 12
+                if freq:
+                    kwds = freq.kwds
+                    month_kw = kwds.get('startingMonth', kwds.get('month', month_kw))
+                if freq is not None:
+                    freq_name = freq.name
+                else:
+                    freq_name = None
+                result = fields.get_start_end_field(values, field, freq_name, month_kw, reso=self._creso)
+            else:
+                result = fields.get_date_field(values, field, reso=self._creso)
+            return result
+        result = fields.get_date_field(values, field, reso=self._creso)
+        result = self._maybe_mask_results(result, fill_value=None, convert='float64')
+        return result
+    f.__name__ = name
+    f.__doc__ = docstring
+    return property(f)
+
+class DatetimeArray(dtl.TimelikeOps, dtl.DatelikeOps):
+    _typ = 'datetimearray'
+    _internal_fill_value = np.datetime64('NaT', 'ns')
+    _recognized_scalars = (datetime, np.datetime64)
+    _is_recognized_dtype = lambda x: lib.is_np_dtype(x, 'M') or isinstance(x, DatetimeTZDtype)
+    _infer_matches = ('datetime', 'datetime64', 'date')
+
+    @property
+    def _scalar_type(self) -> type[Timestamp]:
+        return Timestamp
+    _bool_ops: list[str] = ['is_month_start', 'is_month_end', 'is_quarter_start', 'is_quarter_end', 'is_year_start', 'is_year_end', 'is_leap_year']
+    _field_ops: list[str] = ['year', 'month', 'day', 'hour', 'minute', 'second', 'weekday', 'dayofweek', 'day_of_week', 'dayofyear', 'day_of_year', 'quarter', 'days_in_month', 'daysinmonth', 'microsecond', 'nanosecond']
+    _other_ops: list[str] = ['date', 'time', 'timetz']
+    _datetimelike_ops: list[str] = _field_ops + _bool_ops + _other_ops + ['unit', 'freq', 'tz']
+    _datetimelike_methods: list[str] = ['to_period', 'tz_localize', 'tz_convert', 'normalize', 'strftime', 'round', 'floor', 'ceil', 'month_name', 'day_name', 'as_unit']
+    __array_priority__ = 1000
+    _dtype: np.dtype[np.datetime64] | DatetimeTZDtype
+    _freq: BaseOffset | None = None
+
+    @classmethod
+    def _from_scalars(cls, scalars, *, dtype: DtypeObj) -> Self:
+        if lib.infer_dtype(scalars, skipna=True) not in ['datetime', 'datetime64']:
+            raise ValueError
+        return cls._from_sequence(scalars, dtype=dtype)
+
+    @classmethod
+    def _validate_dtype(cls, values, dtype):
+        dtype = _validate_dt64_dtype(dtype)
+        _validate_dt64_dtype(values.dtype)
+        if isinstance(dtype, np.dtype):
+            if values.dtype != dtype:
+                raise ValueError('Values resolution does not match dtype.')
+        else:
+            vunit = np.datetime_data(values.dtype)[0]
+            if vunit != dtype.unit:
+                raise ValueError('Values resolution does not match dtype.')
+        return dtype
+
+    @classmethod
+    def _simple_new(cls, values: npt.NDArray[np.datetime64], freq: BaseOffset | None=None, dtype: np.dtype[np.datetime64] | DatetimeTZDtype=DT64NS_DTYPE) -> Self:
+        assert isinstance(values, np.ndarray)
+        assert dtype.kind == 'M'
+        if isinstance(dtype, np.dtype):
+            assert dtype == values.dtype
+            assert not is_unitless(dtype)
+        else:
+            assert dtype._creso == get_unit_from_dtype(values.dtype)
+        result = super()._simple_new(values, dtype)
+        result._freq = freq
+        return result
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype=None, copy: bool=False) -> Self:
+        return cls._from_sequence_not_strict(scalars, dtype=dtype, copy=copy)
+
+    @classmethod
+    def _from_sequence_not_strict(cls, data, *, dtype=None, copy: bool=False, tz=lib.no_default, freq: str | BaseOffset | lib.NoDefault | None=lib.no_default, dayfirst: bool=False, yearfirst: bool=False, ambiguous: TimeAmbiguous='raise') -> Self:
+        explicit_tz_none = tz is None
+        if tz is lib.no_default:
+            tz = None
+        else:
+            tz = timezones.maybe_get_tz(tz)
+        dtype = _validate_dt64_dtype(dtype)
+        tz = _validate_tz_from_dtype(dtype, tz, explicit_tz_none)
+        unit = None
+        if dtype is not None:
+            unit = dtl.dtype_to_unit(dtype)
+        (data, copy) = dtl.ensure_arraylike_for_datetimelike(data, copy, cls_name='DatetimeArray')
+        inferred_freq = None
+        if isinstance(data, DatetimeArray):
+            inferred_freq = data.freq
+        (subarr, tz) = _sequence_to_dt64(data, copy=copy, tz=tz, dayfirst=dayfirst, yearfirst=yearfirst, ambiguous=ambiguous, out_unit=unit)
+        _validate_tz_from_dtype(dtype, tz, explicit_tz_none)
+        if tz is not None and explicit_tz_none:
+            raise ValueError("Passed data is timezone-aware, incompatible with 'tz=None'. Use obj.tz_localize(None) instead.")
+        data_unit = np.datetime_data(subarr.dtype)[0]
+        data_dtype = tz_to_dtype(tz, data_unit)
+        result = cls._simple_new(subarr, freq=inferred_freq, dtype=data_dtype)
+        if unit is not None and unit != result.unit:
+            result = result.as_unit(unit)
+        validate_kwds = {'ambiguous': ambiguous}
+        result._maybe_pin_freq(freq, validate_kwds)
+        return result
+
+    @classmethod
+    def _generate_range(cls, start, end, periods: int | None, freq, tz=None, normalize: bool=False, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise', inclusive: IntervalClosedType='both', *, unit: str | None=None) -> Self:
+        periods = dtl.validate_periods(periods)
+        if freq is None and any((x is None for x in [periods, start, end])):
+            raise ValueError('Must provide freq argument if no data is supplied')
+        if com.count_not_none(start, end, periods, freq) != 3:
+            raise ValueError('Of the four parameters: start, end, periods, and freq, exactly three must be specified')
+        freq = to_offset(freq)
+        if start is not None:
+            start = Timestamp(start)
+        if end is not None:
+            end = Timestamp(end)
+        if start is NaT or end is NaT:
+            raise ValueError('Neither `start` nor `end` can be NaT')
+        if unit is not None:
+            if unit not in ['s', 'ms', 'us', 'ns']:
+                raise ValueError("'unit' must be one of 's', 'ms', 'us', 'ns'")
+        else:
+            unit = 'ns'
+        if start is not None:
+            start = start.as_unit(unit, round_ok=False)
+        if end is not None:
+            end = end.as_unit(unit, round_ok=False)
+        (left_inclusive, right_inclusive) = validate_inclusive(inclusive)
+        (start, end) = _maybe_normalize_endpoints(start, end, normalize)
+        tz = _infer_tz_from_endpoints(start, end, tz)
+        if tz is not None:
+            start = _maybe_localize_point(start, freq, tz, ambiguous, nonexistent)
+            end = _maybe_localize_point(end, freq, tz, ambiguous, nonexistent)
+        if freq is not None:
+            if isinstance(freq, Day):
+                if start is not None:
+                    start = start.tz_localize(None)
+                if end is not None:
+                    end = end.tz_localize(None)
+            if isinstance(freq, Tick):
+                i8values = generate_regular_range(start, end, periods, freq, unit=unit)
+            else:
+                xdr = _generate_range(start=start, end=end, periods=periods, offset=freq, unit=unit)
+                i8values = np.array([x._value for x in xdr], dtype=np.int64)
+            endpoint_tz = start.tz if start is not None else end.tz
+            if tz is not None and endpoint_tz is None:
+                if not timezones.is_utc(tz):
+                    creso = abbrev_to_npy_unit(unit)
+                    i8values = tzconversion.tz_localize_to_utc(i8values, tz, ambiguous=ambiguous, nonexistent=nonexistent, creso=creso)
+                if start is not None:
+                    start = start.tz_localize(tz, ambiguous, nonexistent)
+                if end is not None:
+                    end = end.tz_localize(tz, ambiguous, nonexistent)
+        else:
+            periods = cast(int, periods)
+            i8values = np.linspace(0, end._value - start._value, periods, dtype='int64') + start._value
+            if i8values.dtype != 'i8':
+                i8values = i8values.astype('i8')
+        if start == end:
+            if not left_inclusive and (not right_inclusive):
+                i8values = i8values[1:-1]
+        else:
+            start_i8 = Timestamp(start)._value
+            end_i8 = Timestamp(end)._value
+            if not left_inclusive or not right_inclusive:
+                if not left_inclusive and len(i8values) and (i8values[0] == start_i8):
+                    i8values = i8values[1:]
+                if not right_inclusive and len(i8values) and (i8values[-1] == end_i8):
+                    i8values = i8values[:-1]
+        dt64_values = i8values.view(f'datetime64[{unit}]')
+        dtype = tz_to_dtype(tz, unit=unit)
+        return cls._simple_new(dt64_values, freq=freq, dtype=dtype)
+
+    def _unbox_scalar(self, value) -> np.datetime64:
+        if not isinstance(value, self._scalar_type) and value is not NaT:
+            raise ValueError("'value' should be a Timestamp.")
+        self._check_compatible_with(value)
+        if value is NaT:
+            return np.datetime64(value._value, self.unit)
+        else:
+            return value.as_unit(self.unit, round_ok=False).asm8
+
+    def _scalar_from_string(self, value) -> Timestamp | NaTType:
+        return Timestamp(value, tz=self.tz)
+
+    def _check_compatible_with(self, other) -> None:
+        if other is NaT:
+            return
+        self._assert_tzawareness_compat(other)
+
+    def _box_func(self, x: np.datetime64) -> Timestamp | NaTType:
+        value = x.view('i8')
+        ts = Timestamp._from_value_and_reso(value, reso=self._creso, tz=self.tz)
+        return ts
+
+    @property
+    def dtype(self) -> np.dtype[np.datetime64] | DatetimeTZDtype:
+        return self._dtype
+
+    @property
+    def tz(self) -> tzinfo | None:
+        return getattr(self.dtype, 'tz', None)
+
+    @tz.setter
+    def tz(self, value):
+        raise AttributeError('Cannot directly set timezone. Use tz_localize() or tz_convert() as appropriate')
+
+    @property
+    def tzinfo(self) -> tzinfo | None:
+        return self.tz
+
+    @property
+    def is_normalized(self) -> bool:
+        return is_date_array_normalized(self.asi8, self.tz, reso=self._creso)
+
+    @property
+    def _resolution_obj(self) -> Resolution:
+        return get_resolution(self.asi8, self.tz, reso=self._creso)
+
+    def __array__(self, dtype=None, copy=None) -> np.ndarray:
+        if dtype is None and self.tz:
+            dtype = object
+        return super().__array__(dtype=dtype, copy=copy)
+
+    def __iter__(self) -> Iterator:
+        if self.ndim > 1:
+            for i in range(len(self)):
+                yield self[i]
+        else:
+            data = self.asi8
+            length = len(self)
+            chunksize = _ITER_CHUNKSIZE
+            chunks = length // chunksize + 1
+            for i in range(chunks):
+                start_i = i * chunksize
+                end_i = min((i + 1) * chunksize, length)
+                converted = ints_to_pydatetime(data[start_i:end_i], tz=self.tz, box='timestamp', reso=self._creso)
+                yield from converted
+
+    def astype(self, dtype, copy: bool=True):
+        dtype = pandas_dtype(dtype)
+        if dtype == self.dtype:
+            if copy:
+                return self.copy()
+            return self
+        elif isinstance(dtype, ExtensionDtype):
+            if not isinstance(dtype, DatetimeTZDtype):
+                return super().astype(dtype, copy=copy)
+            elif self.tz is None:
+                raise TypeError('Cannot use .astype to convert from timezone-naive dtype to timezone-aware dtype. Use obj.tz_localize instead or series.dt.tz_localize instead')
+            else:
+                np_dtype = np.dtype(dtype.str)
+                res_values = astype_overflowsafe(self._ndarray, np_dtype, copy=copy)
+                return type(self)._simple_new(res_values, dtype=dtype, freq=self.freq)
+        elif self.tz is None and lib.is_np_dtype(dtype, 'M') and (not is_unitless(dtype)) and is_supported_dtype(dtype):
+            res_values = astype_overflowsafe(self._ndarray, dtype, copy=True)
+            return type(self)._simple_new(res_values, dtype=res_values.dtype)
+        elif self.tz is not None and lib.is_np_dtype(dtype, 'M'):
+            raise TypeError("Cannot use .astype to convert from timezone-aware dtype to timezone-naive dtype. Use obj.tz_localize(None) or obj.tz_convert('UTC').tz_localize(None) instead.")
+        elif self.tz is None and lib.is_np_dtype(dtype, 'M') and (dtype != self.dtype) and is_unitless(dtype):
+            raise TypeError("Casting to unit-less dtype 'datetime64' is not supported. Pass e.g. 'datetime64[ns]' instead.")
+        elif isinstance(dtype, PeriodDtype):
+            return self.to_period(freq=dtype.freq)
+        return dtl.DatetimeLikeArrayMixin.astype(self, dtype, copy)
+
+    def _format_native_types(self, *, na_rep: str | float='NaT', date_format=None, **kwargs) -> npt.NDArray[np.object_]:
+        if date_format is None and self._is_dates_only:
+            date_format = '%Y-%m-%d'
+        return tslib.format_array_from_datetime(self.asi8, tz=self.tz, format=date_format, na_rep=na_rep, reso=self._creso)
+
+    def _assert_tzawareness_compat(self, other) -> None:
+        other_tz = getattr(other, 'tzinfo', None)
+        other_dtype = getattr(other, 'dtype', None)
+        if isinstance(other_dtype, DatetimeTZDtype):
+            other_tz = other.dtype.tz
+        if other is NaT:
+            pass
+        elif self.tz is None:
+            if other_tz is not None:
+                raise TypeError('Cannot compare tz-naive and tz-aware datetime-like objects.')
+        elif other_tz is None:
+            raise TypeError('Cannot compare tz-naive and tz-aware datetime-like objects')
+
+    def _add_offset(self, offset: BaseOffset) -> Self:
+        assert not isinstance(offset, Tick)
+        if self.tz is not None:
+            values = self.tz_localize(None)
+        else:
+            values = self
+        try:
+            res_values = offset._apply_array(values._ndarray)
+            if res_values.dtype.kind == 'i':
+                res_values = res_values.view(values.dtype)
+        except NotImplementedError:
+            if get_option('performance_warnings'):
+                warnings.warn('Non-vectorized DateOffset being applied to Series or DatetimeIndex.', PerformanceWarning, stacklevel=find_stack_level())
+            res_values = self.astype('O') + offset
+            result = type(self)._from_sequence(res_values).as_unit(self.unit)
+            if not len(self):
+                return result.tz_localize(self.tz)
+        else:
+            result = type(self)._simple_new(res_values, dtype=res_values.dtype)
+            if offset.normalize:
+                result = result.normalize()
+                result._freq = None
+            if self.tz is not None:
+                result = result.tz_localize(self.tz)
+        return result
+
+    def _local_timestamps(self) -> npt.NDArray[np.int64]:
+        if self.tz is None or timezones.is_utc(self.tz):
+            return self.asi8
+        return tz_convert_from_utc(self.asi8, self.tz, reso=self._creso)
+
+    def tz_convert(self, tz) -> Self:
+        tz = timezones.maybe_get_tz(tz)
+        if self.tz is None:
+            raise TypeError('Cannot convert tz-naive timestamps, use tz_localize to localize')
+        dtype = tz_to_dtype(tz, unit=self.unit)
+        return self._simple_new(self._ndarray, dtype=dtype, freq=self.freq)
+
+    @dtl.ravel_compat
+    def tz_localize(self, tz, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise') -> Self:
+        nonexistent_options = ('raise', 'NaT', 'shift_forward', 'shift_backward')
+        if nonexistent not in nonexistent_options and (not isinstance(nonexistent, timedelta)):
+            raise ValueError("The nonexistent argument must be one of 'raise', 'NaT', 'shift_forward', 'shift_backward' or a timedelta object")
+        if self.tz is not None:
+            if tz is None:
+                new_dates = tz_convert_from_utc(self.asi8, self.tz, reso=self._creso)
+            else:
+                raise TypeError('Already tz-aware, use tz_convert to convert.')
+        else:
+            tz = timezones.maybe_get_tz(tz)
+            new_dates = tzconversion.tz_localize_to_utc(self.asi8, tz, ambiguous=ambiguous, nonexistent=nonexistent, creso=self._creso)
+        new_dates_dt64 = new_dates.view(f'M8[{self.unit}]')
+        dtype = tz_to_dtype(tz, unit=self.unit)
+        freq = None
+        if timezones.is_utc(tz) or (len(self) == 1 and (not isna(new_dates_dt64[0]))):
+            freq = self.freq
+        elif tz is None and self.tz is None:
+            freq = self.freq
+        return self._simple_new(new_dates_dt64, dtype=dtype, freq=freq)
+
+    def to_pydatetime(self) -> npt.NDArray[np.object_]:
+        return ints_to_pydatetime(self.asi8, tz=self.tz, reso=self._creso)
+
+    def normalize(self) -> Self:
+        new_values = normalize_i8_timestamps(self.asi8, self.tz, reso=self._creso)
+        dt64_values = new_values.view(self._ndarray.dtype)
+        dta = type(self)._simple_new(dt64_values, dtype=dt64_values.dtype)
+        dta = dta._with_freq('infer')
+        if self.tz is not None:
+            dta = dta.tz_localize(self.tz)
+        return dta
+
+    def to_period(self, freq=None) -> PeriodArray:
+        from pandas.core.arrays import PeriodArray
+        if self.tz is not None:
+            warnings.warn('Converting to PeriodArray/Index representation will drop timezone information.', UserWarning, stacklevel=find_stack_level())
+        if freq is None:
+            freq = self.freqstr or self.inferred_freq
+            if isinstance(self.freq, BaseOffset) and hasattr(self.freq, '_period_dtype_code'):
+                freq = PeriodDtype(self.freq)._freqstr
+            if freq is None:
+                raise ValueError('You must pass a freq argument as current index has none.')
+            res = get_period_alias(freq)
+            if res is None:
+                res = freq
+            freq = res
+        return PeriodArray._from_datetime64(self._ndarray, freq, tz=self.tz)
+
+    def month_name(self, locale=None) -> npt.NDArray[np.object_]:
+        values = self._local_timestamps()
+        result = fields.get_date_name_field(values, 'month_name', locale=locale, reso=self._creso)
+        result = self._maybe_mask_results(result, fill_value=None)
+        if using_string_dtype():
+            from pandas import StringDtype, array as pd_array
+            return pd_array(result, dtype=StringDtype(na_value=np.nan))
+        return result
+
+    def day_name(self, locale=None) -> npt.NDArray[np.object_]:
+        values = self._local_timestamps()
+        result = fields.get_date_name_field(values, 'day_name', locale=locale, reso=self._creso)
+        result = self._maybe_mask_results(result, fill_value=None)
+        if using_string_dtype():
+            from pandas import StringDtype, array as pd_array
+            return pd_array(result, dtype=StringDtype(na_value=np.nan))
+        return result
+
+    @property
+    def time(self) -> npt.NDArray[np.object_]:
+        timestamps = self._local_timestamps()
+        return ints_to_pydatetime(timestamps, box='time', reso=self._creso)
+
+    @property
+    def timetz(self) -> npt.NDArray[np.object_]:
+        return ints_to_pydatetime(self.asi8, self.tz, box='time', reso=self._creso)
+
+    @property
+    def date(self) -> npt.NDArray[np.object_]:
+        timestamps = self._local_timestamps()
+        return ints_to_pydatetime(timestamps, box='date', reso=self._creso)
+
+    def isocalendar(self) -> DataFrame:
+        from pandas import DataFrame
+        values = self._local_timestamps()
+        sarray = fields.build_isocalendar_sarray(values, reso=self._creso)
+        iso_calendar_df = DataFrame(sarray, columns=['year', 'week', 'day'], dtype='UInt32')
+        if self._hasna:
+            iso_calendar_df.iloc[self._isnan] = None
+        return iso_calendar_df
+    year = _field_accessor('year', 'Y', '\n        The year of the datetime.\n\n        See Also\n        --------\n        DatetimeIndex.month: The month as January=1, December=12.\n        DatetimeIndex.day: The day of the datetime.\n\n        Examples\n        --------\n        >>> datetime_series = pd.Series(\n        ...     pd.date_range("2000-01-01", periods=3, freq="YE")\n        ... )\n        >>> datetime_series\n        0   2000-12-31\n        1   2001-12-31\n        2   2002-12-31\n        dtype: datetime64[ns]\n        >>> datetime_series.dt.year\n        0    2000\n        1    2001\n        2    2002\n        dtype: int32\n        ')
+    month = _field_accessor('month', 'M', '\n        The month as January=1, December=12.\n\n        See Also\n        --------\n        DatetimeIndex.year: The year of the datetime.\n        DatetimeIndex.day: The day of the datetime.\n\n        Examples\n        --------\n        >>> datetime_series = pd.Series(\n        ...     pd.date_range("2000-01-01", periods=3, freq="ME")\n        ... )\n        >>> datetime_series\n        0   2000-01-31\n        1   2000-02-29\n        2   2000-03-31\n        dtype: datetime64[ns]\n        >>> datetime_series.dt.month\n        0    1\n        1    2\n        2    3\n        dtype: int32\n        ')
+    day = _field_accessor('day', 'D', '\n        The day of the datetime.\n\n        See Also\n        --------\n        DatetimeIndex.year: The year of the datetime.\n        DatetimeIndex.month: The month as January=1, December=12.\n        DatetimeIndex.hour: The hours of the datetime.\n\n        Examples\n        --------\n        >>> datetime_series = pd.Series(\n        ...     pd.date_range("2000-01-01", periods=3, freq="D")\n        ... )\n        >>> datetime_series\n        0   2000-01-01\n        1   2000-01-02\n        2   2000-01-03\n        dtype: datetime64[ns]\n        >>> datetime_series.dt.day\n        0    1\n        1    2\n        2    3\n        dtype: int32\n        ')
+    hour = _field_accessor('hour', 'h', '\n        The hours of the datetime.\n\n        See Also\n        --------\n        DatetimeIndex.day: The day of the datetime.\n        DatetimeIndex.minute: The minutes of the datetime.\n        DatetimeIndex.second: The seconds of the datetime.\n\n        Examples\n        --------\n        >>> datetime_series = pd.Series(\n        ...     pd.date_range("2000-01-01", periods=3, freq="h")\n        ... )\n        >>> datetime_series\n        0   2000-01-01 00:00:00\n        1   2000-01-01 01:00:00\n        2   2000-01-01 02:00:00\n        dtype: datetime64[ns]\n        >>> datetime_series.dt.hour\n        0    0\n        1    1\n        2    2\n        dtype: int32\n        ')
+    minute = _field_accessor('minute', 'm', '\n        The minutes of the datetime.\n\n        See Also\n        --------\n        DatetimeIndex.hour: The hours of the datetime.\n        DatetimeIndex.second: The seconds of the datetime.\n\n        Examples\n        --------\n        >>> datetime_series = pd.Series(\n        ...     pd.date_range("2000-01-01", periods=3, freq="min")\n        ... )\n        >>> datetime_series\n        0   2000-01-01 00:00:00\n        1   2000-01-01 00:01:00\n        2   2000-01-01 00:02:00\n        dtype: datetime64[ns]\n        >>> datetime_series.dt.minute\n        0    0\n        1    1\n        2    2\n        dtype: int32\n        ')
+    second = _field_accessor('second', 's', '\n        The seconds of the datetime.\n\n        See Also\n        --------\n        DatetimeIndex.minute: The minutes of the datetime.\n        DatetimeIndex.microsecond: The microseconds of the datetime.\n        DatetimeIndex.nanosecond: The nanoseconds of the datetime.\n\n        Examples\n        --------\n        >>> datetime_series = pd.Series(\n        ...     pd.date_range("2000-01-01", periods=3, freq="s")\n        ... )\n        >>> datetime_series\n        0   2000-01-01 00:00:00\n        1   2000-01-01 00:00:01\n        2   2000-01-01 00:00:02\n        dtype: datetime64[ns]\n        >>> datetime_series.dt.second\n        0    0\n        1    1\n        2    2\n        dtype: int32\n        ')
+    microsecond = _field_accessor('microsecond', 'us', '\n        The microseconds of the datetime.\n\n        See Also\n        --------\n        DatetimeIndex.second: The seconds of the datetime.\n        DatetimeIndex.nanosecond: The nanoseconds of the datetime.\n\n        Examples\n        --------\n        >>> datetime_series = pd.Series(\n        ...     pd.date_range("2000-01-01", periods=3, freq="us")\n        ... )\n        >>> datetime_series\n        0   2000-01-01 00:00:00.000000\n        1   2000-01-01 00:00:00.000001\n        2   2000-01-01 00:00:00.000002\n        dtype: datetime64[ns]\n        >>> datetime_series.dt.microsecond\n        0       0\n        1       1\n        2       2\n        dtype: int32\n        ')
+    nanosecond = _field_accessor('nanosecond', 'ns', '\n        The nanoseconds of the datetime.\n\n        See Also\n        --------\n        DatetimeIndex.second: The seconds of the datetime.\n        DatetimeIndex.microsecond: The microseconds of the datetime.\n\n        Examples\n        --------\n        >>> datetime_series = pd.Series(\n        ...     pd.date_range("2000-01-01", periods=3, freq="ns")\n        ... )\n        >>> datetime_series\n        0   2000-01-01 00:00:00.000000000\n        1   2000-01-01 00:00:00.000000001\n        2   2000-01-01 00:00:00.000000002\n        dtype: datetime64[ns]\n        >>> datetime_series.dt.nanosecond\n        0       0\n        1       1\n        2       2\n        dtype: int32\n        ')
+    _dayofweek_doc = "\n    The day of the week with Monday=0, Sunday=6.\n\n    Return the day of the week. It is assumed the week starts on\n    Monday, which is denoted by 0 and ends on Sunday which is denoted\n    by 6. This method is available on both Series with datetime\n    values (using the `dt` accessor) or DatetimeIndex.\n\n    Returns\n    -------\n    Series or Index\n        Containing integers indicating the day number.\n\n    See Also\n    --------\n    Series.dt.dayofweek : Alias.\n    Series.dt.weekday : Alias.\n    Series.dt.day_name : Returns the name of the day of the week.\n\n    Examples\n    --------\n    >>> s = pd.date_range('2016-12-31', '2017-01-08', freq='D').to_series()\n    >>> s.dt.dayofweek\n    2016-12-31    5\n    2017-01-01    6\n    2017-01-02    0\n    2017-01-03    1\n    2017-01-04    2\n    2017-01-05    3\n    2017-01-06    4\n    2017-01-07    5\n    2017-01-08    6\n    Freq: D, dtype: int32\n    "
+    day_of_week = _field_accessor('day_of_week', 'dow', _dayofweek_doc)
+    dayofweek = day_of_week
+    weekday = day_of_week
+    day_of_year = _field_accessor('dayofyear', 'doy', '\n        The ordinal day of the year.\n\n        See Also\n        --------\n        DatetimeIndex.dayofweek : The day of the week with Monday=0, Sunday=6.\n        DatetimeIndex.day : The day of the datetime.\n\n        Examples\n        --------\n        For Series:\n\n        >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"])\n        >>> s = pd.to_datetime(s)\n        >>> s\n        0   2020-01-01 10:00:00+00:00\n        1   2020-02-01 11:00:00+00:00\n        dtype: datetime64[s, UTC]\n        >>> s.dt.dayofyear\n        0    1\n        1   32\n        dtype: int32\n\n        For DatetimeIndex:\n\n        >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00",\n        ...                         "2/1/2020 11:00:00+00:00"])\n        >>> idx.dayofyear\n        Index([1, 32], dtype=\'int32\')\n        ')
+    dayofyear = day_of_year
+    quarter = _field_accessor('quarter', 'q', '\n        The quarter of the date.\n\n        See Also\n        --------\n        DatetimeIndex.snap : Snap time stamps to nearest occurring frequency.\n        DatetimeIndex.time : Returns numpy array of datetime.time objects.\n            The time part of the Timestamps.\n\n        Examples\n        --------\n        For Series:\n\n        >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "4/1/2020 11:00:00+00:00"])\n        >>> s = pd.to_datetime(s)\n        >>> s\n        0   2020-01-01 10:00:00+00:00\n        1   2020-04-01 11:00:00+00:00\n        dtype: datetime64[s, UTC]\n        >>> s.dt.quarter\n        0    1\n        1    2\n        dtype: int32\n\n        For DatetimeIndex:\n\n        >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00",\n        ...                         "2/1/2020 11:00:00+00:00"])\n        >>> idx.quarter\n        Index([1, 1], dtype=\'int32\')\n        ')
+    days_in_month = _field_accessor('days_in_month', 'dim', '\n        The number of days in the month.\n\n        See Also\n        --------\n        Series.dt.day : Return the day of the month.\n        Series.dt.is_month_end : Return a boolean indicating if the\n            date is the last day of the month.\n        Series.dt.is_month_start : Return a boolean indicating if the\n            date is the first day of the month.\n        Series.dt.month : Return the month as January=1 through December=12.\n\n        Examples\n        --------\n        >>> s = pd.Series(["1/1/2020 10:00:00+00:00", "2/1/2020 11:00:00+00:00"])\n        >>> s = pd.to_datetime(s)\n        >>> s\n        0   2020-01-01 10:00:00+00:00\n        1   2020-02-01 11:00:00+00:00\n        dtype: datetime64[s, UTC]\n        >>> s.dt.daysinmonth\n        0    31\n        1    29\n        dtype: int32\n        ')
+    daysinmonth = days_in_month
+    _is_month_doc = '\n        Indicates whether the date is the {first_or_last} day of the month.\n\n        Returns\n        -------\n        Series or array\n            For Series, returns a Series with boolean values.\n            For DatetimeIndex, returns a boolean array.\n\n        See Also\n        --------\n        is_month_start : Return a boolean indicating whether the date\n            is the first day of the month.\n        is_month_end : Return a boolean indicating whether the date\n            is the last day of the month.\n\n        Examples\n        --------\n        This method is available on Series with datetime values under\n        the ``.dt`` accessor, and directly on DatetimeIndex.\n\n        >>> s = pd.Series(pd.date_range("2018-02-27", periods=3))\n        >>> s\n        0   2018-02-27\n        1   2018-02-28\n        2   2018-03-01\n        dtype: datetime64[ns]\n        >>> s.dt.is_month_start\n        0    False\n        1    False\n        2    True\n        dtype: bool\n        >>> s.dt.is_month_end\n        0    False\n        1    True\n        2    False\n        dtype: bool\n\n        >>> idx = pd.date_range("2018-02-27", periods=3)\n        >>> idx.is_month_start\n        array([False, False, True])\n        >>> idx.is_month_end\n        array([False, True, False])\n    '
+    is_month_start = _field_accessor('is_month_start', 'is_month_start', _is_month_doc.format(first_or_last='first'))
+    is_month_end = _field_accessor('is_month_end', 'is_month_end', _is_month_doc.format(first_or_last='last'))
+    is_quarter_start = _field_accessor('is_quarter_start', 'is_quarter_start', '\n        Indicator for whether the date is the first day of a quarter.\n\n        Returns\n        -------\n        is_quarter_start : Series or DatetimeIndex\n            The same type as the original data with boolean values. Series will\n            have the same name and index. DatetimeIndex will have the same\n            name.\n\n        See Also\n        --------\n        quarter : Return the quarter of the date.\n        is_quarter_end : Similar property for indicating the quarter end.\n\n        Examples\n        --------\n        This method is available on Series with datetime values under\n        the ``.dt`` accessor, and directly on DatetimeIndex.\n\n        >>> df = pd.DataFrame({\'dates\': pd.date_range("2017-03-30",\n        ...                   periods=4)})\n        >>> df.assign(quarter=df.dates.dt.quarter,\n        ...           is_quarter_start=df.dates.dt.is_quarter_start)\n               dates  quarter  is_quarter_start\n        0 2017-03-30        1             False\n        1 2017-03-31        1             False\n        2 2017-04-01        2              True\n        3 2017-04-02        2             False\n\n        >>> idx = pd.date_range(\'2017-03-30\', periods=4)\n        >>> idx\n        DatetimeIndex([\'2017-03-30\', \'2017-03-31\', \'2017-04-01\', \'2017-04-02\'],\n                      dtype=\'datetime64[ns]\', freq=\'D\')\n\n        >>> idx.is_quarter_start\n        array([False, False,  True, False])\n        ')
+    is_quarter_end = _field_accessor('is_quarter_end', 'is_quarter_end', '\n        Indicator for whether the date is the last day of a quarter.\n\n        Returns\n        -------\n        is_quarter_end : Series or DatetimeIndex\n            The same type as the original data with boolean values. Series will\n            have the same name and index. DatetimeIndex will have the same\n            name.\n\n        See Also\n        --------\n        quarter : Return the quarter of the date.\n        is_quarter_start : Similar property indicating the quarter start.\n\n        Examples\n        --------\n        This method is available on Series with datetime values under\n        the ``.dt`` accessor, and directly on DatetimeIndex.\n\n        >>> df = pd.DataFrame({\'dates\': pd.date_range("2017-03-30",\n        ...                    periods=4)})\n        >>> df.assign(quarter=df.dates.dt.quarter,\n        ...           is_quarter_end=df.dates.dt.is_quarter_end)\n               dates  quarter    is_quarter_end\n        0 2017-03-30        1             False\n        1 2017-03-31        1              True\n        2 2017-04-01        2             False\n        3 2017-04-02        2             False\n\n        >>> idx = pd.date_range(\'2017-03-30\', periods=4)\n        >>> idx\n        DatetimeIndex([\'2017-03-30\', \'2017-03-31\', \'2017-04-01\', \'2017-04-02\'],\n                      dtype=\'datetime64[ns]\', freq=\'D\')\n\n        >>> idx.is_quarter_end\n        array([False,  True, False, False])\n        ')
+    is_year_start = _field_accessor('is_year_start', 'is_year_start', '\n        Indicate whether the date is the first day of a year.\n\n        Returns\n        -------\n        Series or DatetimeIndex\n            The same type as the original data with boolean values. Series will\n            have the same name and index. DatetimeIndex will have the same\n            name.\n\n        See Also\n        --------\n        is_year_end : Similar property indicating the last day of the year.\n\n        Examples\n        --------\n        This method is available on Series with datetime values under\n        the ``.dt`` accessor, and directly on DatetimeIndex.\n\n        >>> dates = pd.Series(pd.date_range("2017-12-30", periods=3))\n        >>> dates\n        0   2017-12-30\n        1   2017-12-31\n        2   2018-01-01\n        dtype: datetime64[ns]\n\n        >>> dates.dt.is_year_start\n        0    False\n        1    False\n        2    True\n        dtype: bool\n\n        >>> idx = pd.date_range("2017-12-30", periods=3)\n        >>> idx\n        DatetimeIndex([\'2017-12-30\', \'2017-12-31\', \'2018-01-01\'],\n                      dtype=\'datetime64[ns]\', freq=\'D\')\n\n        >>> idx.is_year_start\n        array([False, False,  True])\n\n        This method, when applied to Series with datetime values under\n        the ``.dt`` accessor, will lose information about Business offsets.\n\n        >>> dates = pd.Series(pd.date_range("2020-10-30", periods=4, freq="BYS"))\n        >>> dates\n        0   2021-01-01\n        1   2022-01-03\n        2   2023-01-02\n        3   2024-01-01\n        dtype: datetime64[ns]\n\n        >>> dates.dt.is_year_start\n        0    True\n        1    False\n        2    False\n        3    True\n        dtype: bool\n\n        >>> idx = pd.date_range("2020-10-30", periods=4, freq="BYS")\n        >>> idx\n        DatetimeIndex([\'2021-01-01\', \'2022-01-03\', \'2023-01-02\', \'2024-01-01\'],\n                      dtype=\'datetime64[ns]\', freq=\'BYS-JAN\')\n\n        >>> idx.is_year_start\n        array([ True,  True,  True,  True])\n        ')
+    is_year_end = _field_accessor('is_year_end', 'is_year_end', '\n        Indicate whether the date is the last day of the year.\n\n        Returns\n        -------\n        Series or DatetimeIndex\n            The same type as the original data with boolean values. Series will\n            have the same name and index. DatetimeIndex will have the same\n            name.\n\n        See Also\n        --------\n        is_year_start : Similar property indicating the start of the year.\n\n        Examples\n        --------\n        This method is available on Series with datetime values under\n        the ``.dt`` accessor, and directly on DatetimeIndex.\n\n        >>> dates = pd.Series(pd.date_range("2017-12-30", periods=3))\n        >>> dates\n        0   2017-12-30\n        1   2017-12-31\n        2   2018-01-01\n        dtype: datetime64[ns]\n\n        >>> dates.dt.is_year_end\n        0    False\n        1     True\n        2    False\n        dtype: bool\n\n        >>> idx = pd.date_range("2017-12-30", periods=3)\n        >>> idx\n        DatetimeIndex([\'2017-12-30\', \'2017-12-31\', \'2018-01-01\'],\n                      dtype=\'datetime64[ns]\', freq=\'D\')\n\n        >>> idx.is_year_end\n        array([False,  True, False])\n        ')
+    is_leap_year = _field_accessor('is_leap_year', 'is_leap_year', '\n        Boolean indicator if the date belongs to a leap year.\n\n        A leap year is a year, which has 366 days (instead of 365) including\n        29th of February as an intercalary day.\n        Leap years are years which are multiples of four with the exception\n        of years divisible by 100 but not by 400.\n\n        Returns\n        -------\n        Series or ndarray\n             Booleans indicating if dates belong to a leap year.\n\n        See Also\n        --------\n        DatetimeIndex.is_year_end : Indicate whether the date is the\n            last day of the year.\n        DatetimeIndex.is_year_start : Indicate whether the date is the first\n            day of a year.\n\n        Examples\n        --------\n        This method is available on Series with datetime values under\n        the ``.dt`` accessor, and directly on DatetimeIndex.\n\n        >>> idx = pd.date_range("2012-01-01", "2015-01-01", freq="YE")\n        >>> idx\n        DatetimeIndex([\'2012-12-31\', \'2013-12-31\', \'2014-12-31\'],\n                      dtype=\'datetime64[ns]\', freq=\'YE-DEC\')\n        >>> idx.is_leap_year\n        array([ True, False, False])\n\n        >>> dates_series = pd.Series(idx)\n        >>> dates_series\n        0   2012-12-31\n        1   2013-12-31\n        2   2014-12-31\n        dtype: datetime64[ns]\n        >>> dates_series.dt.is_leap_year\n        0     True\n        1    False\n        2    False\n        dtype: bool\n        ')
+
+    def to_julian_date(self) -> npt.NDArray[np.float64]:
+        year = np.asarray(self.year)
+        month = np.asarray(self.month)
+        day = np.asarray(self.day)
+        testarr = month < 3
+        year[testarr] -= 1
+        month[testarr] += 12
+        return day + np.fix((153 * month - 457) / 5) + 365 * year + np.floor(year / 4) - np.floor(year / 100) + np.floor(year / 400) + 1721118.5 + (self.hour + self.minute / 60 + self.second / 3600 + self.microsecond / 3600 / 10 ** 6 + self.nanosecond / 3600 / 10 ** 9) / 24
+
+    def _reduce(self, name: str, *, skipna: bool=True, keepdims: bool=False, **kwargs):
+        result = super()._reduce(name, skipna=skipna, keepdims=keepdims, **kwargs)
+        if keepdims and isinstance(result, np.ndarray):
+            if name == 'std':
+                from pandas.core.arrays import TimedeltaArray
+                return TimedeltaArray._from_sequence(result)
+            else:
+                return self._from_sequence(result, dtype=self.dtype)
+        return result
+
+    def std(self, axis=None, dtype=None, out=None, ddof: int=1, keepdims: bool=False, skipna: bool=True) -> Timedelta:
+        from pandas.core.arrays import TimedeltaArray
+        dtype_str = self._ndarray.dtype.name.replace('datetime64', 'timedelta64')
+        dtype = np.dtype(dtype_str)
+        tda = TimedeltaArray._simple_new(self._ndarray.view(dtype), dtype=dtype)
+        return tda.std(axis=axis, out=out, ddof=ddof, keepdims=keepdims, skipna=skipna)
+
+def _sequence_to_dt64(data: ArrayLike, *, copy: bool=False, tz: tzinfo | None=None, dayfirst: bool=False, yearfirst: bool=False, ambiguous: TimeAmbiguous='raise', out_unit: str | None=None) -> tuple[np.ndarray, tzinfo | None]:
+    (data, copy) = maybe_convert_dtype(data, copy, tz=tz)
+    data_dtype = getattr(data, 'dtype', None)
+    out_dtype = DT64NS_DTYPE
+    if out_unit is not None:
+        out_dtype = np.dtype(f'M8[{out_unit}]')
+    if data_dtype == object or is_string_dtype(data_dtype):
+        data = cast(np.ndarray, data)
+        copy = False
+        if lib.infer_dtype(data, skipna=False) == 'integer':
+            data = data.astype(np.int64)
+        elif tz is not None and ambiguous == 'raise':
+            obj_data = np.asarray(data, dtype=object)
+            result = tslib.array_to_datetime_with_tz(obj_data, tz=tz, dayfirst=dayfirst, yearfirst=yearfirst, creso=abbrev_to_npy_unit(out_unit))
+            return (result, tz)
+        else:
+            (converted, inferred_tz) = objects_to_datetime64(data, dayfirst=dayfirst, yearfirst=yearfirst, allow_object=False, out_unit=out_unit)
+            copy = False
+            if tz and inferred_tz:
+                result = converted
+            elif inferred_tz:
+                tz = inferred_tz
+                result = converted
+            else:
+                (result, _) = _construct_from_dt64_naive(converted, tz=tz, copy=copy, ambiguous=ambiguous)
+            return (result, tz)
+        data_dtype = data.dtype
+    if isinstance(data_dtype, DatetimeTZDtype):
+        data = cast(DatetimeArray, data)
+        tz = _maybe_infer_tz(tz, data.tz)
+        result = data._ndarray
+    elif lib.is_np_dtype(data_dtype, 'M'):
+        if isinstance(data, DatetimeArray):
+            data = data._ndarray
+        data = cast(np.ndarray, data)
+        (result, copy) = _construct_from_dt64_naive(data, tz=tz, copy=copy, ambiguous=ambiguous)
+    else:
+        if data.dtype != INT64_DTYPE:
+            data = data.astype(np.int64, copy=False)
+            copy = False
+        data = cast(np.ndarray, data)
+        result = data.view(out_dtype)
+    if copy:
+        result = result.copy()
+    assert isinstance(result, np.ndarray), type(result)
+    assert result.dtype.kind == 'M'
+    assert result.dtype != 'M8'
+    assert is_supported_dtype(result.dtype)
+    return (result, tz)
+
+def _construct_from_dt64_naive(data: np.ndarray, *, tz: tzinfo | None, copy: bool, ambiguous: TimeAmbiguous) -> tuple[np.ndarray, bool]:
+    new_dtype = data.dtype
+    if not is_supported_dtype(new_dtype):
+        new_dtype = get_supported_dtype(new_dtype)
+        data = astype_overflowsafe(data, dtype=new_dtype, copy=False)
+        copy = False
+    if data.dtype.byteorder == '>':
+        data = data.astype(data.dtype.newbyteorder('<'))
+        new_dtype = data.dtype
+        copy = False
+    if tz is not None:
+        shape = data.shape
+        if data.ndim > 1:
+            data = data.ravel()
+        data_unit = get_unit_from_dtype(new_dtype)
+        data = tzconversion.tz_localize_to_utc(data.view('i8'), tz, ambiguous=ambiguous, creso=data_unit)
+        data = data.view(new_dtype)
+        data = data.reshape(shape)
+    assert data.dtype == new_dtype, data.dtype
+    result = data
+    return (result, copy)
+
+def objects_to_datetime64(data: np.ndarray, dayfirst, yearfirst, utc: bool=False, errors: DateTimeErrorChoices='raise', allow_object: bool=False, out_unit: str | None=None) -> tuple[np.ndarray, tzinfo | None]:
+    assert errors in ['raise', 'coerce']
+    data = np.asarray(data, dtype=np.object_)
+    (result, tz_parsed) = tslib.array_to_datetime(data, errors=errors, utc=utc, dayfirst=dayfirst, yearfirst=yearfirst, creso=abbrev_to_npy_unit(out_unit))
+    if tz_parsed is not None:
+        return (result, tz_parsed)
+    elif result.dtype.kind == 'M':
+        return (result, tz_parsed)
+    elif result.dtype == object:
+        if allow_object:
+            return (result, tz_parsed)
+        raise TypeError('DatetimeIndex has mixed timezones')
+    else:
+        raise TypeError(result)
+
+def maybe_convert_dtype(data, copy: bool, tz: tzinfo | None=None):
+    if not hasattr(data, 'dtype'):
+        return (data, copy)
+    if is_float_dtype(data.dtype):
+        data = data.astype(DT64NS_DTYPE).view('i8')
+        copy = False
+    elif lib.is_np_dtype(data.dtype, 'm') or is_bool_dtype(data.dtype):
+        raise TypeError(f'dtype {data.dtype} cannot be converted to datetime64[ns]')
+    elif isinstance(data.dtype, PeriodDtype):
+        raise TypeError('Passing PeriodDtype data is invalid. Use `data.to_timestamp()` instead')
+    elif isinstance(data.dtype, ExtensionDtype) and (not isinstance(data.dtype, DatetimeTZDtype)):
+        data = np.array(data, dtype=np.object_)
+        copy = False
+    return (data, copy)
+
+def _maybe_infer_tz(tz: tzinfo | None, inferred_tz: tzinfo | None) -> tzinfo | None:
+    if tz is None:
+        tz = inferred_tz
+    elif inferred_tz is None:
+        pass
+    elif not timezones.tz_compare(tz, inferred_tz):
+        raise TypeError(f'data is already tz-aware {inferred_tz}, unable to set specified tz: {tz}')
+    return tz
+
+def _validate_dt64_dtype(dtype):
+    if dtype is not None:
+        dtype = pandas_dtype(dtype)
+        if dtype == np.dtype('M8'):
+            msg = "Passing in 'datetime64' dtype with no precision is not allowed. Please pass in 'datetime64[ns]' instead."
+            raise ValueError(msg)
+        if isinstance(dtype, np.dtype) and (dtype.kind != 'M' or not is_supported_dtype(dtype)) or not isinstance(dtype, (np.dtype, DatetimeTZDtype)):
+            raise ValueError(f"Unexpected value for 'dtype': '{dtype}'. Must be 'datetime64[s]', 'datetime64[ms]', 'datetime64[us]', 'datetime64[ns]' or DatetimeTZDtype'.")
+        if getattr(dtype, 'tz', None):
+            dtype = cast(DatetimeTZDtype, dtype)
+            dtype = DatetimeTZDtype(unit=dtype.unit, tz=timezones.tz_standardize(dtype.tz))
+    return dtype
+
+def _validate_tz_from_dtype(dtype, tz: tzinfo | None, explicit_tz_none: bool=False) -> tzinfo | None:
+    if dtype is not None:
+        if isinstance(dtype, str):
+            try:
+                dtype = DatetimeTZDtype.construct_from_string(dtype)
+            except TypeError:
+                pass
+        dtz = getattr(dtype, 'tz', None)
+        if dtz is not None:
+            if tz is not None and (not timezones.tz_compare(tz, dtz)):
+                raise ValueError('cannot supply both a tz and a dtype with a tz')
+            if explicit_tz_none:
+                raise ValueError('Cannot pass both a timezone-aware dtype and tz=None')
+            tz = dtz
+        if tz is not None and lib.is_np_dtype(dtype, 'M'):
+            if tz is not None and (not timezones.tz_compare(tz, dtz)):
+                raise ValueError('cannot supply both a tz and a timezone-naive dtype (i.e. datetime64[ns])')
+    return tz
+
+def _infer_tz_from_endpoints(start: Timestamp, end: Timestamp, tz: tzinfo | None) -> tzinfo | None:
+    try:
+        inferred_tz = timezones.infer_tzinfo(start, end)
+    except AssertionError as err:
+        raise TypeError('Start and end cannot both be tz-aware with different timezones') from err
+    inferred_tz = timezones.maybe_get_tz(inferred_tz)
+    tz = timezones.maybe_get_tz(tz)
+    if tz is not None and inferred_tz is not None:
+        if not timezones.tz_compare(inferred_tz, tz):
+            raise AssertionError('Inferred time zone not equal to passed time zone')
+    elif inferred_tz is not None:
+        tz = inferred_tz
+    return tz
+
+def _maybe_normalize_endpoints(start: _TimestampNoneT1, end: _TimestampNoneT2, normalize: bool) -> tuple[_TimestampNoneT1, _TimestampNoneT2]:
+    if normalize:
+        if start is not None:
+            start = start.normalize()
+        if end is not None:
+            end = end.normalize()
+    return (start, end)
+
+def _maybe_localize_point(ts: Timestamp | None, freq, tz, ambiguous, nonexistent) -> Timestamp | None:
+    if ts is not None and ts.tzinfo is None:
+        ambiguous = ambiguous if ambiguous != 'infer' else False
+        localize_args = {'ambiguous': ambiguous, 'nonexistent': nonexistent, 'tz': None}
+        if isinstance(freq, Tick) or freq is None:
+            localize_args['tz'] = tz
+        ts = ts.tz_localize(**localize_args)
+    return ts
+
+def _generate_range(start: Timestamp | None, end: Timestamp | None, periods: int | None, offset: BaseOffset, *, unit: str) -> Generator[Timestamp, None, None]:
+    offset = to_offset(offset)
+    start = Timestamp(start)
+    if start is not NaT:
+        start = start.as_unit(unit)
+    else:
+        start = None
+    end = Timestamp(end)
+    if end is not NaT:
+        end = end.as_unit(unit)
+    else:
+        end = None
+    if start and (not offset.is_on_offset(start)):
+        if offset.n >= 0:
+            start = offset.rollforward(start)
+        else:
+            start = offset.rollback(start)
+    if periods is None and end < start and (offset.n >= 0):
+        end = None
+        periods = 0
+    if end is None:
+        end = start + (periods - 1) * offset
+    if start is None:
+        start = end - (periods - 1) * offset
+    start = cast(Timestamp, start)
+    end = cast(Timestamp, end)
+    cur = start
+    if offset.n >= 0:
+        while cur <= end:
+            yield cur
+            if cur == end:
+                break
+            next_date = offset._apply(cur)
+            next_date = next_date.as_unit(unit)
+            if next_date <= cur:
+                raise ValueError(f'Offset {offset} did not increment date')
+            cur = next_date
+    else:
+        while cur >= end:
+            yield cur
+            if cur == end:
+                break
+            next_date = offset._apply(cur)
+            next_date = next_date.as_unit(unit)
+            if next_date >= cur:
+                raise ValueError(f'Offset {offset} did not decrement date')
+            cur = next_date
+
+# File: pandas-main/pandas/core/arrays/floating.py
+from __future__ import annotations
+from typing import ClassVar
+import numpy as np
+from pandas.core.dtypes.base import register_extension_dtype
+from pandas.core.dtypes.common import is_float_dtype
+from pandas.core.arrays.numeric import NumericArray, NumericDtype
+
+class FloatingDtype(NumericDtype):
+    _internal_fill_value = np.nan
+    _default_np_dtype = np.dtype(np.float64)
+    _checker = is_float_dtype
+
+    @classmethod
+    def construct_array_type(cls) -> type[FloatingArray]:
+        return FloatingArray
+
+    @classmethod
+    def _get_dtype_mapping(cls) -> dict[np.dtype, FloatingDtype]:
+        return NUMPY_FLOAT_TO_DTYPE
+
+    @classmethod
+    def _safe_cast(cls, values: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
+        return values.astype(dtype, copy=copy)
+
+class FloatingArray(NumericArray):
+    _dtype_cls = FloatingDtype
+_dtype_docstring = '\nAn ExtensionDtype for {dtype} data.\n\nThis dtype uses ``pd.NA`` as missing value indicator.\n\nAttributes\n----------\nNone\n\nMethods\n-------\nNone\n\nSee Also\n--------\nCategoricalDtype : Type for categorical data with the categories and orderedness.\nIntegerDtype : An ExtensionDtype to hold a single size & kind of integer dtype.\nStringDtype : An ExtensionDtype for string data.\n\nExamples\n--------\nFor Float32Dtype:\n\n>>> ser = pd.Series([2.25, pd.NA], dtype=pd.Float32Dtype())\n>>> ser.dtype\nFloat32Dtype()\n\nFor Float64Dtype:\n\n>>> ser = pd.Series([2.25, pd.NA], dtype=pd.Float64Dtype())\n>>> ser.dtype\nFloat64Dtype()\n'
+
+@register_extension_dtype
+class Float32Dtype(FloatingDtype):
+    type = np.float32
+    name: ClassVar[str] = 'Float32'
+    __doc__ = _dtype_docstring.format(dtype='float32')
+
+@register_extension_dtype
+class Float64Dtype(FloatingDtype):
+    type = np.float64
+    name: ClassVar[str] = 'Float64'
+    __doc__ = _dtype_docstring.format(dtype='float64')
+NUMPY_FLOAT_TO_DTYPE: dict[np.dtype, FloatingDtype] = {np.dtype(np.float32): Float32Dtype(), np.dtype(np.float64): Float64Dtype()}
+
+# File: pandas-main/pandas/core/arrays/integer.py
+from __future__ import annotations
+from typing import ClassVar
+import numpy as np
+from pandas.core.dtypes.base import register_extension_dtype
+from pandas.core.dtypes.common import is_integer_dtype
+from pandas.core.arrays.numeric import NumericArray, NumericDtype
+
+class IntegerDtype(NumericDtype):
+    _internal_fill_value = 1
+    _default_np_dtype = np.dtype(np.int64)
+    _checker = is_integer_dtype
+
+    @classmethod
+    def construct_array_type(cls) -> type[IntegerArray]:
+        return IntegerArray
+
+    @classmethod
+    def _get_dtype_mapping(cls) -> dict[np.dtype, IntegerDtype]:
+        return NUMPY_INT_TO_DTYPE
+
+    @classmethod
+    def _safe_cast(cls, values: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
+        try:
+            return values.astype(dtype, casting='safe', copy=copy)
+        except TypeError as err:
+            casted = values.astype(dtype, copy=copy)
+            if (casted == values).all():
+                return casted
+            raise TypeError(f'cannot safely cast non-equivalent {values.dtype} to {np.dtype(dtype)}') from err
+
+class IntegerArray(NumericArray):
+    _dtype_cls = IntegerDtype
+_dtype_docstring = '\nAn ExtensionDtype for {dtype} integer data.\n\nUses :attr:`pandas.NA` as its missing value, rather than :attr:`numpy.nan`.\n\nAttributes\n----------\nNone\n\nMethods\n-------\nNone\n\nSee Also\n--------\nInt8Dtype : 8-bit nullable integer type.\nInt16Dtype : 16-bit nullable integer type.\nInt32Dtype : 32-bit nullable integer type.\nInt64Dtype : 64-bit nullable integer type.\n\nExamples\n--------\nFor Int8Dtype:\n\n>>> ser = pd.Series([2, pd.NA], dtype=pd.Int8Dtype())\n>>> ser.dtype\nInt8Dtype()\n\nFor Int16Dtype:\n\n>>> ser = pd.Series([2, pd.NA], dtype=pd.Int16Dtype())\n>>> ser.dtype\nInt16Dtype()\n\nFor Int32Dtype:\n\n>>> ser = pd.Series([2, pd.NA], dtype=pd.Int32Dtype())\n>>> ser.dtype\nInt32Dtype()\n\nFor Int64Dtype:\n\n>>> ser = pd.Series([2, pd.NA], dtype=pd.Int64Dtype())\n>>> ser.dtype\nInt64Dtype()\n\nFor UInt8Dtype:\n\n>>> ser = pd.Series([2, pd.NA], dtype=pd.UInt8Dtype())\n>>> ser.dtype\nUInt8Dtype()\n\nFor UInt16Dtype:\n\n>>> ser = pd.Series([2, pd.NA], dtype=pd.UInt16Dtype())\n>>> ser.dtype\nUInt16Dtype()\n\nFor UInt32Dtype:\n\n>>> ser = pd.Series([2, pd.NA], dtype=pd.UInt32Dtype())\n>>> ser.dtype\nUInt32Dtype()\n\nFor UInt64Dtype:\n\n>>> ser = pd.Series([2, pd.NA], dtype=pd.UInt64Dtype())\n>>> ser.dtype\nUInt64Dtype()\n'
+
+@register_extension_dtype
+class Int8Dtype(IntegerDtype):
+    type = np.int8
+    name: ClassVar[str] = 'Int8'
+    __doc__ = _dtype_docstring.format(dtype='int8')
+
+@register_extension_dtype
+class Int16Dtype(IntegerDtype):
+    type = np.int16
+    name: ClassVar[str] = 'Int16'
+    __doc__ = _dtype_docstring.format(dtype='int16')
+
+@register_extension_dtype
+class Int32Dtype(IntegerDtype):
+    type = np.int32
+    name: ClassVar[str] = 'Int32'
+    __doc__ = _dtype_docstring.format(dtype='int32')
+
+@register_extension_dtype
+class Int64Dtype(IntegerDtype):
+    type = np.int64
+    name: ClassVar[str] = 'Int64'
+    __doc__ = _dtype_docstring.format(dtype='int64')
+
+@register_extension_dtype
+class UInt8Dtype(IntegerDtype):
+    type = np.uint8
+    name: ClassVar[str] = 'UInt8'
+    __doc__ = _dtype_docstring.format(dtype='uint8')
+
+@register_extension_dtype
+class UInt16Dtype(IntegerDtype):
+    type = np.uint16
+    name: ClassVar[str] = 'UInt16'
+    __doc__ = _dtype_docstring.format(dtype='uint16')
+
+@register_extension_dtype
+class UInt32Dtype(IntegerDtype):
+    type = np.uint32
+    name: ClassVar[str] = 'UInt32'
+    __doc__ = _dtype_docstring.format(dtype='uint32')
+
+@register_extension_dtype
+class UInt64Dtype(IntegerDtype):
+    type = np.uint64
+    name: ClassVar[str] = 'UInt64'
+    __doc__ = _dtype_docstring.format(dtype='uint64')
+NUMPY_INT_TO_DTYPE: dict[np.dtype, IntegerDtype] = {np.dtype(np.int8): Int8Dtype(), np.dtype(np.int16): Int16Dtype(), np.dtype(np.int32): Int32Dtype(), np.dtype(np.int64): Int64Dtype(), np.dtype(np.uint8): UInt8Dtype(), np.dtype(np.uint16): UInt16Dtype(), np.dtype(np.uint32): UInt32Dtype(), np.dtype(np.uint64): UInt64Dtype()}
+
+# File: pandas-main/pandas/core/arrays/interval.py
+from __future__ import annotations
+import operator
+from operator import le, lt
+import textwrap
+from typing import TYPE_CHECKING, Literal, Union, overload
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.interval import VALID_CLOSED, Interval, IntervalMixin, intervals_to_interval_bounds
+from pandas._libs.missing import NA
+from pandas._typing import ArrayLike, AxisInt, Dtype, IntervalClosedType, NpDtype, PositionalIndexer, ScalarIndexer, Self, SequenceIndexer, SortKind, TimeArrayLike, npt
+from pandas.compat.numpy import function as nv
+from pandas.errors import IntCastingNaNError
+from pandas.util._decorators import Appender
+from pandas.core.dtypes.cast import LossySetitemError, maybe_upcast_numeric_to_64bit
+from pandas.core.dtypes.common import is_float_dtype, is_integer_dtype, is_list_like, is_object_dtype, is_scalar, is_string_dtype, needs_i8_conversion, pandas_dtype
+from pandas.core.dtypes.dtypes import CategoricalDtype, IntervalDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCDatetimeIndex, ABCIntervalIndex, ABCPeriodIndex
+from pandas.core.dtypes.missing import is_valid_na_for_dtype, isna, notna
+from pandas.core.algorithms import isin, take, unique, value_counts_internal as value_counts
+from pandas.core.arrays import ArrowExtensionArray
+from pandas.core.arrays.base import ExtensionArray, _extension_array_shared_docs
+from pandas.core.arrays.datetimes import DatetimeArray
+from pandas.core.arrays.timedeltas import TimedeltaArray
+import pandas.core.common as com
+from pandas.core.construction import array as pd_array, ensure_wrapped_if_datetimelike, extract_array
+from pandas.core.indexers import check_array_indexer
+from pandas.core.ops import invalid_comparison, unpack_zerodim_and_defer
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator, Sequence
+    from pandas import Index, Series
+IntervalSide = Union[TimeArrayLike, np.ndarray]
+IntervalOrNA = Union[Interval, float]
+_interval_shared_docs: dict[str, str] = {}
+_shared_docs_kwargs = {'klass': 'IntervalArray', 'qualname': 'arrays.IntervalArray', 'name': ''}
+_interval_shared_docs['class'] = "\n%(summary)s\n\nParameters\n----------\ndata : array-like (1-dimensional)\n    Array-like (ndarray, :class:`DateTimeArray`, :class:`TimeDeltaArray`) containing\n    Interval objects from which to build the %(klass)s.\nclosed : {'left', 'right', 'both', 'neither'}, default 'right'\n    Whether the intervals are closed on the left-side, right-side, both or\n    neither.\ndtype : dtype or None, default None\n    If None, dtype will be inferred.\ncopy : bool, default False\n    Copy the input data.\n%(name)sverify_integrity : bool, default True\n    Verify that the %(klass)s is valid.\n\nAttributes\n----------\nleft\nright\nclosed\nmid\nlength\nis_empty\nis_non_overlapping_monotonic\n%(extra_attributes)s\nMethods\n-------\nfrom_arrays\nfrom_tuples\nfrom_breaks\ncontains\noverlaps\nset_closed\nto_tuples\n%(extra_methods)s\nSee Also\n--------\nIndex : The base pandas Index type.\nInterval : A bounded slice-like interval; the elements of an %(klass)s.\ninterval_range : Function to create a fixed frequency IntervalIndex.\ncut : Bin values into discrete Intervals.\nqcut : Bin values into equal-sized Intervals based on rank or sample quantiles.\n\nNotes\n-----\nSee the `user guide\n<https://pandas.pydata.org/pandas-docs/stable/user_guide/advanced.html#intervalindex>`__\nfor more.\n\n%(examples)s"
+
+@Appender(_interval_shared_docs['class'] % {'klass': 'IntervalArray', 'summary': 'Pandas array for interval data that are closed on the same side.', 'name': '', 'extra_attributes': '', 'extra_methods': '', 'examples': textwrap.dedent('    Examples\n    --------\n    A new ``IntervalArray`` can be constructed directly from an array-like of\n    ``Interval`` objects:\n\n    >>> pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)])\n    <IntervalArray>\n    [(0, 1], (1, 5]]\n    Length: 2, dtype: interval[int64, right]\n\n    It may also be constructed using one of the constructor\n    methods: :meth:`IntervalArray.from_arrays`,\n    :meth:`IntervalArray.from_breaks`, and :meth:`IntervalArray.from_tuples`.\n    ')})
+class IntervalArray(IntervalMixin, ExtensionArray):
+    can_hold_na = True
+    _na_value = _fill_value = np.nan
+
+    @property
+    def ndim(self) -> Literal[1]:
+        return 1
+    _left: IntervalSide
+    _right: IntervalSide
+    _dtype: IntervalDtype
+
+    def __new__(cls, data, closed: IntervalClosedType | None=None, dtype: Dtype | None=None, copy: bool=False, verify_integrity: bool=True) -> Self:
+        data = extract_array(data, extract_numpy=True)
+        if isinstance(data, cls):
+            left: IntervalSide = data._left
+            right: IntervalSide = data._right
+            closed = closed or data.closed
+            dtype = IntervalDtype(left.dtype, closed=closed)
+        else:
+            if is_scalar(data):
+                msg = f'{cls.__name__}(...) must be called with a collection of some kind, {data} was passed'
+                raise TypeError(msg)
+            data = _maybe_convert_platform_interval(data)
+            (left, right, infer_closed) = intervals_to_interval_bounds(data, validate_closed=closed is None)
+            if left.dtype == object:
+                left = lib.maybe_convert_objects(left)
+                right = lib.maybe_convert_objects(right)
+            closed = closed or infer_closed
+            (left, right, dtype) = cls._ensure_simple_new_inputs(left, right, closed=closed, copy=copy, dtype=dtype)
+        if verify_integrity:
+            cls._validate(left, right, dtype=dtype)
+        return cls._simple_new(left, right, dtype=dtype)
+
+    @classmethod
+    def _simple_new(cls, left: IntervalSide, right: IntervalSide, dtype: IntervalDtype) -> Self:
+        result = IntervalMixin.__new__(cls)
+        result._left = left
+        result._right = right
+        result._dtype = dtype
+        return result
+
+    @classmethod
+    def _ensure_simple_new_inputs(cls, left, right, closed: IntervalClosedType | None=None, copy: bool=False, dtype: Dtype | None=None) -> tuple[IntervalSide, IntervalSide, IntervalDtype]:
+        from pandas.core.indexes.base import ensure_index
+        left = ensure_index(left, copy=copy)
+        left = maybe_upcast_numeric_to_64bit(left)
+        right = ensure_index(right, copy=copy)
+        right = maybe_upcast_numeric_to_64bit(right)
+        if closed is None and isinstance(dtype, IntervalDtype):
+            closed = dtype.closed
+        closed = closed or 'right'
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+            if isinstance(dtype, IntervalDtype):
+                if dtype.subtype is not None:
+                    left = left.astype(dtype.subtype)
+                    right = right.astype(dtype.subtype)
+            else:
+                msg = f'dtype must be an IntervalDtype, got {dtype}'
+                raise TypeError(msg)
+            if dtype.closed is None:
+                dtype = IntervalDtype(dtype.subtype, closed)
+            elif closed != dtype.closed:
+                raise ValueError('closed keyword does not match dtype.closed')
+        if is_float_dtype(left.dtype) and is_integer_dtype(right.dtype):
+            right = right.astype(left.dtype)
+        elif is_float_dtype(right.dtype) and is_integer_dtype(left.dtype):
+            left = left.astype(right.dtype)
+        if type(left) != type(right):
+            msg = f'must not have differing left [{type(left).__name__}] and right [{type(right).__name__}] types'
+            raise ValueError(msg)
+        if isinstance(left.dtype, CategoricalDtype) or is_string_dtype(left.dtype):
+            msg = 'category, object, and string subtypes are not supported for IntervalArray'
+            raise TypeError(msg)
+        if isinstance(left, ABCPeriodIndex):
+            msg = 'Period dtypes are not supported, use a PeriodIndex instead'
+            raise ValueError(msg)
+        if isinstance(left, ABCDatetimeIndex) and str(left.tz) != str(right.tz):
+            msg = f"left and right must have the same time zone, got '{left.tz}' and '{right.tz}'"
+            raise ValueError(msg)
+        elif needs_i8_conversion(left.dtype) and left.unit != right.unit:
+            (left_arr, right_arr) = left._data._ensure_matching_resos(right._data)
+            left = ensure_index(left_arr)
+            right = ensure_index(right_arr)
+        left = ensure_wrapped_if_datetimelike(left)
+        left = extract_array(left, extract_numpy=True)
+        right = ensure_wrapped_if_datetimelike(right)
+        right = extract_array(right, extract_numpy=True)
+        if isinstance(left, ArrowExtensionArray) or isinstance(right, ArrowExtensionArray):
+            pass
+        else:
+            lbase = getattr(left, '_ndarray', left)
+            lbase = getattr(lbase, '_data', lbase).base
+            rbase = getattr(right, '_ndarray', right)
+            rbase = getattr(rbase, '_data', rbase).base
+            if lbase is not None and lbase is rbase:
+                right = right.copy()
+        dtype = IntervalDtype(left.dtype, closed=closed)
+        return (left, right, dtype)
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype: Dtype | None=None, copy: bool=False) -> Self:
+        return cls(scalars, dtype=dtype, copy=copy)
+
+    @classmethod
+    def _from_factorized(cls, values: np.ndarray, original: IntervalArray) -> Self:
+        return cls._from_sequence(values, dtype=original.dtype)
+    _interval_shared_docs['from_breaks'] = textwrap.dedent("\n        Construct an %(klass)s from an array of splits.\n\n        Parameters\n        ----------\n        breaks : array-like (1-dimensional)\n            Left and right bounds for each interval.\n        closed : {'left', 'right', 'both', 'neither'}, default 'right'\n            Whether the intervals are closed on the left-side, right-side, both\n            or neither.        %(name)s\n        copy : bool, default False\n            Copy the data.\n        dtype : dtype or None, default None\n            If None, dtype will be inferred.\n\n        Returns\n        -------\n        %(klass)s\n\n        See Also\n        --------\n        interval_range : Function to create a fixed frequency IntervalIndex.\n        %(klass)s.from_arrays : Construct from a left and right array.\n        %(klass)s.from_tuples : Construct from a sequence of tuples.\n\n        %(examples)s        ")
+
+    @classmethod
+    @Appender(_interval_shared_docs['from_breaks'] % {'klass': 'IntervalArray', 'name': '', 'examples': textwrap.dedent('        Examples\n        --------\n        >>> pd.arrays.IntervalArray.from_breaks([0, 1, 2, 3])\n        <IntervalArray>\n        [(0, 1], (1, 2], (2, 3]]\n        Length: 3, dtype: interval[int64, right]\n        ')})
+    def from_breaks(cls, breaks, closed: IntervalClosedType | None='right', copy: bool=False, dtype: Dtype | None=None) -> Self:
+        breaks = _maybe_convert_platform_interval(breaks)
+        return cls.from_arrays(breaks[:-1], breaks[1:], closed, copy=copy, dtype=dtype)
+    _interval_shared_docs['from_arrays'] = textwrap.dedent("\n        Construct from two arrays defining the left and right bounds.\n\n        Parameters\n        ----------\n        left : array-like (1-dimensional)\n            Left bounds for each interval.\n        right : array-like (1-dimensional)\n            Right bounds for each interval.\n        closed : {'left', 'right', 'both', 'neither'}, default 'right'\n            Whether the intervals are closed on the left-side, right-side, both\n            or neither.        %(name)s\n        copy : bool, default False\n            Copy the data.\n        dtype : dtype, optional\n            If None, dtype will be inferred.\n\n        Returns\n        -------\n        %(klass)s\n\n        Raises\n        ------\n        ValueError\n            When a value is missing in only one of `left` or `right`.\n            When a value in `left` is greater than the corresponding value\n            in `right`.\n\n        See Also\n        --------\n        interval_range : Function to create a fixed frequency IntervalIndex.\n        %(klass)s.from_breaks : Construct an %(klass)s from an array of\n            splits.\n        %(klass)s.from_tuples : Construct an %(klass)s from an\n            array-like of tuples.\n\n        Notes\n        -----\n        Each element of `left` must be less than or equal to the `right`\n        element at the same position. If an element is missing, it must be\n        missing in both `left` and `right`. A TypeError is raised when\n        using an unsupported type for `left` or `right`. At the moment,\n        'category', 'object', and 'string' subtypes are not supported.\n\n        %(examples)s        ")
+
+    @classmethod
+    @Appender(_interval_shared_docs['from_arrays'] % {'klass': 'IntervalArray', 'name': '', 'examples': textwrap.dedent('        Examples\n        --------\n        >>> pd.arrays.IntervalArray.from_arrays([0, 1, 2], [1, 2, 3])\n        <IntervalArray>\n        [(0, 1], (1, 2], (2, 3]]\n        Length: 3, dtype: interval[int64, right]\n        ')})
+    def from_arrays(cls, left, right, closed: IntervalClosedType | None='right', copy: bool=False, dtype: Dtype | None=None) -> Self:
+        left = _maybe_convert_platform_interval(left)
+        right = _maybe_convert_platform_interval(right)
+        (left, right, dtype) = cls._ensure_simple_new_inputs(left, right, closed=closed, copy=copy, dtype=dtype)
+        cls._validate(left, right, dtype=dtype)
+        return cls._simple_new(left, right, dtype=dtype)
+    _interval_shared_docs['from_tuples'] = textwrap.dedent("\n        Construct an %(klass)s from an array-like of tuples.\n\n        Parameters\n        ----------\n        data : array-like (1-dimensional)\n            Array of tuples.\n        closed : {'left', 'right', 'both', 'neither'}, default 'right'\n            Whether the intervals are closed on the left-side, right-side, both\n            or neither.        %(name)s\n        copy : bool, default False\n            By-default copy the data, this is compat only and ignored.\n        dtype : dtype or None, default None\n            If None, dtype will be inferred.\n\n        Returns\n        -------\n        %(klass)s\n\n        See Also\n        --------\n        interval_range : Function to create a fixed frequency IntervalIndex.\n        %(klass)s.from_arrays : Construct an %(klass)s from a left and\n                                    right array.\n        %(klass)s.from_breaks : Construct an %(klass)s from an array of\n                                    splits.\n\n        %(examples)s        ")
+
+    @classmethod
+    @Appender(_interval_shared_docs['from_tuples'] % {'klass': 'IntervalArray', 'name': '', 'examples': textwrap.dedent('        Examples\n        --------\n        >>> pd.arrays.IntervalArray.from_tuples([(0, 1), (1, 2)])\n        <IntervalArray>\n        [(0, 1], (1, 2]]\n        Length: 2, dtype: interval[int64, right]\n        ')})
+    def from_tuples(cls, data, closed: IntervalClosedType | None='right', copy: bool=False, dtype: Dtype | None=None) -> Self:
+        if len(data):
+            (left, right) = ([], [])
+        else:
+            left = right = data
+        for d in data:
+            if not isinstance(d, tuple) and isna(d):
+                lhs = rhs = np.nan
+            else:
+                name = cls.__name__
+                try:
+                    (lhs, rhs) = d
+                except ValueError as err:
+                    msg = f'{name}.from_tuples requires tuples of length 2, got {d}'
+                    raise ValueError(msg) from err
+                except TypeError as err:
+                    msg = f'{name}.from_tuples received an invalid item, {d}'
+                    raise TypeError(msg) from err
+            left.append(lhs)
+            right.append(rhs)
+        return cls.from_arrays(left, right, closed, copy=False, dtype=dtype)
+
+    @classmethod
+    def _validate(cls, left, right, dtype: IntervalDtype) -> None:
+        if not isinstance(dtype, IntervalDtype):
+            msg = f'invalid dtype: {dtype}'
+            raise ValueError(msg)
+        if len(left) != len(right):
+            msg = 'left and right must have the same length'
+            raise ValueError(msg)
+        left_mask = notna(left)
+        right_mask = notna(right)
+        if not (left_mask == right_mask).all():
+            msg = 'missing values must be missing in the same location both left and right sides'
+            raise ValueError(msg)
+        if not (left[left_mask] <= right[left_mask]).all():
+            msg = 'left side of interval must be <= right side'
+            raise ValueError(msg)
+
+    def _shallow_copy(self, left, right) -> Self:
+        dtype = IntervalDtype(left.dtype, closed=self.closed)
+        (left, right, dtype) = self._ensure_simple_new_inputs(left, right, dtype=dtype)
+        return self._simple_new(left, right, dtype=dtype)
+
+    @property
+    def dtype(self) -> IntervalDtype:
+        return self._dtype
+
+    @property
+    def nbytes(self) -> int:
+        return self.left.nbytes + self.right.nbytes
+
+    @property
+    def size(self) -> int:
+        return self.left.size
+
+    def __iter__(self) -> Iterator:
+        return iter(np.asarray(self))
+
+    def __len__(self) -> int:
+        return len(self._left)
+
+    @overload
+    def __getitem__(self, key: ScalarIndexer) -> IntervalOrNA:
+        ...
+
+    @overload
+    def __getitem__(self, key: SequenceIndexer) -> Self:
+        ...
+
+    def __getitem__(self, key: PositionalIndexer) -> Self | IntervalOrNA:
+        key = check_array_indexer(self, key)
+        left = self._left[key]
+        right = self._right[key]
+        if not isinstance(left, (np.ndarray, ExtensionArray)):
+            if is_scalar(left) and isna(left):
+                return self._fill_value
+            return Interval(left, right, self.closed)
+        if np.ndim(left) > 1:
+            raise ValueError('multi-dimensional indexing not allowed')
+        return self._simple_new(left, right, dtype=self.dtype)
+
+    def __setitem__(self, key, value) -> None:
+        (value_left, value_right) = self._validate_setitem_value(value)
+        key = check_array_indexer(self, key)
+        self._left[key] = value_left
+        self._right[key] = value_right
+
+    def _cmp_method(self, other, op):
+        if is_list_like(other):
+            if len(self) != len(other):
+                raise ValueError('Lengths must match to compare')
+            other = pd_array(other)
+        elif not isinstance(other, Interval):
+            if other is NA:
+                from pandas.core.arrays import BooleanArray
+                arr = np.empty(self.shape, dtype=bool)
+                mask = np.ones(self.shape, dtype=bool)
+                return BooleanArray(arr, mask)
+            return invalid_comparison(self, other, op)
+        if isinstance(other, Interval):
+            other_dtype = pandas_dtype('interval')
+        elif not isinstance(other.dtype, CategoricalDtype):
+            other_dtype = other.dtype
+        else:
+            other_dtype = other.categories.dtype
+            if isinstance(other_dtype, IntervalDtype):
+                if self.closed != other.categories.closed:
+                    return invalid_comparison(self, other, op)
+                other = other.categories._values.take(other.codes, allow_fill=True, fill_value=other.categories._na_value)
+        if isinstance(other_dtype, IntervalDtype):
+            if self.closed != other.closed:
+                return invalid_comparison(self, other, op)
+            elif not isinstance(other, Interval):
+                other = type(self)(other)
+            if op is operator.eq:
+                return (self._left == other.left) & (self._right == other.right)
+            elif op is operator.ne:
+                return (self._left != other.left) | (self._right != other.right)
+            elif op is operator.gt:
+                return (self._left > other.left) | (self._left == other.left) & (self._right > other.right)
+            elif op is operator.ge:
+                return (self == other) | (self > other)
+            elif op is operator.lt:
+                return (self._left < other.left) | (self._left == other.left) & (self._right < other.right)
+            else:
+                return (self == other) | (self < other)
+        if not is_object_dtype(other_dtype):
+            return invalid_comparison(self, other, op)
+        result = np.zeros(len(self), dtype=bool)
+        for (i, obj) in enumerate(other):
+            try:
+                result[i] = op(self[i], obj)
+            except TypeError:
+                if obj is NA:
+                    result = result.astype(object)
+                    result[i] = NA
+                else:
+                    raise
+        return result
+
+    @unpack_zerodim_and_defer('__eq__')
+    def __eq__(self, other):
+        return self._cmp_method(other, operator.eq)
+
+    @unpack_zerodim_and_defer('__ne__')
+    def __ne__(self, other):
+        return self._cmp_method(other, operator.ne)
+
+    @unpack_zerodim_and_defer('__gt__')
+    def __gt__(self, other):
+        return self._cmp_method(other, operator.gt)
+
+    @unpack_zerodim_and_defer('__ge__')
+    def __ge__(self, other):
+        return self._cmp_method(other, operator.ge)
+
+    @unpack_zerodim_and_defer('__lt__')
+    def __lt__(self, other):
+        return self._cmp_method(other, operator.lt)
+
+    @unpack_zerodim_and_defer('__le__')
+    def __le__(self, other):
+        return self._cmp_method(other, operator.le)
+
+    def argsort(self, *, ascending: bool=True, kind: SortKind='quicksort', na_position: str='last', **kwargs) -> np.ndarray:
+        ascending = nv.validate_argsort_with_ascending(ascending, (), kwargs)
+        if ascending and kind == 'quicksort' and (na_position == 'last'):
+            return np.lexsort((self.right, self.left))
+        return super().argsort(ascending=ascending, kind=kind, na_position=na_position, **kwargs)
+
+    def min(self, *, axis: AxisInt | None=None, skipna: bool=True) -> IntervalOrNA:
+        nv.validate_minmax_axis(axis, self.ndim)
+        if not len(self):
+            return self._na_value
+        mask = self.isna()
+        if mask.any():
+            if not skipna:
+                return self._na_value
+            obj = self[~mask]
+        else:
+            obj = self
+        indexer = obj.argsort()[0]
+        return obj[indexer]
+
+    def max(self, *, axis: AxisInt | None=None, skipna: bool=True) -> IntervalOrNA:
+        nv.validate_minmax_axis(axis, self.ndim)
+        if not len(self):
+            return self._na_value
+        mask = self.isna()
+        if mask.any():
+            if not skipna:
+                return self._na_value
+            obj = self[~mask]
+        else:
+            obj = self
+        indexer = obj.argsort()[-1]
+        return obj[indexer]
+
+    def fillna(self, value, limit: int | None=None, copy: bool=True) -> Self:
+        if copy is False:
+            raise NotImplementedError
+        if limit is not None:
+            raise ValueError('limit must be None')
+        (value_left, value_right) = self._validate_scalar(value)
+        left = self.left.fillna(value=value_left)
+        right = self.right.fillna(value=value_right)
+        return self._shallow_copy(left, right)
+
+    def astype(self, dtype, copy: bool=True):
+        from pandas import Index
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+        if isinstance(dtype, IntervalDtype):
+            if dtype == self.dtype:
+                return self.copy() if copy else self
+            if is_float_dtype(self.dtype.subtype) and needs_i8_conversion(dtype.subtype):
+                msg = f'Cannot convert {self.dtype} to {dtype}; subtypes are incompatible'
+                raise TypeError(msg)
+            try:
+                new_left = Index(self._left, copy=False).astype(dtype.subtype)
+                new_right = Index(self._right, copy=False).astype(dtype.subtype)
+            except IntCastingNaNError:
+                raise
+            except (TypeError, ValueError) as err:
+                msg = f'Cannot convert {self.dtype} to {dtype}; subtypes are incompatible'
+                raise TypeError(msg) from err
+            return self._shallow_copy(new_left, new_right)
+        else:
+            try:
+                return super().astype(dtype, copy=copy)
+            except (TypeError, ValueError) as err:
+                msg = f'Cannot cast {type(self).__name__} to dtype {dtype}'
+                raise TypeError(msg) from err
+
+    def equals(self, other) -> bool:
+        if type(self) != type(other):
+            return False
+        return bool(self.closed == other.closed and self.left.equals(other.left) and self.right.equals(other.right))
+
+    @classmethod
+    def _concat_same_type(cls, to_concat: Sequence[IntervalArray]) -> Self:
+        closed_set = {interval.closed for interval in to_concat}
+        if len(closed_set) != 1:
+            raise ValueError('Intervals must all be closed on the same side.')
+        closed = closed_set.pop()
+        left: IntervalSide = np.concatenate([interval.left for interval in to_concat])
+        right: IntervalSide = np.concatenate([interval.right for interval in to_concat])
+        (left, right, dtype) = cls._ensure_simple_new_inputs(left, right, closed=closed)
+        return cls._simple_new(left, right, dtype=dtype)
+
+    def copy(self) -> Self:
+        left = self._left.copy()
+        right = self._right.copy()
+        dtype = self.dtype
+        return self._simple_new(left, right, dtype=dtype)
+
+    def isna(self) -> np.ndarray:
+        return isna(self._left)
+
+    def shift(self, periods: int=1, fill_value: object=None) -> IntervalArray:
+        if not len(self) or periods == 0:
+            return self.copy()
+        self._validate_scalar(fill_value)
+        empty_len = min(abs(periods), len(self))
+        if isna(fill_value):
+            from pandas import Index
+            fill_value = Index(self._left, copy=False)._na_value
+            empty = IntervalArray.from_breaks([fill_value] * (empty_len + 1))
+        else:
+            empty = self._from_sequence([fill_value] * empty_len, dtype=self.dtype)
+        if periods > 0:
+            a = empty
+            b = self[:-periods]
+        else:
+            a = self[abs(periods):]
+            b = empty
+        return self._concat_same_type([a, b])
+
+    def take(self, indices, *, allow_fill: bool=False, fill_value=None, axis=None, **kwargs) -> Self:
+        nv.validate_take((), kwargs)
+        fill_left = fill_right = fill_value
+        if allow_fill:
+            (fill_left, fill_right) = self._validate_scalar(fill_value)
+        left_take = take(self._left, indices, allow_fill=allow_fill, fill_value=fill_left)
+        right_take = take(self._right, indices, allow_fill=allow_fill, fill_value=fill_right)
+        return self._shallow_copy(left_take, right_take)
+
+    def _validate_listlike(self, value):
+        try:
+            array = IntervalArray(value)
+            self._check_closed_matches(array, name='value')
+            (value_left, value_right) = (array.left, array.right)
+        except TypeError as err:
+            msg = f"'value' should be an interval type, got {type(value)} instead."
+            raise TypeError(msg) from err
+        try:
+            self.left._validate_fill_value(value_left)
+        except (LossySetitemError, TypeError) as err:
+            msg = f"'value' should be a compatible interval type, got {type(value)} instead."
+            raise TypeError(msg) from err
+        return (value_left, value_right)
+
+    def _validate_scalar(self, value):
+        if isinstance(value, Interval):
+            self._check_closed_matches(value, name='value')
+            (left, right) = (value.left, value.right)
+        elif is_valid_na_for_dtype(value, self.left.dtype):
+            left = right = self.left._na_value
+        else:
+            raise TypeError('can only insert Interval objects and NA into an IntervalArray')
+        return (left, right)
+
+    def _validate_setitem_value(self, value):
+        if is_valid_na_for_dtype(value, self.left.dtype):
+            value = self.left._na_value
+            if is_integer_dtype(self.dtype.subtype):
+                raise TypeError('Cannot set float NaN to integer-backed IntervalArray')
+            (value_left, value_right) = (value, value)
+        elif isinstance(value, Interval):
+            self._check_closed_matches(value, name='value')
+            (value_left, value_right) = (value.left, value.right)
+            self.left._validate_fill_value(value_left)
+            self.left._validate_fill_value(value_right)
+        else:
+            return self._validate_listlike(value)
+        return (value_left, value_right)
+
+    def value_counts(self, dropna: bool=True) -> Series:
+        result = value_counts(np.asarray(self), dropna=dropna)
+        result.index = result.index.astype(self.dtype)
+        return result
+
+    def _formatter(self, boxed: bool=False) -> Callable[[object], str]:
+        return str
+
+    @property
+    def left(self) -> Index:
+        from pandas import Index
+        return Index(self._left, copy=False)
+
+    @property
+    def right(self) -> Index:
+        from pandas import Index
+        return Index(self._right, copy=False)
+
+    @property
+    def length(self) -> Index:
+        return self.right - self.left
+
+    @property
+    def mid(self) -> Index:
+        try:
+            return 0.5 * (self.left + self.right)
+        except TypeError:
+            return self.left + 0.5 * self.length
+    _interval_shared_docs['overlaps'] = textwrap.dedent("\n        Check elementwise if an Interval overlaps the values in the %(klass)s.\n\n        Two intervals overlap if they share a common point, including closed\n        endpoints. Intervals that only have an open endpoint in common do not\n        overlap.\n\n        Parameters\n        ----------\n        other : %(klass)s\n            Interval to check against for an overlap.\n\n        Returns\n        -------\n        ndarray\n            Boolean array positionally indicating where an overlap occurs.\n\n        See Also\n        --------\n        Interval.overlaps : Check whether two Interval objects overlap.\n\n        Examples\n        --------\n        %(examples)s\n        >>> intervals.overlaps(pd.Interval(0.5, 1.5))\n        array([ True,  True, False])\n\n        Intervals that share closed endpoints overlap:\n\n        >>> intervals.overlaps(pd.Interval(1, 3, closed='left'))\n        array([ True,  True, True])\n\n        Intervals that only have an open endpoint in common do not overlap:\n\n        >>> intervals.overlaps(pd.Interval(1, 2, closed='right'))\n        array([False,  True, False])\n        ")
+
+    @Appender(_interval_shared_docs['overlaps'] % {'klass': 'IntervalArray', 'examples': textwrap.dedent('        >>> data = [(0, 1), (1, 3), (2, 4)]\n        >>> intervals = pd.arrays.IntervalArray.from_tuples(data)\n        >>> intervals\n        <IntervalArray>\n        [(0, 1], (1, 3], (2, 4]]\n        Length: 3, dtype: interval[int64, right]\n        ')})
+    def overlaps(self, other):
+        if isinstance(other, (IntervalArray, ABCIntervalIndex)):
+            raise NotImplementedError
+        if not isinstance(other, Interval):
+            msg = f'`other` must be Interval-like, got {type(other).__name__}'
+            raise TypeError(msg)
+        op1 = le if self.closed_left and other.closed_right else lt
+        op2 = le if other.closed_left and self.closed_right else lt
+        return op1(self.left, other.right) & op2(other.left, self.right)
+
+    @property
+    def closed(self) -> IntervalClosedType:
+        return self.dtype.closed
+    _interval_shared_docs['set_closed'] = textwrap.dedent("\n        Return an identical %(klass)s closed on the specified side.\n\n        Parameters\n        ----------\n        closed : {'left', 'right', 'both', 'neither'}\n            Whether the intervals are closed on the left-side, right-side, both\n            or neither.\n\n        Returns\n        -------\n        %(klass)s\n\n        %(examples)s        ")
+
+    def set_closed(self, closed: IntervalClosedType) -> Self:
+        if closed not in VALID_CLOSED:
+            msg = f"invalid option for 'closed': {closed}"
+            raise ValueError(msg)
+        (left, right) = (self._left, self._right)
+        dtype = IntervalDtype(left.dtype, closed=closed)
+        return self._simple_new(left, right, dtype=dtype)
+    _interval_shared_docs['is_non_overlapping_monotonic'] = "\n        Return a boolean whether the %(klass)s is non-overlapping and monotonic.\n\n        Non-overlapping means (no Intervals share points), and monotonic means\n        either monotonic increasing or monotonic decreasing.\n\n        Examples\n        --------\n        For arrays:\n\n        >>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1), pd.Interval(1, 5)])\n        >>> interv_arr\n        <IntervalArray>\n        [(0, 1], (1, 5]]\n        Length: 2, dtype: interval[int64, right]\n        >>> interv_arr.is_non_overlapping_monotonic\n        True\n\n        >>> interv_arr = pd.arrays.IntervalArray([pd.Interval(0, 1),\n        ...                                       pd.Interval(-1, 0.1)])\n        >>> interv_arr\n        <IntervalArray>\n        [(0.0, 1.0], (-1.0, 0.1]]\n        Length: 2, dtype: interval[float64, right]\n        >>> interv_arr.is_non_overlapping_monotonic\n        False\n\n        For Interval Index:\n\n        >>> interv_idx = pd.interval_range(start=0, end=2)\n        >>> interv_idx\n        IntervalIndex([(0, 1], (1, 2]], dtype='interval[int64, right]')\n        >>> interv_idx.is_non_overlapping_monotonic\n        True\n\n        >>> interv_idx = pd.interval_range(start=0, end=2, closed='both')\n        >>> interv_idx\n        IntervalIndex([[0, 1], [1, 2]], dtype='interval[int64, both]')\n        >>> interv_idx.is_non_overlapping_monotonic\n        False\n        "
+
+    @property
+    def is_non_overlapping_monotonic(self) -> bool:
+        if self.closed == 'both':
+            return bool((self._right[:-1] < self._left[1:]).all() or (self._left[:-1] > self._right[1:]).all())
+        return bool((self._right[:-1] <= self._left[1:]).all() or (self._left[:-1] >= self._right[1:]).all())
+
+    def __array__(self, dtype: NpDtype | None=None, copy: bool | None=None) -> np.ndarray:
+        left = self._left
+        right = self._right
+        mask = self.isna()
+        closed = self.closed
+        result = np.empty(len(left), dtype=object)
+        for (i, left_value) in enumerate(left):
+            if mask[i]:
+                result[i] = np.nan
+            else:
+                result[i] = Interval(left_value, right[i], closed)
+        return result
+
+    def __arrow_array__(self, type=None):
+        import pyarrow
+        from pandas.core.arrays.arrow.extension_types import ArrowIntervalType
+        try:
+            subtype = pyarrow.from_numpy_dtype(self.dtype.subtype)
+        except TypeError as err:
+            raise TypeError(f"Conversion to arrow with subtype '{self.dtype.subtype}' is not supported") from err
+        interval_type = ArrowIntervalType(subtype, self.closed)
+        storage_array = pyarrow.StructArray.from_arrays([pyarrow.array(self._left, type=subtype, from_pandas=True), pyarrow.array(self._right, type=subtype, from_pandas=True)], names=['left', 'right'])
+        mask = self.isna()
+        if mask.any():
+            null_bitmap = pyarrow.array(~mask).buffers()[1]
+            storage_array = pyarrow.StructArray.from_buffers(storage_array.type, len(storage_array), [null_bitmap], children=[storage_array.field(0), storage_array.field(1)])
+        if type is not None:
+            if type.equals(interval_type.storage_type):
+                return storage_array
+            elif isinstance(type, ArrowIntervalType):
+                if not type.equals(interval_type):
+                    raise TypeError(f"Not supported to convert IntervalArray to type with different 'subtype' ({self.dtype.subtype} vs {type.subtype}) and 'closed' ({self.closed} vs {type.closed}) attributes")
+            else:
+                raise TypeError(f"Not supported to convert IntervalArray to '{type}' type")
+        return pyarrow.ExtensionArray.from_storage(interval_type, storage_array)
+    _interval_shared_docs['to_tuples'] = textwrap.dedent('\n        Return an %(return_type)s of tuples of the form (left, right).\n\n        Parameters\n        ----------\n        na_tuple : bool, default True\n            If ``True``, return ``NA`` as a tuple ``(nan, nan)``. If ``False``,\n            just return ``NA`` as ``nan``.\n\n        Returns\n        -------\n        tuples: %(return_type)s\n        %(examples)s        ')
+
+    def to_tuples(self, na_tuple: bool=True) -> np.ndarray:
+        tuples = com.asarray_tuplesafe(zip(self._left, self._right))
+        if not na_tuple:
+            tuples = np.where(~self.isna(), tuples, np.nan)
+        return tuples
+
+    def _putmask(self, mask: npt.NDArray[np.bool_], value) -> None:
+        (value_left, value_right) = self._validate_setitem_value(value)
+        if isinstance(self._left, np.ndarray):
+            np.putmask(self._left, mask, value_left)
+            assert isinstance(self._right, np.ndarray)
+            np.putmask(self._right, mask, value_right)
+        else:
+            self._left._putmask(mask, value_left)
+            assert not isinstance(self._right, np.ndarray)
+            self._right._putmask(mask, value_right)
+
+    def insert(self, loc: int, item: Interval) -> Self:
+        (left_insert, right_insert) = self._validate_scalar(item)
+        new_left = self.left.insert(loc, left_insert)
+        new_right = self.right.insert(loc, right_insert)
+        return self._shallow_copy(new_left, new_right)
+
+    def delete(self, loc) -> Self:
+        new_left: np.ndarray | DatetimeArray | TimedeltaArray
+        new_right: np.ndarray | DatetimeArray | TimedeltaArray
+        if isinstance(self._left, np.ndarray):
+            new_left = np.delete(self._left, loc)
+            assert isinstance(self._right, np.ndarray)
+            new_right = np.delete(self._right, loc)
+        else:
+            new_left = self._left.delete(loc)
+            assert not isinstance(self._right, np.ndarray)
+            new_right = self._right.delete(loc)
+        return self._shallow_copy(left=new_left, right=new_right)
+
+    @Appender(_extension_array_shared_docs['repeat'] % _shared_docs_kwargs)
+    def repeat(self, repeats: int | Sequence[int], axis: AxisInt | None=None) -> Self:
+        nv.validate_repeat((), {'axis': axis})
+        left_repeat = self.left.repeat(repeats)
+        right_repeat = self.right.repeat(repeats)
+        return self._shallow_copy(left=left_repeat, right=right_repeat)
+    _interval_shared_docs['contains'] = textwrap.dedent('\n        Check elementwise if the Intervals contain the value.\n\n        Return a boolean mask whether the value is contained in the Intervals\n        of the %(klass)s.\n\n        Parameters\n        ----------\n        other : scalar\n            The value to check whether it is contained in the Intervals.\n\n        Returns\n        -------\n        boolean array\n\n        See Also\n        --------\n        Interval.contains : Check whether Interval object contains value.\n        %(klass)s.overlaps : Check if an Interval overlaps the values in the\n            %(klass)s.\n\n        Examples\n        --------\n        %(examples)s\n        >>> intervals.contains(0.5)\n        array([ True, False, False])\n    ')
+
+    def contains(self, other):
+        if isinstance(other, Interval):
+            raise NotImplementedError('contains not implemented for two intervals')
+        return (self._left < other if self.open_left else self._left <= other) & (other < self._right if self.open_right else other <= self._right)
+
+    def isin(self, values: ArrayLike) -> npt.NDArray[np.bool_]:
+        if isinstance(values, IntervalArray):
+            if self.closed != values.closed:
+                return np.zeros(self.shape, dtype=bool)
+            if self.dtype == values.dtype:
+                left = self._combined.view('complex128')
+                right = values._combined.view('complex128')
+                return np.isin(left, right).ravel()
+            elif needs_i8_conversion(self.left.dtype) ^ needs_i8_conversion(values.left.dtype):
+                return np.zeros(self.shape, dtype=bool)
+        return isin(self.astype(object), values.astype(object))
+
+    @property
+    def _combined(self) -> IntervalSide:
+        left = self.left._values.reshape(-1, 1)
+        right = self.right._values.reshape(-1, 1)
+        if needs_i8_conversion(left.dtype):
+            comb = left._concat_same_type([left, right], axis=1)
+        else:
+            comb = np.concatenate([left, right], axis=1)
+        return comb
+
+    def _from_combined(self, combined: np.ndarray) -> IntervalArray:
+        nc = combined.view('i8').reshape(-1, 2)
+        dtype = self._left.dtype
+        if needs_i8_conversion(dtype):
+            assert isinstance(self._left, (DatetimeArray, TimedeltaArray))
+            new_left: DatetimeArray | TimedeltaArray | np.ndarray = type(self._left)._from_sequence(nc[:, 0], dtype=dtype)
+            assert isinstance(self._right, (DatetimeArray, TimedeltaArray))
+            new_right: DatetimeArray | TimedeltaArray | np.ndarray = type(self._right)._from_sequence(nc[:, 1], dtype=dtype)
+        else:
+            assert isinstance(dtype, np.dtype)
+            new_left = nc[:, 0].view(dtype)
+            new_right = nc[:, 1].view(dtype)
+        return self._shallow_copy(left=new_left, right=new_right)
+
+    def unique(self) -> IntervalArray:
+        nc = unique(self._combined.view('complex128')[:, 0])
+        nc = nc[:, None]
+        return self._from_combined(nc)
+
+def _maybe_convert_platform_interval(values) -> ArrayLike:
+    if isinstance(values, (list, tuple)) and len(values) == 0:
+        return np.array([], dtype=np.int64)
+    elif not is_list_like(values) or isinstance(values, ABCDataFrame):
+        return values
+    elif isinstance(getattr(values, 'dtype', None), CategoricalDtype):
+        values = np.asarray(values)
+    elif not hasattr(values, 'dtype') and (not isinstance(values, (list, tuple, range))):
+        return values
+    else:
+        values = extract_array(values, extract_numpy=True)
+    if not hasattr(values, 'dtype'):
+        values = np.asarray(values)
+        if values.dtype.kind in 'iu' and values.dtype != np.int64:
+            values = values.astype(np.int64)
+    return values
+
+# File: pandas-main/pandas/core/arrays/masked.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
+import warnings
+import numpy as np
+from pandas._libs import lib, missing as libmissing
+from pandas._libs.tslibs import is_supported_dtype
+from pandas.compat import IS64, is_platform_windows
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import doc
+from pandas.core.dtypes.base import ExtensionDtype
+from pandas.core.dtypes.common import is_bool, is_integer_dtype, is_list_like, is_scalar, is_string_dtype, pandas_dtype
+from pandas.core.dtypes.dtypes import BaseMaskedDtype
+from pandas.core.dtypes.missing import array_equivalent, is_valid_na_for_dtype, isna, notna
+from pandas.core import algorithms as algos, arraylike, missing, nanops, ops
+from pandas.core.algorithms import factorize_array, isin, map_array, mode, take
+from pandas.core.array_algos import masked_accumulations, masked_reductions
+from pandas.core.array_algos.quantile import quantile_with_mask
+from pandas.core.arraylike import OpsMixin
+from pandas.core.arrays._utils import to_numpy_dtype_inference
+from pandas.core.arrays.base import ExtensionArray
+from pandas.core.construction import array as pd_array, ensure_wrapped_if_datetimelike, extract_array
+from pandas.core.indexers import check_array_indexer
+from pandas.core.ops import invalid_comparison
+from pandas.core.util.hashing import hash_array
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Iterator, Sequence
+    from pandas import Series
+    from pandas.core.arrays import BooleanArray
+    from pandas._typing import NumpySorter, NumpyValueArrayLike, ArrayLike, AstypeArg, AxisInt, DtypeObj, FillnaOptions, InterpolateOptions, NpDtype, PositionalIndexer, Scalar, ScalarIndexer, Self, SequenceIndexer, Shape, npt
+    from pandas._libs.missing import NAType
+    from pandas.core.arrays import FloatingArray
+from pandas.compat.numpy import function as nv
+
+class BaseMaskedArray(OpsMixin, ExtensionArray):
+    _data: np.ndarray
+    _mask: npt.NDArray[np.bool_]
+
+    @classmethod
+    def _simple_new(cls, values: np.ndarray, mask: npt.NDArray[np.bool_]) -> Self:
+        result = BaseMaskedArray.__new__(cls)
+        result._data = values
+        result._mask = mask
+        return result
+
+    def __init__(self, values: np.ndarray, mask: npt.NDArray[np.bool_], copy: bool=False) -> None:
+        if not (isinstance(mask, np.ndarray) and mask.dtype == np.bool_):
+            raise TypeError("mask should be boolean numpy array. Use the 'pd.array' function instead")
+        if values.shape != mask.shape:
+            raise ValueError('values.shape must match mask.shape')
+        if copy:
+            values = values.copy()
+            mask = mask.copy()
+        self._data = values
+        self._mask = mask
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype=None, copy: bool=False) -> Self:
+        (values, mask) = cls._coerce_to_array(scalars, dtype=dtype, copy=copy)
+        return cls(values, mask)
+
+    @classmethod
+    @doc(ExtensionArray._empty)
+    def _empty(cls, shape: Shape, dtype: ExtensionDtype) -> Self:
+        dtype = cast(BaseMaskedDtype, dtype)
+        values: np.ndarray = np.empty(shape, dtype=dtype.type)
+        values.fill(dtype._internal_fill_value)
+        mask = np.ones(shape, dtype=bool)
+        result = cls(values, mask)
+        if not isinstance(result, cls) or dtype != result.dtype:
+            raise NotImplementedError(f"Default 'empty' implementation is invalid for dtype='{dtype}'")
+        return result
+
+    def _formatter(self, boxed: bool=False) -> Callable[[Any], str | None]:
+        return str
+
+    @property
+    def dtype(self) -> BaseMaskedDtype:
+        raise AbstractMethodError(self)
+
+    @overload
+    def __getitem__(self, item: ScalarIndexer) -> Any:
+        ...
+
+    @overload
+    def __getitem__(self, item: SequenceIndexer) -> Self:
+        ...
+
+    def __getitem__(self, item: PositionalIndexer) -> Self | Any:
+        item = check_array_indexer(self, item)
+        newmask = self._mask[item]
+        if is_bool(newmask):
+            if newmask:
+                return self.dtype.na_value
+            return self._data[item]
+        return self._simple_new(self._data[item], newmask)
+
+    def _pad_or_backfill(self, *, method: FillnaOptions, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None, copy: bool=True) -> Self:
+        mask = self._mask
+        if mask.any():
+            func = missing.get_fill_func(method, ndim=self.ndim)
+            npvalues = self._data.T
+            new_mask = mask.T
+            if copy:
+                npvalues = npvalues.copy()
+                new_mask = new_mask.copy()
+            elif limit_area is not None:
+                mask = mask.copy()
+            func(npvalues, limit=limit, mask=new_mask)
+            if limit_area is not None and (not mask.all()):
+                mask = mask.T
+                neg_mask = ~mask
+                first = neg_mask.argmax()
+                last = len(neg_mask) - neg_mask[::-1].argmax() - 1
+                if limit_area == 'inside':
+                    new_mask[:first] |= mask[:first]
+                    new_mask[last + 1:] |= mask[last + 1:]
+                elif limit_area == 'outside':
+                    new_mask[first + 1:last] |= mask[first + 1:last]
+            if copy:
+                return self._simple_new(npvalues.T, new_mask.T)
+            else:
+                return self
+        elif copy:
+            new_values = self.copy()
+        else:
+            new_values = self
+        return new_values
+
+    @doc(ExtensionArray.fillna)
+    def fillna(self, value, limit: int | None=None, copy: bool=True) -> Self:
+        mask = self._mask
+        if limit is not None and limit < len(self):
+            modify = mask.cumsum() > limit
+            if modify.any():
+                mask = mask.copy()
+                mask[modify] = False
+        value = missing.check_value_size(value, mask, len(self))
+        if mask.any():
+            if copy:
+                new_values = self.copy()
+            else:
+                new_values = self[:]
+            new_values[mask] = value
+        elif copy:
+            new_values = self.copy()
+        else:
+            new_values = self[:]
+        return new_values
+
+    @classmethod
+    def _coerce_to_array(cls, values, *, dtype: DtypeObj, copy: bool=False) -> tuple[np.ndarray, np.ndarray]:
+        raise AbstractMethodError(cls)
+
+    def _validate_setitem_value(self, value):
+        kind = self.dtype.kind
+        if kind == 'b':
+            if lib.is_bool(value):
+                return value
+        elif kind == 'f':
+            if lib.is_integer(value) or lib.is_float(value):
+                return value
+        elif lib.is_integer(value) or (lib.is_float(value) and value.is_integer()):
+            return value
+        raise TypeError(f"Invalid value '{value!s}' for dtype {self.dtype}")
+
+    def __setitem__(self, key, value) -> None:
+        key = check_array_indexer(self, key)
+        if is_scalar(value):
+            if is_valid_na_for_dtype(value, self.dtype):
+                self._mask[key] = True
+            else:
+                value = self._validate_setitem_value(value)
+                self._data[key] = value
+                self._mask[key] = False
+            return
+        (value, mask) = self._coerce_to_array(value, dtype=self.dtype)
+        self._data[key] = value
+        self._mask[key] = mask
+
+    def __contains__(self, key) -> bool:
+        if isna(key) and key is not self.dtype.na_value:
+            if self._data.dtype.kind == 'f' and lib.is_float(key):
+                return bool((np.isnan(self._data) & ~self._mask).any())
+        return bool(super().__contains__(key))
+
+    def __iter__(self) -> Iterator:
+        if self.ndim == 1:
+            if not self._hasna:
+                for val in self._data:
+                    yield val
+            else:
+                na_value = self.dtype.na_value
+                for (isna_, val) in zip(self._mask, self._data):
+                    if isna_:
+                        yield na_value
+                    else:
+                        yield val
+        else:
+            for i in range(len(self)):
+                yield self[i]
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    @property
+    def shape(self) -> Shape:
+        return self._data.shape
+
+    @property
+    def ndim(self) -> int:
+        return self._data.ndim
+
+    def swapaxes(self, axis1, axis2) -> Self:
+        data = self._data.swapaxes(axis1, axis2)
+        mask = self._mask.swapaxes(axis1, axis2)
+        return self._simple_new(data, mask)
+
+    def delete(self, loc, axis: AxisInt=0) -> Self:
+        data = np.delete(self._data, loc, axis=axis)
+        mask = np.delete(self._mask, loc, axis=axis)
+        return self._simple_new(data, mask)
+
+    def reshape(self, *args, **kwargs) -> Self:
+        data = self._data.reshape(*args, **kwargs)
+        mask = self._mask.reshape(*args, **kwargs)
+        return self._simple_new(data, mask)
+
+    def ravel(self, *args, **kwargs) -> Self:
+        data = self._data.ravel(*args, **kwargs)
+        mask = self._mask.ravel(*args, **kwargs)
+        return type(self)(data, mask)
+
+    @property
+    def T(self) -> Self:
+        return self._simple_new(self._data.T, self._mask.T)
+
+    def round(self, decimals: int=0, *args, **kwargs):
+        if self.dtype.kind == 'b':
+            return self
+        nv.validate_round(args, kwargs)
+        values = np.round(self._data, decimals=decimals, **kwargs)
+        return self._maybe_mask_result(values, self._mask.copy())
+
+    def __invert__(self) -> Self:
+        return self._simple_new(~self._data, self._mask.copy())
+
+    def __neg__(self) -> Self:
+        return self._simple_new(-self._data, self._mask.copy())
+
+    def __pos__(self) -> Self:
+        return self.copy()
+
+    def __abs__(self) -> Self:
+        return self._simple_new(abs(self._data), self._mask.copy())
+
+    def _values_for_json(self) -> np.ndarray:
+        return np.asarray(self, dtype=object)
+
+    def to_numpy(self, dtype: npt.DTypeLike | None=None, copy: bool=False, na_value: object=lib.no_default) -> np.ndarray:
+        hasna = self._hasna
+        (dtype, na_value) = to_numpy_dtype_inference(self, dtype, na_value, hasna)
+        if dtype is None:
+            dtype = object
+        if hasna:
+            if dtype != object and (not is_string_dtype(dtype)) and (na_value is libmissing.NA):
+                raise ValueError(f"cannot convert to '{dtype}'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.")
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore', category=RuntimeWarning)
+                data = self._data.astype(dtype)
+            data[self._mask] = na_value
+        else:
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore', category=RuntimeWarning)
+                data = self._data.astype(dtype, copy=copy)
+        return data
+
+    @doc(ExtensionArray.tolist)
+    def tolist(self) -> list:
+        if self.ndim > 1:
+            return [x.tolist() for x in self]
+        dtype = None if self._hasna else self._data.dtype
+        return self.to_numpy(dtype=dtype, na_value=libmissing.NA).tolist()
+
+    @overload
+    def astype(self, dtype: npt.DTypeLike, copy: bool=...) -> np.ndarray:
+        ...
+
+    @overload
+    def astype(self, dtype: ExtensionDtype, copy: bool=...) -> ExtensionArray:
+        ...
+
+    @overload
+    def astype(self, dtype: AstypeArg, copy: bool=...) -> ArrayLike:
+        ...
+
+    def astype(self, dtype: AstypeArg, copy: bool=True) -> ArrayLike:
+        dtype = pandas_dtype(dtype)
+        if dtype == self.dtype:
+            if copy:
+                return self.copy()
+            return self
+        if isinstance(dtype, BaseMaskedDtype):
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore', category=RuntimeWarning)
+                data = self._data.astype(dtype.numpy_dtype, copy=copy)
+            mask = self._mask if data is self._data else self._mask.copy()
+            cls = dtype.construct_array_type()
+            return cls(data, mask, copy=False)
+        if isinstance(dtype, ExtensionDtype):
+            eacls = dtype.construct_array_type()
+            return eacls._from_sequence(self, dtype=dtype, copy=copy)
+        na_value: float | np.datetime64 | lib.NoDefault
+        if dtype.kind == 'f':
+            na_value = np.nan
+        elif dtype.kind == 'M':
+            na_value = np.datetime64('NaT')
+        else:
+            na_value = lib.no_default
+        if dtype.kind in 'iu' and self._hasna:
+            raise ValueError('cannot convert NA to integer')
+        if dtype.kind == 'b' and self._hasna:
+            raise ValueError('cannot convert float NaN to bool')
+        data = self.to_numpy(dtype=dtype, na_value=na_value, copy=copy)
+        return data
+    __array_priority__ = 1000
+
+    def __array__(self, dtype: NpDtype | None=None, copy: bool | None=None) -> np.ndarray:
+        return self.to_numpy(dtype=dtype)
+    _HANDLED_TYPES: tuple[type, ...]
+
+    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
+        out = kwargs.get('out', ())
+        for x in inputs + out:
+            if not isinstance(x, self._HANDLED_TYPES + (BaseMaskedArray,)):
+                return NotImplemented
+        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(self, ufunc, method, *inputs, **kwargs)
+        if result is not NotImplemented:
+            return result
+        if 'out' in kwargs:
+            return arraylike.dispatch_ufunc_with_out(self, ufunc, method, *inputs, **kwargs)
+        if method == 'reduce':
+            result = arraylike.dispatch_reduction_ufunc(self, ufunc, method, *inputs, **kwargs)
+            if result is not NotImplemented:
+                return result
+        mask = np.zeros(len(self), dtype=bool)
+        inputs2 = []
+        for x in inputs:
+            if isinstance(x, BaseMaskedArray):
+                mask |= x._mask
+                inputs2.append(x._data)
+            else:
+                inputs2.append(x)
+
+        def reconstruct(x: np.ndarray):
+            from pandas.core.arrays import BooleanArray, FloatingArray, IntegerArray
+            if x.dtype.kind == 'b':
+                m = mask.copy()
+                return BooleanArray(x, m)
+            elif x.dtype.kind in 'iu':
+                m = mask.copy()
+                return IntegerArray(x, m)
+            elif x.dtype.kind == 'f':
+                m = mask.copy()
+                if x.dtype == np.float16:
+                    x = x.astype(np.float32)
+                return FloatingArray(x, m)
+            else:
+                x[mask] = np.nan
+            return x
+        result = getattr(ufunc, method)(*inputs2, **kwargs)
+        if ufunc.nout > 1:
+            return tuple((reconstruct(x) for x in result))
+        elif method == 'reduce':
+            if self._mask.any():
+                return self._na_value
+            return result
+        else:
+            return reconstruct(result)
+
+    def __arrow_array__(self, type=None):
+        import pyarrow as pa
+        return pa.array(self._data, mask=self._mask, type=type)
+
+    @property
+    def _hasna(self) -> bool:
+        return self._mask.any()
+
+    def _propagate_mask(self, mask: npt.NDArray[np.bool_] | None, other) -> npt.NDArray[np.bool_]:
+        if mask is None:
+            mask = self._mask.copy()
+            if other is libmissing.NA:
+                mask = mask | True
+            elif is_list_like(other) and len(other) == len(mask):
+                mask = mask | isna(other)
+        else:
+            mask = self._mask | mask
+        return mask
+
+    def _arith_method(self, other, op):
+        op_name = op.__name__
+        omask = None
+        if not hasattr(other, 'dtype') and is_list_like(other) and (len(other) == len(self)):
+            other = pd_array(other)
+            other = extract_array(other, extract_numpy=True)
+        if isinstance(other, BaseMaskedArray):
+            (other, omask) = (other._data, other._mask)
+        elif is_list_like(other):
+            if not isinstance(other, ExtensionArray):
+                other = np.asarray(other)
+            if other.ndim > 1:
+                raise NotImplementedError('can only perform ops with 1-d structures')
+        other = ops.maybe_prepare_scalar_for_op(other, (len(self),))
+        pd_op = ops.get_array_op(op)
+        other = ensure_wrapped_if_datetimelike(other)
+        if op_name in {'pow', 'rpow'} and isinstance(other, np.bool_):
+            other = bool(other)
+        mask = self._propagate_mask(omask, other)
+        if other is libmissing.NA:
+            result = np.ones_like(self._data)
+            if self.dtype.kind == 'b':
+                if op_name in {'floordiv', 'rfloordiv', 'pow', 'rpow', 'truediv', 'rtruediv'}:
+                    raise NotImplementedError(f"operator '{op_name}' not implemented for bool dtypes")
+                if op_name in {'mod', 'rmod'}:
+                    dtype = 'int8'
+                else:
+                    dtype = 'bool'
+                result = result.astype(dtype)
+            elif 'truediv' in op_name and self.dtype.kind != 'f':
+                result = result.astype(np.float64)
+        else:
+            if self.dtype.kind in 'iu' and op_name in ['floordiv', 'mod']:
+                pd_op = op
+            with np.errstate(all='ignore'):
+                result = pd_op(self._data, other)
+        if op_name == 'pow':
+            mask = np.where((self._data == 1) & ~self._mask, False, mask)
+            if omask is not None:
+                mask = np.where((other == 0) & ~omask, False, mask)
+            elif other is not libmissing.NA:
+                mask = np.where(other == 0, False, mask)
+        elif op_name == 'rpow':
+            if omask is not None:
+                mask = np.where((other == 1) & ~omask, False, mask)
+            elif other is not libmissing.NA:
+                mask = np.where(other == 1, False, mask)
+            mask = np.where((self._data == 0) & ~self._mask, False, mask)
+        return self._maybe_mask_result(result, mask)
+    _logical_method = _arith_method
+
+    def _cmp_method(self, other, op) -> BooleanArray:
+        from pandas.core.arrays import BooleanArray
+        mask = None
+        if isinstance(other, BaseMaskedArray):
+            (other, mask) = (other._data, other._mask)
+        elif is_list_like(other):
+            other = np.asarray(other)
+            if other.ndim > 1:
+                raise NotImplementedError('can only perform ops with 1-d structures')
+            if len(self) != len(other):
+                raise ValueError('Lengths must match to compare')
+        if other is libmissing.NA:
+            result = np.zeros(self._data.shape, dtype='bool')
+            mask = np.ones(self._data.shape, dtype='bool')
+        else:
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore', 'elementwise', FutureWarning)
+                warnings.filterwarnings('ignore', 'elementwise', DeprecationWarning)
+                method = getattr(self._data, f'__{op.__name__}__')
+                result = method(other)
+                if result is NotImplemented:
+                    result = invalid_comparison(self._data, other, op)
+        mask = self._propagate_mask(mask, other)
+        return BooleanArray(result, mask, copy=False)
+
+    def _maybe_mask_result(self, result: np.ndarray | tuple[np.ndarray, np.ndarray], mask: np.ndarray):
+        if isinstance(result, tuple):
+            (div, mod) = result
+            return (self._maybe_mask_result(div, mask), self._maybe_mask_result(mod, mask))
+        if result.dtype.kind == 'f':
+            from pandas.core.arrays import FloatingArray
+            return FloatingArray(result, mask, copy=False)
+        elif result.dtype.kind == 'b':
+            from pandas.core.arrays import BooleanArray
+            return BooleanArray(result, mask, copy=False)
+        elif lib.is_np_dtype(result.dtype, 'm') and is_supported_dtype(result.dtype):
+            from pandas.core.arrays import TimedeltaArray
+            result[mask] = result.dtype.type('NaT')
+            if not isinstance(result, TimedeltaArray):
+                return TimedeltaArray._simple_new(result, dtype=result.dtype)
+            return result
+        elif result.dtype.kind in 'iu':
+            from pandas.core.arrays import IntegerArray
+            return IntegerArray(result, mask, copy=False)
+        else:
+            result[mask] = np.nan
+            return result
+
+    def isna(self) -> np.ndarray:
+        return self._mask.copy()
+
+    @property
+    def _na_value(self):
+        return self.dtype.na_value
+
+    @property
+    def nbytes(self) -> int:
+        return self._data.nbytes + self._mask.nbytes
+
+    @classmethod
+    def _concat_same_type(cls, to_concat: Sequence[Self], axis: AxisInt=0) -> Self:
+        data = np.concatenate([x._data for x in to_concat], axis=axis)
+        mask = np.concatenate([x._mask for x in to_concat], axis=axis)
+        return cls(data, mask)
+
+    def _hash_pandas_object(self, *, encoding: str, hash_key: str, categorize: bool) -> npt.NDArray[np.uint64]:
+        hashed_array = hash_array(self._data, encoding=encoding, hash_key=hash_key, categorize=categorize)
+        hashed_array[self.isna()] = hash(self.dtype.na_value)
+        return hashed_array
+
+    def take(self, indexer, *, allow_fill: bool=False, fill_value: Scalar | None=None, axis: AxisInt=0) -> Self:
+        data_fill_value = self.dtype._internal_fill_value if isna(fill_value) else fill_value
+        result = take(self._data, indexer, fill_value=data_fill_value, allow_fill=allow_fill, axis=axis)
+        mask = take(self._mask, indexer, fill_value=True, allow_fill=allow_fill, axis=axis)
+        if allow_fill and notna(fill_value):
+            fill_mask = np.asarray(indexer) == -1
+            result[fill_mask] = fill_value
+            mask = mask ^ fill_mask
+        return self._simple_new(result, mask)
+
+    def isin(self, values: ArrayLike) -> BooleanArray:
+        from pandas.core.arrays import BooleanArray
+        values_arr = np.asarray(values)
+        result = isin(self._data, values_arr)
+        if self._hasna:
+            values_have_NA = values_arr.dtype == object and any((val is self.dtype.na_value for val in values_arr))
+            result[self._mask] = values_have_NA
+        mask = np.zeros(self._data.shape, dtype=bool)
+        return BooleanArray(result, mask, copy=False)
+
+    def copy(self) -> Self:
+        data = self._data.copy()
+        mask = self._mask.copy()
+        return self._simple_new(data, mask)
+
+    @doc(ExtensionArray.duplicated)
+    def duplicated(self, keep: Literal['first', 'last', False]='first') -> npt.NDArray[np.bool_]:
+        values = self._data
+        mask = self._mask
+        return algos.duplicated(values, keep=keep, mask=mask)
+
+    def unique(self) -> Self:
+        (uniques, mask) = algos.unique_with_mask(self._data, self._mask)
+        return self._simple_new(uniques, mask)
+
+    @doc(ExtensionArray.searchsorted)
+    def searchsorted(self, value: NumpyValueArrayLike | ExtensionArray, side: Literal['left', 'right']='left', sorter: NumpySorter | None=None) -> npt.NDArray[np.intp] | np.intp:
+        if self._hasna:
+            raise ValueError('searchsorted requires array to be sorted, which is impossible with NAs present.')
+        if isinstance(value, ExtensionArray):
+            value = value.astype(object)
+        return self._data.searchsorted(value, side=side, sorter=sorter)
+
+    @doc(ExtensionArray.factorize)
+    def factorize(self, use_na_sentinel: bool=True) -> tuple[np.ndarray, ExtensionArray]:
+        arr = self._data
+        mask = self._mask
+        (codes, uniques) = factorize_array(arr, use_na_sentinel=True, mask=mask)
+        assert uniques.dtype == self.dtype.numpy_dtype, (uniques.dtype, self.dtype)
+        has_na = mask.any()
+        if use_na_sentinel or not has_na:
+            size = len(uniques)
+        else:
+            size = len(uniques) + 1
+        uniques_mask = np.zeros(size, dtype=bool)
+        if not use_na_sentinel and has_na:
+            na_index = mask.argmax()
+            if na_index == 0:
+                na_code = np.intp(0)
+            else:
+                na_code = codes[:na_index].max() + 1
+            codes[codes >= na_code] += 1
+            codes[codes == -1] = na_code
+            uniques = np.insert(uniques, na_code, 0)
+            uniques_mask[na_code] = True
+        uniques_ea = self._simple_new(uniques, uniques_mask)
+        return (codes, uniques_ea)
+
+    @doc(ExtensionArray._values_for_argsort)
+    def _values_for_argsort(self) -> np.ndarray:
+        return self._data
+
+    def value_counts(self, dropna: bool=True) -> Series:
+        from pandas import Index, Series
+        from pandas.arrays import IntegerArray
+        (keys, value_counts, na_counter) = algos.value_counts_arraylike(self._data, dropna=dropna, mask=self._mask)
+        mask_index = np.zeros((len(value_counts),), dtype=np.bool_)
+        mask = mask_index.copy()
+        if na_counter > 0:
+            mask_index[-1] = True
+        arr = IntegerArray(value_counts, mask)
+        index = Index(self.dtype.construct_array_type()(keys, mask_index))
+        return Series(arr, index=index, name='count', copy=False)
+
+    def _mode(self, dropna: bool=True) -> Self:
+        if dropna:
+            result = mode(self._data, dropna=dropna, mask=self._mask)
+            res_mask = np.zeros(result.shape, dtype=np.bool_)
+        else:
+            (result, res_mask) = mode(self._data, dropna=dropna, mask=self._mask)
+        result = type(self)(result, res_mask)
+        return result[result.argsort()]
+
+    @doc(ExtensionArray.equals)
+    def equals(self, other) -> bool:
+        if type(self) != type(other):
+            return False
+        if other.dtype != self.dtype:
+            return False
+        if not np.array_equal(self._mask, other._mask):
+            return False
+        left = self._data[~self._mask]
+        right = other._data[~other._mask]
+        return array_equivalent(left, right, strict_nan=True, dtype_equal=True)
+
+    def _quantile(self, qs: npt.NDArray[np.float64], interpolation: str) -> BaseMaskedArray:
+        res = quantile_with_mask(self._data, mask=self._mask, fill_value=np.nan, qs=qs, interpolation=interpolation)
+        if self._hasna:
+            if self.ndim == 2:
+                raise NotImplementedError
+            if self.isna().all():
+                out_mask = np.ones(res.shape, dtype=bool)
+                if is_integer_dtype(self.dtype):
+                    res = np.zeros(res.shape, dtype=self.dtype.numpy_dtype)
+            else:
+                out_mask = np.zeros(res.shape, dtype=bool)
+        else:
+            out_mask = np.zeros(res.shape, dtype=bool)
+        return self._maybe_mask_result(res, mask=out_mask)
+
+    def _reduce(self, name: str, *, skipna: bool=True, keepdims: bool=False, **kwargs):
+        if name in {'any', 'all', 'min', 'max', 'sum', 'prod', 'mean', 'var', 'std'}:
+            result = getattr(self, name)(skipna=skipna, **kwargs)
+        else:
+            data = self._data
+            mask = self._mask
+            op = getattr(nanops, f'nan{name}')
+            axis = kwargs.pop('axis', None)
+            result = op(data, axis=axis, skipna=skipna, mask=mask, **kwargs)
+        if keepdims:
+            if isna(result):
+                return self._wrap_na_result(name=name, axis=0, mask_size=(1,))
+            else:
+                result = result.reshape(1)
+                mask = np.zeros(1, dtype=bool)
+                return self._maybe_mask_result(result, mask)
+        if isna(result):
+            return libmissing.NA
+        else:
+            return result
+
+    def _wrap_reduction_result(self, name: str, result, *, skipna, axis):
+        if isinstance(result, np.ndarray):
+            if skipna:
+                mask = self._mask.all(axis=axis)
+            else:
+                mask = self._mask.any(axis=axis)
+            return self._maybe_mask_result(result, mask)
+        return result
+
+    def _wrap_na_result(self, *, name, axis, mask_size):
+        mask = np.ones(mask_size, dtype=bool)
+        float_dtyp = 'float32' if self.dtype == 'Float32' else 'float64'
+        if name in ['mean', 'median', 'var', 'std', 'skew', 'kurt', 'sem']:
+            np_dtype = float_dtyp
+        elif name in ['min', 'max'] or self.dtype.itemsize == 8:
+            np_dtype = self.dtype.numpy_dtype.name
+        else:
+            is_windows_or_32bit = is_platform_windows() or not IS64
+            int_dtyp = 'int32' if is_windows_or_32bit else 'int64'
+            uint_dtyp = 'uint32' if is_windows_or_32bit else 'uint64'
+            np_dtype = {'b': int_dtyp, 'i': int_dtyp, 'u': uint_dtyp, 'f': float_dtyp}[self.dtype.kind]
+        value = np.array([1], dtype=np_dtype)
+        return self._maybe_mask_result(value, mask=mask)
+
+    def _wrap_min_count_reduction_result(self, name: str, result, *, skipna, min_count, axis):
+        if min_count == 0 and isinstance(result, np.ndarray):
+            return self._maybe_mask_result(result, np.zeros(result.shape, dtype=bool))
+        return self._wrap_reduction_result(name, result, skipna=skipna, axis=axis)
+
+    def sum(self, *, skipna: bool=True, min_count: int=0, axis: AxisInt | None=0, **kwargs):
+        nv.validate_sum((), kwargs)
+        result = masked_reductions.sum(self._data, self._mask, skipna=skipna, min_count=min_count, axis=axis)
+        return self._wrap_min_count_reduction_result('sum', result, skipna=skipna, min_count=min_count, axis=axis)
+
+    def prod(self, *, skipna: bool=True, min_count: int=0, axis: AxisInt | None=0, **kwargs):
+        nv.validate_prod((), kwargs)
+        result = masked_reductions.prod(self._data, self._mask, skipna=skipna, min_count=min_count, axis=axis)
+        return self._wrap_min_count_reduction_result('prod', result, skipna=skipna, min_count=min_count, axis=axis)
+
+    def mean(self, *, skipna: bool=True, axis: AxisInt | None=0, **kwargs):
+        nv.validate_mean((), kwargs)
+        result = masked_reductions.mean(self._data, self._mask, skipna=skipna, axis=axis)
+        return self._wrap_reduction_result('mean', result, skipna=skipna, axis=axis)
+
+    def var(self, *, skipna: bool=True, axis: AxisInt | None=0, ddof: int=1, **kwargs):
+        nv.validate_stat_ddof_func((), kwargs, fname='var')
+        result = masked_reductions.var(self._data, self._mask, skipna=skipna, axis=axis, ddof=ddof)
+        return self._wrap_reduction_result('var', result, skipna=skipna, axis=axis)
+
+    def std(self, *, skipna: bool=True, axis: AxisInt | None=0, ddof: int=1, **kwargs):
+        nv.validate_stat_ddof_func((), kwargs, fname='std')
+        result = masked_reductions.std(self._data, self._mask, skipna=skipna, axis=axis, ddof=ddof)
+        return self._wrap_reduction_result('std', result, skipna=skipna, axis=axis)
+
+    def min(self, *, skipna: bool=True, axis: AxisInt | None=0, **kwargs):
+        nv.validate_min((), kwargs)
+        result = masked_reductions.min(self._data, self._mask, skipna=skipna, axis=axis)
+        return self._wrap_reduction_result('min', result, skipna=skipna, axis=axis)
+
+    def max(self, *, skipna: bool=True, axis: AxisInt | None=0, **kwargs):
+        nv.validate_max((), kwargs)
+        result = masked_reductions.max(self._data, self._mask, skipna=skipna, axis=axis)
+        return self._wrap_reduction_result('max', result, skipna=skipna, axis=axis)
+
+    def map(self, mapper, na_action: Literal['ignore'] | None=None):
+        return map_array(self.to_numpy(), mapper, na_action=na_action)
+
+    @overload
+    def any(self, *, skipna: Literal[True]=..., axis: AxisInt | None=..., **kwargs) -> np.bool_:
+        ...
+
+    @overload
+    def any(self, *, skipna: bool, axis: AxisInt | None=..., **kwargs) -> np.bool_ | NAType:
+        ...
+
+    def any(self, *, skipna: bool=True, axis: AxisInt | None=0, **kwargs) -> np.bool_ | NAType:
+        nv.validate_any((), kwargs)
+        values = self._data.copy()
+        np.putmask(values, self._mask, self.dtype._falsey_value)
+        result = values.any()
+        if skipna:
+            return result
+        elif result or len(self) == 0 or (not self._mask.any()):
+            return result
+        else:
+            return self.dtype.na_value
+
+    @overload
+    def all(self, *, skipna: Literal[True]=..., axis: AxisInt | None=..., **kwargs) -> np.bool_:
+        ...
+
+    @overload
+    def all(self, *, skipna: bool, axis: AxisInt | None=..., **kwargs) -> np.bool_ | NAType:
+        ...
+
+    def all(self, *, skipna: bool=True, axis: AxisInt | None=0, **kwargs) -> np.bool_ | NAType:
+        nv.validate_all((), kwargs)
+        values = self._data.copy()
+        np.putmask(values, self._mask, self.dtype._truthy_value)
+        result = values.all(axis=axis)
+        if skipna:
+            return result
+        elif not result or len(self) == 0 or (not self._mask.any()):
+            return result
+        else:
+            return self.dtype.na_value
+
+    def interpolate(self, *, method: InterpolateOptions, axis: int, index, limit, limit_direction, limit_area, copy: bool, **kwargs) -> FloatingArray:
+        if self.dtype.kind == 'f':
+            if copy:
+                data = self._data.copy()
+                mask = self._mask.copy()
+            else:
+                data = self._data
+                mask = self._mask
+        elif self.dtype.kind in 'iu':
+            copy = True
+            data = self._data.astype('f8')
+            mask = self._mask.copy()
+        else:
+            raise NotImplementedError(f'interpolate is not implemented for dtype={self.dtype}')
+        missing.interpolate_2d_inplace(data, method=method, axis=0, index=index, limit=limit, limit_direction=limit_direction, limit_area=limit_area, mask=mask, **kwargs)
+        if not copy:
+            return self
+        if self.dtype.kind == 'f':
+            return type(self)._simple_new(data, mask)
+        else:
+            from pandas.core.arrays import FloatingArray
+            return FloatingArray._simple_new(data, mask)
+
+    def _accumulate(self, name: str, *, skipna: bool=True, **kwargs) -> BaseMaskedArray:
+        data = self._data
+        mask = self._mask
+        op = getattr(masked_accumulations, name)
+        (data, mask) = op(data, mask, skipna=skipna, **kwargs)
+        return self._simple_new(data, mask)
+
+    def _groupby_op(self, *, how: str, has_dropped_na: bool, min_count: int, ngroups: int, ids: npt.NDArray[np.intp], **kwargs):
+        from pandas.core.groupby.ops import WrappedCythonOp
+        kind = WrappedCythonOp.get_kind_from_how(how)
+        op = WrappedCythonOp(how=how, kind=kind, has_dropped_na=has_dropped_na)
+        mask = self._mask
+        if op.kind != 'aggregate':
+            result_mask = mask.copy()
+        else:
+            result_mask = np.zeros(ngroups, dtype=bool)
+        if how == 'rank' and kwargs.get('na_option') in ['top', 'bottom']:
+            result_mask[:] = False
+        res_values = op._cython_op_ndim_compat(self._data, min_count=min_count, ngroups=ngroups, comp_ids=ids, mask=mask, result_mask=result_mask, **kwargs)
+        if op.how == 'ohlc':
+            arity = op._cython_arity.get(op.how, 1)
+            result_mask = np.tile(result_mask, (arity, 1)).T
+        if op.how in ['idxmin', 'idxmax']:
+            return res_values
+        else:
+            return self._maybe_mask_result(res_values, result_mask)
+
+def transpose_homogeneous_masked_arrays(masked_arrays: Sequence[BaseMaskedArray]) -> list[BaseMaskedArray]:
+    masked_arrays = list(masked_arrays)
+    dtype = masked_arrays[0].dtype
+    values = [arr._data.reshape(1, -1) for arr in masked_arrays]
+    transposed_values = np.concatenate(values, axis=0, out=np.empty((len(masked_arrays), len(masked_arrays[0])), order='F', dtype=dtype.numpy_dtype))
+    masks = [arr._mask.reshape(1, -1) for arr in masked_arrays]
+    transposed_masks = np.concatenate(masks, axis=0, out=np.empty_like(transposed_values, dtype=bool))
+    arr_type = dtype.construct_array_type()
+    transposed_arrays: list[BaseMaskedArray] = []
+    for i in range(transposed_values.shape[1]):
+        transposed_arr = arr_type(transposed_values[:, i], mask=transposed_masks[:, i])
+        transposed_arrays.append(transposed_arr)
+    return transposed_arrays
+
+# File: pandas-main/pandas/core/arrays/numeric.py
+from __future__ import annotations
+import numbers
+from typing import TYPE_CHECKING, Any
+import numpy as np
+from pandas._libs import lib, missing as libmissing
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import cache_readonly
+from pandas.core.dtypes.common import is_integer_dtype, is_string_dtype, pandas_dtype
+from pandas.core.arrays.masked import BaseMaskedArray, BaseMaskedDtype
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+    import pyarrow
+    from pandas._typing import DtypeObj, Self, npt
+    from pandas.core.dtypes.dtypes import ExtensionDtype
+
+class NumericDtype(BaseMaskedDtype):
+    _default_np_dtype: np.dtype
+    _checker: Callable[[Any], bool]
+
+    def __repr__(self) -> str:
+        return f'{self.name}Dtype()'
+
+    @cache_readonly
+    def is_signed_integer(self) -> bool:
+        return self.kind == 'i'
+
+    @cache_readonly
+    def is_unsigned_integer(self) -> bool:
+        return self.kind == 'u'
+
+    @property
+    def _is_numeric(self) -> bool:
+        return True
+
+    def __from_arrow__(self, array: pyarrow.Array | pyarrow.ChunkedArray) -> BaseMaskedArray:
+        import pyarrow
+        from pandas.core.arrays.arrow._arrow_utils import pyarrow_array_to_numpy_and_mask
+        array_class = self.construct_array_type()
+        pyarrow_type = pyarrow.from_numpy_dtype(self.type)
+        if not array.type.equals(pyarrow_type) and (not pyarrow.types.is_null(array.type)):
+            rt_dtype = pandas_dtype(array.type.to_pandas_dtype())
+            if rt_dtype.kind not in 'iuf':
+                raise TypeError(f'Expected array of {self} type, got {array.type} instead')
+            array = array.cast(pyarrow_type)
+        if isinstance(array, pyarrow.ChunkedArray):
+            if array.num_chunks == 0:
+                array = pyarrow.array([], type=array.type)
+            else:
+                array = array.combine_chunks()
+        (data, mask) = pyarrow_array_to_numpy_and_mask(array, dtype=self.numpy_dtype)
+        return array_class(data.copy(), ~mask, copy=False)
+
+    @classmethod
+    def _get_dtype_mapping(cls) -> Mapping[np.dtype, NumericDtype]:
+        raise AbstractMethodError(cls)
+
+    @classmethod
+    def _standardize_dtype(cls, dtype: NumericDtype | str | np.dtype) -> NumericDtype:
+        if isinstance(dtype, str) and dtype.startswith(('Int', 'UInt', 'Float')):
+            dtype = dtype.lower()
+        if not isinstance(dtype, NumericDtype):
+            mapping = cls._get_dtype_mapping()
+            try:
+                dtype = mapping[np.dtype(dtype)]
+            except KeyError as err:
+                raise ValueError(f'invalid dtype specified {dtype}') from err
+        return dtype
+
+    @classmethod
+    def _safe_cast(cls, values: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
+        raise AbstractMethodError(cls)
+
+def _coerce_to_data_and_mask(values, dtype, copy: bool, dtype_cls: type[NumericDtype], default_dtype: np.dtype):
+    checker = dtype_cls._checker
+    mask = None
+    inferred_type = None
+    if dtype is None and hasattr(values, 'dtype'):
+        if checker(values.dtype):
+            dtype = values.dtype
+    if dtype is not None:
+        dtype = dtype_cls._standardize_dtype(dtype)
+    cls = dtype_cls.construct_array_type()
+    if isinstance(values, cls):
+        (values, mask) = (values._data, values._mask)
+        if dtype is not None:
+            values = values.astype(dtype.numpy_dtype, copy=False)
+        if copy:
+            values = values.copy()
+            mask = mask.copy()
+        return (values, mask, dtype, inferred_type)
+    original = values
+    if not copy:
+        values = np.asarray(values)
+    else:
+        values = np.array(values, copy=copy)
+    inferred_type = None
+    if values.dtype == object or is_string_dtype(values.dtype):
+        inferred_type = lib.infer_dtype(values, skipna=True)
+        if inferred_type == 'boolean' and dtype is None:
+            name = dtype_cls.__name__.strip('_')
+            raise TypeError(f'{values.dtype} cannot be converted to {name}')
+    elif values.dtype.kind == 'b' and checker(dtype):
+        if not copy:
+            values = np.asarray(values, dtype=default_dtype)
+        else:
+            values = np.array(values, dtype=default_dtype, copy=copy)
+    elif values.dtype.kind not in 'iuf':
+        name = dtype_cls.__name__.strip('_')
+        raise TypeError(f'{values.dtype} cannot be converted to {name}')
+    if values.ndim != 1:
+        raise TypeError('values must be a 1D list-like')
+    if mask is None:
+        if values.dtype.kind in 'iu':
+            mask = np.zeros(len(values), dtype=np.bool_)
+        else:
+            mask = libmissing.is_numeric_na(values)
+    else:
+        assert len(mask) == len(values)
+    if mask.ndim != 1:
+        raise TypeError('mask must be a 1D list-like')
+    if dtype is None:
+        dtype = default_dtype
+    else:
+        dtype = dtype.numpy_dtype
+    if is_integer_dtype(dtype) and values.dtype.kind == 'f' and (len(values) > 0):
+        if mask.all():
+            values = np.ones(values.shape, dtype=dtype)
+        else:
+            idx = np.nanargmax(values)
+            if int(values[idx]) != original[idx]:
+                inferred_type = lib.infer_dtype(original, skipna=True)
+                if inferred_type not in ['floating', 'mixed-integer-float'] and (not mask.any()):
+                    values = np.asarray(original, dtype=dtype)
+                else:
+                    values = np.asarray(original, dtype='object')
+    if mask.any():
+        values = values.copy()
+        values[mask] = dtype_cls._internal_fill_value
+    if inferred_type in ('string', 'unicode'):
+        values = values.astype(dtype, copy=copy)
+    else:
+        values = dtype_cls._safe_cast(values, dtype, copy=False)
+    return (values, mask, dtype, inferred_type)
+
+class NumericArray(BaseMaskedArray):
+    _dtype_cls: type[NumericDtype]
+
+    def __init__(self, values: np.ndarray, mask: npt.NDArray[np.bool_], copy: bool=False) -> None:
+        checker = self._dtype_cls._checker
+        if not (isinstance(values, np.ndarray) and checker(values.dtype)):
+            descr = 'floating' if self._dtype_cls.kind == 'f' else 'integer'
+            raise TypeError(f"values should be {descr} numpy array. Use the 'pd.array' function instead")
+        if values.dtype == np.float16:
+            raise TypeError('FloatingArray does not support np.float16 dtype.')
+        super().__init__(values, mask, copy=copy)
+
+    @cache_readonly
+    def dtype(self) -> NumericDtype:
+        mapping = self._dtype_cls._get_dtype_mapping()
+        return mapping[self._data.dtype]
+
+    @classmethod
+    def _coerce_to_array(cls, value, *, dtype: DtypeObj, copy: bool=False) -> tuple[np.ndarray, np.ndarray]:
+        dtype_cls = cls._dtype_cls
+        default_dtype = dtype_cls._default_np_dtype
+        (values, mask, _, _) = _coerce_to_data_and_mask(value, dtype, copy, dtype_cls, default_dtype)
+        return (values, mask)
+
+    @classmethod
+    def _from_sequence_of_strings(cls, strings, *, dtype: ExtensionDtype, copy: bool=False) -> Self:
+        from pandas.core.tools.numeric import to_numeric
+        scalars = to_numeric(strings, errors='raise', dtype_backend='numpy_nullable')
+        return cls._from_sequence(scalars, dtype=dtype, copy=copy)
+    _HANDLED_TYPES = (np.ndarray, numbers.Number)
+
+# File: pandas-main/pandas/core/arrays/numpy_.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, Literal
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.tslibs import is_supported_dtype
+from pandas.compat.numpy import function as nv
+from pandas.core.dtypes.astype import astype_array
+from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
+from pandas.core.dtypes.common import pandas_dtype
+from pandas.core.dtypes.dtypes import NumpyEADtype
+from pandas.core.dtypes.missing import isna
+from pandas.core import arraylike, missing, nanops, ops
+from pandas.core.arraylike import OpsMixin
+from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
+from pandas.core.construction import ensure_wrapped_if_datetimelike
+from pandas.core.strings.object_array import ObjectStringArrayMixin
+if TYPE_CHECKING:
+    from pandas._typing import AxisInt, Dtype, FillnaOptions, InterpolateOptions, NpDtype, Scalar, Self, npt
+    from pandas import Index
+
+class NumpyExtensionArray(OpsMixin, NDArrayBackedExtensionArray, ObjectStringArrayMixin):
+    _typ = 'npy_extension'
+    __array_priority__ = 1000
+    _ndarray: np.ndarray
+    _dtype: NumpyEADtype
+    _internal_fill_value = np.nan
+
+    def __init__(self, values: np.ndarray | NumpyExtensionArray, copy: bool=False) -> None:
+        if isinstance(values, type(self)):
+            values = values._ndarray
+        if not isinstance(values, np.ndarray):
+            raise ValueError(f"'values' must be a NumPy array, not {type(values).__name__}")
+        if values.ndim == 0:
+            raise ValueError('NumpyExtensionArray must be 1-dimensional.')
+        if copy:
+            values = values.copy()
+        dtype = NumpyEADtype(values.dtype)
+        super().__init__(values, dtype)
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype: Dtype | None=None, copy: bool=False) -> NumpyExtensionArray:
+        if isinstance(dtype, NumpyEADtype):
+            dtype = dtype._dtype
+        result = np.asarray(scalars, dtype=dtype)
+        if result.ndim > 1 and (not hasattr(scalars, 'dtype')) and (dtype is None or dtype == object):
+            result = construct_1d_object_array_from_listlike(scalars)
+        if copy and result is scalars:
+            result = result.copy()
+        return cls(result)
+
+    @property
+    def dtype(self) -> NumpyEADtype:
+        return self._dtype
+
+    def __array__(self, dtype: NpDtype | None=None, copy: bool | None=None) -> np.ndarray:
+        return np.asarray(self._ndarray, dtype=dtype)
+
+    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
+        out = kwargs.get('out', ())
+        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(self, ufunc, method, *inputs, **kwargs)
+        if result is not NotImplemented:
+            return result
+        if 'out' in kwargs:
+            return arraylike.dispatch_ufunc_with_out(self, ufunc, method, *inputs, **kwargs)
+        if method == 'reduce':
+            result = arraylike.dispatch_reduction_ufunc(self, ufunc, method, *inputs, **kwargs)
+            if result is not NotImplemented:
+                return result
+        inputs = tuple((x._ndarray if isinstance(x, NumpyExtensionArray) else x for x in inputs))
+        if out:
+            kwargs['out'] = tuple((x._ndarray if isinstance(x, NumpyExtensionArray) else x for x in out))
+        result = getattr(ufunc, method)(*inputs, **kwargs)
+        if ufunc.nout > 1:
+            return tuple((type(self)(x) for x in result))
+        elif method == 'at':
+            return None
+        elif method == 'reduce':
+            if isinstance(result, np.ndarray):
+                return type(self)(result)
+            return result
+        else:
+            return type(self)(result)
+
+    def astype(self, dtype, copy: bool=True):
+        dtype = pandas_dtype(dtype)
+        if dtype == self.dtype:
+            if copy:
+                return self.copy()
+            return self
+        result = astype_array(self._ndarray, dtype=dtype, copy=copy)
+        return result
+
+    def isna(self) -> np.ndarray:
+        return isna(self._ndarray)
+
+    def _validate_scalar(self, fill_value):
+        if fill_value is None:
+            fill_value = self.dtype.na_value
+        return fill_value
+
+    def _values_for_factorize(self) -> tuple[np.ndarray, float | None]:
+        if self.dtype.kind in 'iub':
+            fv = None
+        else:
+            fv = np.nan
+        return (self._ndarray, fv)
+
+    def _pad_or_backfill(self, *, method: FillnaOptions, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None, copy: bool=True) -> Self:
+        if copy:
+            out_data = self._ndarray.copy()
+        else:
+            out_data = self._ndarray
+        meth = missing.clean_fill_method(method)
+        missing.pad_or_backfill_inplace(out_data.T, method=meth, axis=0, limit=limit, limit_area=limit_area)
+        if not copy:
+            return self
+        return type(self)._simple_new(out_data, dtype=self.dtype)
+
+    def interpolate(self, *, method: InterpolateOptions, axis: int, index: Index, limit, limit_direction, limit_area, copy: bool, **kwargs) -> Self:
+        if not copy:
+            out_data = self._ndarray
+        else:
+            out_data = self._ndarray.copy()
+        missing.interpolate_2d_inplace(out_data, method=method, axis=axis, index=index, limit=limit, limit_direction=limit_direction, limit_area=limit_area, **kwargs)
+        if not copy:
+            return self
+        return type(self)._simple_new(out_data, dtype=self.dtype)
+
+    def any(self, *, axis: AxisInt | None=None, out=None, keepdims: bool=False, skipna: bool=True):
+        nv.validate_any((), {'out': out, 'keepdims': keepdims})
+        result = nanops.nanany(self._ndarray, axis=axis, skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def all(self, *, axis: AxisInt | None=None, out=None, keepdims: bool=False, skipna: bool=True):
+        nv.validate_all((), {'out': out, 'keepdims': keepdims})
+        result = nanops.nanall(self._ndarray, axis=axis, skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def min(self, *, axis: AxisInt | None=None, skipna: bool=True, **kwargs) -> Scalar:
+        nv.validate_min((), kwargs)
+        result = nanops.nanmin(values=self._ndarray, axis=axis, mask=self.isna(), skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def max(self, *, axis: AxisInt | None=None, skipna: bool=True, **kwargs) -> Scalar:
+        nv.validate_max((), kwargs)
+        result = nanops.nanmax(values=self._ndarray, axis=axis, mask=self.isna(), skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def sum(self, *, axis: AxisInt | None=None, skipna: bool=True, min_count: int=0, **kwargs) -> Scalar:
+        nv.validate_sum((), kwargs)
+        result = nanops.nansum(self._ndarray, axis=axis, skipna=skipna, min_count=min_count)
+        return self._wrap_reduction_result(axis, result)
+
+    def prod(self, *, axis: AxisInt | None=None, skipna: bool=True, min_count: int=0, **kwargs) -> Scalar:
+        nv.validate_prod((), kwargs)
+        result = nanops.nanprod(self._ndarray, axis=axis, skipna=skipna, min_count=min_count)
+        return self._wrap_reduction_result(axis, result)
+
+    def mean(self, *, axis: AxisInt | None=None, dtype: NpDtype | None=None, out=None, keepdims: bool=False, skipna: bool=True):
+        nv.validate_mean((), {'dtype': dtype, 'out': out, 'keepdims': keepdims})
+        result = nanops.nanmean(self._ndarray, axis=axis, skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def median(self, *, axis: AxisInt | None=None, out=None, overwrite_input: bool=False, keepdims: bool=False, skipna: bool=True):
+        nv.validate_median((), {'out': out, 'overwrite_input': overwrite_input, 'keepdims': keepdims})
+        result = nanops.nanmedian(self._ndarray, axis=axis, skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def std(self, *, axis: AxisInt | None=None, dtype: NpDtype | None=None, out=None, ddof: int=1, keepdims: bool=False, skipna: bool=True):
+        nv.validate_stat_ddof_func((), {'dtype': dtype, 'out': out, 'keepdims': keepdims}, fname='std')
+        result = nanops.nanstd(self._ndarray, axis=axis, skipna=skipna, ddof=ddof)
+        return self._wrap_reduction_result(axis, result)
+
+    def var(self, *, axis: AxisInt | None=None, dtype: NpDtype | None=None, out=None, ddof: int=1, keepdims: bool=False, skipna: bool=True):
+        nv.validate_stat_ddof_func((), {'dtype': dtype, 'out': out, 'keepdims': keepdims}, fname='var')
+        result = nanops.nanvar(self._ndarray, axis=axis, skipna=skipna, ddof=ddof)
+        return self._wrap_reduction_result(axis, result)
+
+    def sem(self, *, axis: AxisInt | None=None, dtype: NpDtype | None=None, out=None, ddof: int=1, keepdims: bool=False, skipna: bool=True):
+        nv.validate_stat_ddof_func((), {'dtype': dtype, 'out': out, 'keepdims': keepdims}, fname='sem')
+        result = nanops.nansem(self._ndarray, axis=axis, skipna=skipna, ddof=ddof)
+        return self._wrap_reduction_result(axis, result)
+
+    def kurt(self, *, axis: AxisInt | None=None, dtype: NpDtype | None=None, out=None, keepdims: bool=False, skipna: bool=True):
+        nv.validate_stat_ddof_func((), {'dtype': dtype, 'out': out, 'keepdims': keepdims}, fname='kurt')
+        result = nanops.nankurt(self._ndarray, axis=axis, skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def skew(self, *, axis: AxisInt | None=None, dtype: NpDtype | None=None, out=None, keepdims: bool=False, skipna: bool=True):
+        nv.validate_stat_ddof_func((), {'dtype': dtype, 'out': out, 'keepdims': keepdims}, fname='skew')
+        result = nanops.nanskew(self._ndarray, axis=axis, skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def to_numpy(self, dtype: npt.DTypeLike | None=None, copy: bool=False, na_value: object=lib.no_default) -> np.ndarray:
+        mask = self.isna()
+        if na_value is not lib.no_default and mask.any():
+            result = self._ndarray.copy()
+            result[mask] = na_value
+        else:
+            result = self._ndarray
+        result = np.asarray(result, dtype=dtype)
+        if copy and result is self._ndarray:
+            result = result.copy()
+        return result
+
+    def __invert__(self) -> NumpyExtensionArray:
+        return type(self)(~self._ndarray)
+
+    def __neg__(self) -> NumpyExtensionArray:
+        return type(self)(-self._ndarray)
+
+    def __pos__(self) -> NumpyExtensionArray:
+        return type(self)(+self._ndarray)
+
+    def __abs__(self) -> NumpyExtensionArray:
+        return type(self)(abs(self._ndarray))
+
+    def _cmp_method(self, other, op):
+        if isinstance(other, NumpyExtensionArray):
+            other = other._ndarray
+        other = ops.maybe_prepare_scalar_for_op(other, (len(self),))
+        pd_op = ops.get_array_op(op)
+        other = ensure_wrapped_if_datetimelike(other)
+        result = pd_op(self._ndarray, other)
+        if op is divmod or op is ops.rdivmod:
+            (a, b) = result
+            if isinstance(a, np.ndarray):
+                return (self._wrap_ndarray_result(a), self._wrap_ndarray_result(b))
+            return (a, b)
+        if isinstance(result, np.ndarray):
+            return self._wrap_ndarray_result(result)
+        return result
+    _arith_method = _cmp_method
+
+    def _wrap_ndarray_result(self, result: np.ndarray):
+        if result.dtype.kind == 'm' and is_supported_dtype(result.dtype):
+            from pandas.core.arrays import TimedeltaArray
+            return TimedeltaArray._simple_new(result, dtype=result.dtype)
+        return type(self)(result)
+
+# File: pandas-main/pandas/core/arrays/period.py
+from __future__ import annotations
+from datetime import timedelta
+import operator
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast, overload
+import warnings
+import numpy as np
+from pandas._libs import algos as libalgos, lib
+from pandas._libs.arrays import NDArrayBacked
+from pandas._libs.tslibs import BaseOffset, NaT, NaTType, Timedelta, add_overflowsafe, astype_overflowsafe, dt64arr_to_periodarr as c_dt64arr_to_periodarr, get_unit_from_dtype, iNaT, parsing, period as libperiod, to_offset
+from pandas._libs.tslibs.dtypes import FreqGroup, PeriodDtypeBase
+from pandas._libs.tslibs.fields import isleapyear_arr
+from pandas._libs.tslibs.offsets import Tick, delta_to_tick
+from pandas._libs.tslibs.period import DIFFERENT_FREQ, IncompatibleFrequency, Period, get_period_field_arr, period_asfreq_arr
+from pandas.util._decorators import cache_readonly, doc
+from pandas.core.dtypes.common import ensure_object, pandas_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype, PeriodDtype
+from pandas.core.dtypes.generic import ABCIndex, ABCPeriodIndex, ABCSeries, ABCTimedeltaArray
+from pandas.core.dtypes.missing import isna
+from pandas.core.arrays import datetimelike as dtl
+import pandas.core.common as com
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+    from pandas._typing import AnyArrayLike, Dtype, FillnaOptions, NpDtype, NumpySorter, NumpyValueArrayLike, Self, npt
+    from pandas.core.dtypes.dtypes import ExtensionDtype
+    from pandas.core.arrays import DatetimeArray, TimedeltaArray
+    from pandas.core.arrays.base import ExtensionArray
+BaseOffsetT = TypeVar('BaseOffsetT', bound=BaseOffset)
+_shared_doc_kwargs = {'klass': 'PeriodArray'}
+
+def _field_accessor(name: str, docstring: str | None=None):
+
+    def f(self):
+        base = self.dtype._dtype_code
+        result = get_period_field_arr(name, self.asi8, base)
+        return result
+    f.__name__ = name
+    f.__doc__ = docstring
+    return property(f)
+
+class PeriodArray(dtl.DatelikeOps, libperiod.PeriodMixin):
+    __array_priority__ = 1000
+    _typ = 'periodarray'
+    _internal_fill_value = np.int64(iNaT)
+    _recognized_scalars = (Period,)
+    _is_recognized_dtype = lambda x: isinstance(x, PeriodDtype)
+    _infer_matches = ('period',)
+
+    @property
+    def _scalar_type(self) -> type[Period]:
+        return Period
+    _other_ops: list[str] = []
+    _bool_ops: list[str] = ['is_leap_year']
+    _object_ops: list[str] = ['start_time', 'end_time', 'freq']
+    _field_ops: list[str] = ['year', 'month', 'day', 'hour', 'minute', 'second', 'weekofyear', 'weekday', 'week', 'dayofweek', 'day_of_week', 'dayofyear', 'day_of_year', 'quarter', 'qyear', 'days_in_month', 'daysinmonth']
+    _datetimelike_ops: list[str] = _field_ops + _object_ops + _bool_ops
+    _datetimelike_methods: list[str] = ['strftime', 'to_timestamp', 'asfreq']
+    _dtype: PeriodDtype
+
+    def __init__(self, values, dtype: Dtype | None=None, copy: bool=False) -> None:
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+            if not isinstance(dtype, PeriodDtype):
+                raise ValueError(f'Invalid dtype {dtype} for PeriodArray')
+        if isinstance(values, ABCSeries):
+            values = values._values
+            if not isinstance(values, type(self)):
+                raise TypeError('Incorrect dtype')
+        elif isinstance(values, ABCPeriodIndex):
+            values = values._values
+        if isinstance(values, type(self)):
+            if dtype is not None and dtype != values.dtype:
+                raise raise_on_incompatible(values, dtype.freq)
+            (values, dtype) = (values._ndarray, values.dtype)
+        if not copy:
+            values = np.asarray(values, dtype='int64')
+        else:
+            values = np.array(values, dtype='int64', copy=copy)
+        if dtype is None:
+            raise ValueError('dtype is not specified and cannot be inferred')
+        dtype = cast(PeriodDtype, dtype)
+        NDArrayBacked.__init__(self, values, dtype)
+
+    @classmethod
+    def _simple_new(cls, values: npt.NDArray[np.int64], dtype: PeriodDtype) -> Self:
+        assertion_msg = 'Should be numpy array of type i8'
+        assert isinstance(values, np.ndarray) and values.dtype == 'i8', assertion_msg
+        return cls(values, dtype=dtype)
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype: Dtype | None=None, copy: bool=False) -> Self:
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+        if dtype and isinstance(dtype, PeriodDtype):
+            freq = dtype.freq
+        else:
+            freq = None
+        if isinstance(scalars, cls):
+            validate_dtype_freq(scalars.dtype, freq)
+            if copy:
+                scalars = scalars.copy()
+            return scalars
+        periods = np.asarray(scalars, dtype=object)
+        freq = freq or libperiod.extract_freq(periods)
+        ordinals = libperiod.extract_ordinals(periods, freq)
+        dtype = PeriodDtype(freq)
+        return cls(ordinals, dtype=dtype)
+
+    @classmethod
+    def _from_sequence_of_strings(cls, strings, *, dtype: ExtensionDtype, copy: bool=False) -> Self:
+        return cls._from_sequence(strings, dtype=dtype, copy=copy)
+
+    @classmethod
+    def _from_datetime64(cls, data, freq, tz=None) -> Self:
+        if isinstance(freq, BaseOffset):
+            freq = PeriodDtype(freq)._freqstr
+        (data, freq) = dt64arr_to_periodarr(data, freq, tz)
+        dtype = PeriodDtype(freq)
+        return cls(data, dtype=dtype)
+
+    @classmethod
+    def _generate_range(cls, start, end, periods, freq):
+        periods = dtl.validate_periods(periods)
+        if freq is not None:
+            freq = Period._maybe_convert_freq(freq)
+        if start is not None or end is not None:
+            (subarr, freq) = _get_ordinal_range(start, end, periods, freq)
+        else:
+            raise ValueError('Not enough parameters to construct Period range')
+        return (subarr, freq)
+
+    @classmethod
+    def _from_fields(cls, *, fields: dict, freq) -> Self:
+        (subarr, freq) = _range_from_fields(freq=freq, **fields)
+        dtype = PeriodDtype(freq)
+        return cls._simple_new(subarr, dtype=dtype)
+
+    def _unbox_scalar(self, value: Period | NaTType) -> np.int64:
+        if value is NaT:
+            return np.int64(value._value)
+        elif isinstance(value, self._scalar_type):
+            self._check_compatible_with(value)
+            return np.int64(value.ordinal)
+        else:
+            raise ValueError(f"'value' should be a Period. Got '{value}' instead.")
+
+    def _scalar_from_string(self, value: str) -> Period:
+        return Period(value, freq=self.freq)
+
+    def _check_compatible_with(self, other: Period | NaTType | PeriodArray) -> None:
+        if other is NaT:
+            return
+        self._require_matching_freq(other.freq)
+
+    @cache_readonly
+    def dtype(self) -> PeriodDtype:
+        return self._dtype
+
+    @property
+    def freq(self) -> BaseOffset:
+        return self.dtype.freq
+
+    @property
+    def freqstr(self) -> str:
+        return PeriodDtype(self.freq)._freqstr
+
+    def __array__(self, dtype: NpDtype | None=None, copy: bool | None=None) -> np.ndarray:
+        if dtype == 'i8':
+            return self.asi8
+        elif dtype == bool:
+            return ~self._isnan
+        return np.array(list(self), dtype=object)
+
+    def __arrow_array__(self, type=None):
+        import pyarrow
+        from pandas.core.arrays.arrow.extension_types import ArrowPeriodType
+        if type is not None:
+            if pyarrow.types.is_integer(type):
+                return pyarrow.array(self._ndarray, mask=self.isna(), type=type)
+            elif isinstance(type, ArrowPeriodType):
+                if self.freqstr != type.freq:
+                    raise TypeError(f"Not supported to convert PeriodArray to array with different 'freq' ({self.freqstr} vs {type.freq})")
+            else:
+                raise TypeError(f"Not supported to convert PeriodArray to '{type}' type")
+        period_type = ArrowPeriodType(self.freqstr)
+        storage_array = pyarrow.array(self._ndarray, mask=self.isna(), type='int64')
+        return pyarrow.ExtensionArray.from_storage(period_type, storage_array)
+    year = _field_accessor('year', '\n        The year of the period.\n\n        See Also\n        --------\n        PeriodIndex.day_of_year : The ordinal day of the year.\n        PeriodIndex.dayofyear : The ordinal day of the year.\n        PeriodIndex.is_leap_year : Logical indicating if the date belongs to a\n            leap year.\n        PeriodIndex.weekofyear : The week ordinal of the year.\n        PeriodIndex.year : The year of the period.\n\n        Examples\n        --------\n        >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y")\n        >>> idx.year\n        Index([2023, 2024, 2025], dtype=\'int64\')\n        ')
+    month = _field_accessor('month', '\n        The month as January=1, December=12.\n\n        See Also\n        --------\n        PeriodIndex.days_in_month : The number of days in the month.\n        PeriodIndex.daysinmonth : The number of days in the month.\n\n        Examples\n        --------\n        >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M")\n        >>> idx.month\n        Index([1, 2, 3], dtype=\'int64\')\n        ')
+    day = _field_accessor('day', "\n        The days of the period.\n\n        See Also\n        --------\n        PeriodIndex.day_of_week : The day of the week with Monday=0, Sunday=6.\n        PeriodIndex.day_of_year : The ordinal day of the year.\n        PeriodIndex.dayofweek : The day of the week with Monday=0, Sunday=6.\n        PeriodIndex.dayofyear : The ordinal day of the year.\n        PeriodIndex.days_in_month : The number of days in the month.\n        PeriodIndex.daysinmonth : The number of days in the month.\n        PeriodIndex.weekday : The day of the week with Monday=0, Sunday=6.\n\n        Examples\n        --------\n        >>> idx = pd.PeriodIndex(['2020-01-31', '2020-02-28'], freq='D')\n        >>> idx.day\n        Index([31, 28], dtype='int64')\n        ")
+    hour = _field_accessor('hour', '\n        The hour of the period.\n\n        See Also\n        --------\n        PeriodIndex.minute : The minute of the period.\n        PeriodIndex.second : The second of the period.\n        PeriodIndex.to_timestamp : Cast to DatetimeArray/Index.\n\n        Examples\n        --------\n        >>> idx = pd.PeriodIndex(["2023-01-01 10:00", "2023-01-01 11:00"], freq=\'h\')\n        >>> idx.hour\n        Index([10, 11], dtype=\'int64\')\n        ')
+    minute = _field_accessor('minute', '\n        The minute of the period.\n\n        See Also\n        --------\n        PeriodIndex.hour : The hour of the period.\n        PeriodIndex.second : The second of the period.\n        PeriodIndex.to_timestamp : Cast to DatetimeArray/Index.\n\n        Examples\n        --------\n        >>> idx = pd.PeriodIndex(["2023-01-01 10:30:00",\n        ...                       "2023-01-01 11:50:00"], freq=\'min\')\n        >>> idx.minute\n        Index([30, 50], dtype=\'int64\')\n        ')
+    second = _field_accessor('second', '\n        The second of the period.\n\n        See Also\n        --------\n        PeriodIndex.hour : The hour of the period.\n        PeriodIndex.minute : The minute of the period.\n        PeriodIndex.to_timestamp : Cast to DatetimeArray/Index.\n\n        Examples\n        --------\n        >>> idx = pd.PeriodIndex(["2023-01-01 10:00:30",\n        ...                       "2023-01-01 10:00:31"], freq=\'s\')\n        >>> idx.second\n        Index([30, 31], dtype=\'int64\')\n        ')
+    weekofyear = _field_accessor('week', '\n        The week ordinal of the year.\n\n        See Also\n        --------\n        PeriodIndex.day_of_week : The day of the week with Monday=0, Sunday=6.\n        PeriodIndex.dayofweek : The day of the week with Monday=0, Sunday=6.\n        PeriodIndex.week : The week ordinal of the year.\n        PeriodIndex.weekday : The day of the week with Monday=0, Sunday=6.\n        PeriodIndex.year : The year of the period.\n\n        Examples\n        --------\n        >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M")\n        >>> idx.week  # It can be written `weekofyear`\n        Index([5, 9, 13], dtype=\'int64\')\n        ')
+    week = weekofyear
+    day_of_week = _field_accessor('day_of_week', '\n        The day of the week with Monday=0, Sunday=6.\n\n        See Also\n        --------\n        PeriodIndex.day : The days of the period.\n        PeriodIndex.day_of_week : The day of the week with Monday=0, Sunday=6.\n        PeriodIndex.day_of_year : The ordinal day of the year.\n        PeriodIndex.dayofweek : The day of the week with Monday=0, Sunday=6.\n        PeriodIndex.dayofyear : The ordinal day of the year.\n        PeriodIndex.week : The week ordinal of the year.\n        PeriodIndex.weekday : The day of the week with Monday=0, Sunday=6.\n        PeriodIndex.weekofyear : The week ordinal of the year.\n\n        Examples\n        --------\n        >>> idx = pd.PeriodIndex(["2023-01-01", "2023-01-02", "2023-01-03"], freq="D")\n        >>> idx.weekday\n        Index([6, 0, 1], dtype=\'int64\')\n        ')
+    dayofweek = day_of_week
+    weekday = dayofweek
+    dayofyear = day_of_year = _field_accessor('day_of_year', '\n        The ordinal day of the year.\n\n        See Also\n        --------\n        PeriodIndex.day : The days of the period.\n        PeriodIndex.day_of_week : The day of the week with Monday=0, Sunday=6.\n        PeriodIndex.day_of_year : The ordinal day of the year.\n        PeriodIndex.dayofweek : The day of the week with Monday=0, Sunday=6.\n        PeriodIndex.dayofyear : The ordinal day of the year.\n        PeriodIndex.weekday : The day of the week with Monday=0, Sunday=6.\n        PeriodIndex.weekofyear : The week ordinal of the year.\n        PeriodIndex.year : The year of the period.\n\n        Examples\n        --------\n        >>> idx = pd.PeriodIndex(["2023-01-10", "2023-02-01", "2023-03-01"], freq="D")\n        >>> idx.dayofyear\n        Index([10, 32, 60], dtype=\'int64\')\n\n        >>> idx = pd.PeriodIndex(["2023", "2024", "2025"], freq="Y")\n        >>> idx\n        PeriodIndex([\'2023\', \'2024\', \'2025\'], dtype=\'period[Y-DEC]\')\n        >>> idx.dayofyear\n        Index([365, 366, 365], dtype=\'int64\')\n        ')
+    quarter = _field_accessor('quarter', '\n        The quarter of the date.\n\n        See Also\n        --------\n        PeriodIndex.qyear : Fiscal year the Period lies in according to its\n            starting-quarter.\n\n        Examples\n        --------\n        >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M")\n        >>> idx.quarter\n        Index([1, 1, 1], dtype=\'int64\')\n        ')
+    qyear = _field_accessor('qyear', "\n        Fiscal year the Period lies in according to its starting-quarter.\n\n        The `year` and the `qyear` of the period will be the same if the fiscal\n        and calendar years are the same. When they are not, the fiscal year\n        can be different from the calendar year of the period.\n\n        Returns\n        -------\n        int\n            The fiscal year of the period.\n\n        See Also\n        --------\n        PeriodIndex.quarter : The quarter of the date.\n        PeriodIndex.year : The year of the period.\n\n        Examples\n        --------\n        If the natural and fiscal year are the same, `qyear` and `year` will\n        be the same.\n\n        >>> per = pd.Period('2018Q1', freq='Q')\n        >>> per.qyear\n        2018\n        >>> per.year\n        2018\n\n        If the fiscal year starts in April (`Q-MAR`), the first quarter of\n        2018 will start in April 2017. `year` will then be 2017, but `qyear`\n        will be the fiscal year, 2018.\n\n        >>> per = pd.Period('2018Q1', freq='Q-MAR')\n        >>> per.start_time\n        Timestamp('2017-04-01 00:00:00')\n        >>> per.qyear\n        2018\n        >>> per.year\n        2017\n        ")
+    days_in_month = _field_accessor('days_in_month', '\n        The number of days in the month.\n\n        See Also\n        --------\n        PeriodIndex.day : The days of the period.\n        PeriodIndex.days_in_month : The number of days in the month.\n        PeriodIndex.daysinmonth : The number of days in the month.\n        PeriodIndex.month : The month as January=1, December=12.\n\n        Examples\n        --------\n        For Series:\n\n        >>> period = pd.period_range(\'2020-1-1 00:00\', \'2020-3-1 00:00\', freq=\'M\')\n        >>> s = pd.Series(period)\n        >>> s\n        0   2020-01\n        1   2020-02\n        2   2020-03\n        dtype: period[M]\n        >>> s.dt.days_in_month\n        0    31\n        1    29\n        2    31\n        dtype: int64\n\n        For PeriodIndex:\n\n        >>> idx = pd.PeriodIndex(["2023-01", "2023-02", "2023-03"], freq="M")\n        >>> idx.days_in_month   # It can be also entered as `daysinmonth`\n        Index([31, 28, 31], dtype=\'int64\')\n        ')
+    daysinmonth = days_in_month
+
+    @property
+    def is_leap_year(self) -> npt.NDArray[np.bool_]:
+        return isleapyear_arr(np.asarray(self.year))
+
+    def to_timestamp(self, freq=None, how: str='start') -> DatetimeArray:
+        from pandas.core.arrays import DatetimeArray
+        how = libperiod.validate_end_alias(how)
+        end = how == 'E'
+        if end:
+            if freq == 'B' or self.freq == 'B':
+                adjust = Timedelta(1, 'D') - Timedelta(1, 'ns')
+                return self.to_timestamp(how='start') + adjust
+            else:
+                adjust = Timedelta(1, 'ns')
+                return (self + self.freq).to_timestamp(how='start') - adjust
+        if freq is None:
+            freq_code = self._dtype._get_to_timestamp_base()
+            dtype = PeriodDtypeBase(freq_code, 1)
+            freq = dtype._freqstr
+            base = freq_code
+        else:
+            freq = Period._maybe_convert_freq(freq)
+            base = freq._period_dtype_code
+        new_parr = self.asfreq(freq, how=how)
+        new_data = libperiod.periodarr_to_dt64arr(new_parr.asi8, base)
+        dta = DatetimeArray._from_sequence(new_data)
+        if self.freq.name == 'B':
+            diffs = libalgos.unique_deltas(self.asi8)
+            if len(diffs) == 1:
+                diff = diffs[0]
+                if diff == self.dtype._n:
+                    dta._freq = self.freq
+                elif diff == 1:
+                    dta._freq = self.freq.base
+            return dta
+        else:
+            return dta._with_freq('infer')
+
+    def _box_func(self, x) -> Period | NaTType:
+        return Period._from_ordinal(ordinal=x, freq=self.freq)
+
+    @doc(**_shared_doc_kwargs, other='PeriodIndex', other_name='PeriodIndex')
+    def asfreq(self, freq=None, how: str='E') -> Self:
+        how = libperiod.validate_end_alias(how)
+        if isinstance(freq, BaseOffset) and hasattr(freq, '_period_dtype_code'):
+            freq = PeriodDtype(freq)._freqstr
+        freq = Period._maybe_convert_freq(freq)
+        base1 = self._dtype._dtype_code
+        base2 = freq._period_dtype_code
+        asi8 = self.asi8
+        end = how == 'E'
+        if end:
+            ordinal = asi8 + self.dtype._n - 1
+        else:
+            ordinal = asi8
+        new_data = period_asfreq_arr(ordinal, base1, base2, end)
+        if self._hasna:
+            new_data[self._isnan] = iNaT
+        dtype = PeriodDtype(freq)
+        return type(self)(new_data, dtype=dtype)
+
+    def _formatter(self, boxed: bool=False) -> Callable[[object], str]:
+        if boxed:
+            return str
+        return "'{}'".format
+
+    def _format_native_types(self, *, na_rep: str | float='NaT', date_format=None, **kwargs) -> npt.NDArray[np.object_]:
+        return libperiod.period_array_strftime(self.asi8, self.dtype._dtype_code, na_rep, date_format)
+
+    def astype(self, dtype, copy: bool=True):
+        dtype = pandas_dtype(dtype)
+        if dtype == self._dtype:
+            if not copy:
+                return self
+            else:
+                return self.copy()
+        if isinstance(dtype, PeriodDtype):
+            return self.asfreq(dtype.freq)
+        if lib.is_np_dtype(dtype, 'M') or isinstance(dtype, DatetimeTZDtype):
+            tz = getattr(dtype, 'tz', None)
+            unit = dtl.dtype_to_unit(dtype)
+            return self.to_timestamp().tz_localize(tz).as_unit(unit)
+        return super().astype(dtype, copy=copy)
+
+    def searchsorted(self, value: NumpyValueArrayLike | ExtensionArray, side: Literal['left', 'right']='left', sorter: NumpySorter | None=None) -> npt.NDArray[np.intp] | np.intp:
+        npvalue = self._validate_setitem_value(value).view('M8[ns]')
+        m8arr = self._ndarray.view('M8[ns]')
+        return m8arr.searchsorted(npvalue, side=side, sorter=sorter)
+
+    def _pad_or_backfill(self, *, method: FillnaOptions, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None, copy: bool=True) -> Self:
+        dta = self.view('M8[ns]')
+        result = dta._pad_or_backfill(method=method, limit=limit, limit_area=limit_area, copy=copy)
+        if copy:
+            return cast('Self', result.view(self.dtype))
+        else:
+            return self
+
+    def _addsub_int_array_or_scalar(self, other: np.ndarray | int, op: Callable[[Any, Any], Any]) -> Self:
+        assert op in [operator.add, operator.sub]
+        if op is operator.sub:
+            other = -other
+        res_values = add_overflowsafe(self.asi8, np.asarray(other, dtype='i8'))
+        return type(self)(res_values, dtype=self.dtype)
+
+    def _add_offset(self, other: BaseOffset):
+        assert not isinstance(other, Tick)
+        self._require_matching_freq(other, base=True)
+        return self._addsub_int_array_or_scalar(other.n, operator.add)
+
+    def _add_timedeltalike_scalar(self, other):
+        if not isinstance(self.freq, Tick):
+            raise raise_on_incompatible(self, other)
+        if isna(other):
+            return super()._add_timedeltalike_scalar(other)
+        td = np.asarray(Timedelta(other).asm8)
+        return self._add_timedelta_arraylike(td)
+
+    def _add_timedelta_arraylike(self, other: TimedeltaArray | npt.NDArray[np.timedelta64]) -> Self:
+        if not self.dtype._is_tick_like():
+            raise TypeError(f'Cannot add or subtract timedelta64[ns] dtype from {self.dtype}')
+        dtype = np.dtype(f'm8[{self.dtype._td64_unit}]')
+        try:
+            delta = astype_overflowsafe(np.asarray(other), dtype=dtype, copy=False, round_ok=False)
+        except ValueError as err:
+            raise IncompatibleFrequency("Cannot add/subtract timedelta-like from PeriodArray that is not an integer multiple of the PeriodArray's freq.") from err
+        res_values = add_overflowsafe(self.asi8, np.asarray(delta.view('i8')))
+        return type(self)(res_values, dtype=self.dtype)
+
+    def _check_timedeltalike_freq_compat(self, other):
+        assert self.dtype._is_tick_like()
+        dtype = np.dtype(f'm8[{self.dtype._td64_unit}]')
+        if isinstance(other, (timedelta, np.timedelta64, Tick)):
+            td = np.asarray(Timedelta(other).asm8)
+        else:
+            td = np.asarray(other)
+        try:
+            delta = astype_overflowsafe(td, dtype=dtype, copy=False, round_ok=False)
+        except ValueError as err:
+            raise raise_on_incompatible(self, other) from err
+        delta = delta.view('i8')
+        return lib.item_from_zerodim(delta)
+
+    def _reduce(self, name: str, *, skipna: bool=True, keepdims: bool=False, **kwargs):
+        result = super()._reduce(name, skipna=skipna, keepdims=keepdims, **kwargs)
+        if keepdims and isinstance(result, np.ndarray):
+            return self._from_sequence(result, dtype=self.dtype)
+        return result
+
+def raise_on_incompatible(left, right) -> IncompatibleFrequency:
+    if isinstance(right, (np.ndarray, ABCTimedeltaArray)) or right is None:
+        other_freq = None
+    elif isinstance(right, BaseOffset):
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', 'PeriodDtype\\[B\\] is deprecated', category=FutureWarning)
+            other_freq = PeriodDtype(right)._freqstr
+    elif isinstance(right, (ABCPeriodIndex, PeriodArray, Period)):
+        other_freq = right.freqstr
+    else:
+        other_freq = delta_to_tick(Timedelta(right)).freqstr
+    own_freq = PeriodDtype(left.freq)._freqstr
+    msg = DIFFERENT_FREQ.format(cls=type(left).__name__, own_freq=own_freq, other_freq=other_freq)
+    return IncompatibleFrequency(msg)
+
+def period_array(data: Sequence[Period | str | None] | AnyArrayLike, freq: str | Tick | BaseOffset | None=None, copy: bool=False) -> PeriodArray:
+    data_dtype = getattr(data, 'dtype', None)
+    if lib.is_np_dtype(data_dtype, 'M'):
+        return PeriodArray._from_datetime64(data, freq)
+    if isinstance(data_dtype, PeriodDtype):
+        out = PeriodArray(data)
+        if freq is not None:
+            if freq == data_dtype.freq:
+                return out
+            return out.asfreq(freq)
+        return out
+    if not isinstance(data, (np.ndarray, list, tuple, ABCSeries)):
+        data = list(data)
+    arrdata = np.asarray(data)
+    dtype: PeriodDtype | None
+    if freq:
+        dtype = PeriodDtype(freq)
+    else:
+        dtype = None
+    if arrdata.dtype.kind == 'f' and len(arrdata) > 0:
+        raise TypeError('PeriodIndex does not allow floating point in construction')
+    if arrdata.dtype.kind in 'iu':
+        arr = arrdata.astype(np.int64, copy=False)
+        ordinals = libperiod.from_ordinals(arr, freq)
+        return PeriodArray(ordinals, dtype=dtype)
+    data = ensure_object(arrdata)
+    if freq is None:
+        freq = libperiod.extract_freq(data)
+    dtype = PeriodDtype(freq)
+    return PeriodArray._from_sequence(data, dtype=dtype)
+
+@overload
+def validate_dtype_freq(dtype, freq: BaseOffsetT) -> BaseOffsetT:
+    ...
+
+@overload
+def validate_dtype_freq(dtype, freq: timedelta | str | None) -> BaseOffset:
+    ...
+
+def validate_dtype_freq(dtype, freq: BaseOffsetT | BaseOffset | timedelta | str | None) -> BaseOffsetT:
+    if freq is not None:
+        freq = to_offset(freq, is_period=True)
+    if dtype is not None:
+        dtype = pandas_dtype(dtype)
+        if not isinstance(dtype, PeriodDtype):
+            raise ValueError('dtype must be PeriodDtype')
+        if freq is None:
+            freq = dtype.freq
+        elif freq != dtype.freq:
+            raise IncompatibleFrequency('specified freq and dtype are different')
+    return freq
+
+def dt64arr_to_periodarr(data, freq, tz=None) -> tuple[npt.NDArray[np.int64], BaseOffset]:
+    if not isinstance(data.dtype, np.dtype) or data.dtype.kind != 'M':
+        raise ValueError(f'Wrong dtype: {data.dtype}')
+    if freq is None:
+        if isinstance(data, ABCIndex):
+            (data, freq) = (data._values, data.freq)
+        elif isinstance(data, ABCSeries):
+            (data, freq) = (data._values, data.dt.freq)
+    elif isinstance(data, (ABCIndex, ABCSeries)):
+        data = data._values
+    reso = get_unit_from_dtype(data.dtype)
+    freq = Period._maybe_convert_freq(freq)
+    base = freq._period_dtype_code
+    return (c_dt64arr_to_periodarr(data.view('i8'), base, tz, reso=reso), freq)
+
+def _get_ordinal_range(start, end, periods, freq, mult: int=1):
+    if com.count_not_none(start, end, periods) != 2:
+        raise ValueError('Of the three parameters: start, end, and periods, exactly two must be specified')
+    if freq is not None:
+        freq = to_offset(freq, is_period=True)
+        mult = freq.n
+    if start is not None:
+        start = Period(start, freq)
+    if end is not None:
+        end = Period(end, freq)
+    is_start_per = isinstance(start, Period)
+    is_end_per = isinstance(end, Period)
+    if is_start_per and is_end_per and (start.freq != end.freq):
+        raise ValueError('start and end must have same freq')
+    if start is NaT or end is NaT:
+        raise ValueError('start and end must not be NaT')
+    if freq is None:
+        if is_start_per:
+            freq = start.freq
+        elif is_end_per:
+            freq = end.freq
+        else:
+            raise ValueError('Could not infer freq from start/end')
+        mult = freq.n
+    if periods is not None:
+        periods = periods * mult
+        if start is None:
+            data = np.arange(end.ordinal - periods + mult, end.ordinal + 1, mult, dtype=np.int64)
+        else:
+            data = np.arange(start.ordinal, start.ordinal + periods, mult, dtype=np.int64)
+    else:
+        data = np.arange(start.ordinal, end.ordinal + 1, mult, dtype=np.int64)
+    return (data, freq)
+
+def _range_from_fields(year=None, month=None, quarter=None, day=None, hour=None, minute=None, second=None, freq=None) -> tuple[np.ndarray, BaseOffset]:
+    if hour is None:
+        hour = 0
+    if minute is None:
+        minute = 0
+    if second is None:
+        second = 0
+    if day is None:
+        day = 1
+    ordinals = []
+    if quarter is not None:
+        if freq is None:
+            freq = to_offset('Q', is_period=True)
+            base = FreqGroup.FR_QTR.value
+        else:
+            freq = to_offset(freq, is_period=True)
+            base = libperiod.freq_to_dtype_code(freq)
+            if base != FreqGroup.FR_QTR.value:
+                raise AssertionError('base must equal FR_QTR')
+        freqstr = freq.freqstr
+        (year, quarter) = _make_field_arrays(year, quarter)
+        for (y, q) in zip(year, quarter):
+            (calendar_year, calendar_month) = parsing.quarter_to_myear(y, q, freqstr)
+            val = libperiod.period_ordinal(calendar_year, calendar_month, 1, 1, 1, 1, 0, 0, base)
+            ordinals.append(val)
+    else:
+        freq = to_offset(freq, is_period=True)
+        base = libperiod.freq_to_dtype_code(freq)
+        arrays = _make_field_arrays(year, month, day, hour, minute, second)
+        for (y, mth, d, h, mn, s) in zip(*arrays):
+            ordinals.append(libperiod.period_ordinal(y, mth, d, h, mn, s, 0, 0, base))
+    return (np.array(ordinals, dtype=np.int64), freq)
+
+def _make_field_arrays(*fields) -> list[np.ndarray]:
+    length = None
+    for x in fields:
+        if isinstance(x, (list, np.ndarray, ABCSeries)):
+            if length is not None and len(x) != length:
+                raise ValueError('Mismatched Period array lengths')
+            if length is None:
+                length = len(x)
+    return [np.asarray(x) if isinstance(x, (np.ndarray, list, ABCSeries)) else np.repeat(x, length) for x in fields]
+
+# File: pandas-main/pandas/core/arrays/sparse/__init__.py
+from pandas.core.arrays.sparse.accessor import SparseAccessor, SparseFrameAccessor
+from pandas.core.arrays.sparse.array import BlockIndex, IntIndex, SparseArray, make_sparse_index
+__all__ = ['BlockIndex', 'IntIndex', 'make_sparse_index', 'SparseAccessor', 'SparseArray', 'SparseFrameAccessor']
+
+# File: pandas-main/pandas/core/arrays/sparse/accessor.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas.compat._optional import import_optional_dependency
+from pandas.core.dtypes.cast import find_common_type
+from pandas.core.dtypes.dtypes import SparseDtype
+from pandas.core.accessor import PandasDelegate, delegate_names
+from pandas.core.arrays.sparse.array import SparseArray
+if TYPE_CHECKING:
+    from scipy.sparse import coo_matrix, spmatrix
+    from pandas import DataFrame, Series
+
+class BaseAccessor:
+    _validation_msg = "Can only use the '.sparse' accessor with Sparse data."
+
+    def __init__(self, data=None) -> None:
+        self._parent = data
+        self._validate(data)
+
+    def _validate(self, data) -> None:
+        raise NotImplementedError
+
+@delegate_names(SparseArray, ['npoints', 'density', 'fill_value', 'sp_values'], typ='property')
+class SparseAccessor(BaseAccessor, PandasDelegate):
+
+    def _validate(self, data) -> None:
+        if not isinstance(data.dtype, SparseDtype):
+            raise AttributeError(self._validation_msg)
+
+    def _delegate_property_get(self, name: str, *args, **kwargs):
+        return getattr(self._parent.array, name)
+
+    def _delegate_method(self, name: str, *args, **kwargs):
+        if name == 'from_coo':
+            return self.from_coo(*args, **kwargs)
+        elif name == 'to_coo':
+            return self.to_coo(*args, **kwargs)
+        else:
+            raise ValueError
+
+    @classmethod
+    def from_coo(cls, A, dense_index: bool=False) -> Series:
+        from pandas import Series
+        from pandas.core.arrays.sparse.scipy_sparse import coo_to_sparse_series
+        result = coo_to_sparse_series(A, dense_index=dense_index)
+        result = Series(result.array, index=result.index, copy=False)
+        return result
+
+    def to_coo(self, row_levels=(0,), column_levels=(1,), sort_labels: bool=False) -> tuple[coo_matrix, list, list]:
+        from pandas.core.arrays.sparse.scipy_sparse import sparse_series_to_coo
+        (A, rows, columns) = sparse_series_to_coo(self._parent, row_levels, column_levels, sort_labels=sort_labels)
+        return (A, rows, columns)
+
+    def to_dense(self) -> Series:
+        from pandas import Series
+        return Series(self._parent.array.to_dense(), index=self._parent.index, name=self._parent.name, copy=False)
+
+class SparseFrameAccessor(BaseAccessor, PandasDelegate):
+
+    def _validate(self, data) -> None:
+        dtypes = data.dtypes
+        if not all((isinstance(t, SparseDtype) for t in dtypes)):
+            raise AttributeError(self._validation_msg)
+
+    @classmethod
+    def from_spmatrix(cls, data, index=None, columns=None) -> DataFrame:
+        from pandas._libs.sparse import IntIndex
+        from pandas import DataFrame
+        data = data.tocsc()
+        (index, columns) = cls._prep_index(data, index, columns)
+        (n_rows, n_columns) = data.shape
+        data.sort_indices()
+        indices = data.indices
+        indptr = data.indptr
+        array_data = data.data
+        dtype = SparseDtype(array_data.dtype)
+        arrays = []
+        for i in range(n_columns):
+            sl = slice(indptr[i], indptr[i + 1])
+            idx = IntIndex(n_rows, indices[sl], check_integrity=False)
+            arr = SparseArray._simple_new(array_data[sl], idx, dtype)
+            arrays.append(arr)
+        return DataFrame._from_arrays(arrays, columns=columns, index=index, verify_integrity=False)
+
+    def to_dense(self) -> DataFrame:
+        from pandas import DataFrame
+        data = {k: v.array.to_dense() for (k, v) in self._parent.items()}
+        return DataFrame(data, index=self._parent.index, columns=self._parent.columns)
+
+    def to_coo(self) -> spmatrix:
+        import_optional_dependency('scipy')
+        from scipy.sparse import coo_matrix
+        dtype = find_common_type(self._parent.dtypes.to_list())
+        if isinstance(dtype, SparseDtype):
+            dtype = dtype.subtype
+        (cols, rows, data) = ([], [], [])
+        for (col, (_, ser)) in enumerate(self._parent.items()):
+            sp_arr = ser.array
+            row = sp_arr.sp_index.indices
+            cols.append(np.repeat(col, len(row)))
+            rows.append(row)
+            data.append(sp_arr.sp_values.astype(dtype, copy=False))
+        cols = np.concatenate(cols)
+        rows = np.concatenate(rows)
+        data = np.concatenate(data)
+        return coo_matrix((data, (rows, cols)), shape=self._parent.shape)
+
+    @property
+    def density(self) -> float:
+        tmp = np.mean([column.array.density for (_, column) in self._parent.items()])
+        return tmp
+
+    @staticmethod
+    def _prep_index(data, index, columns):
+        from pandas.core.indexes.api import default_index, ensure_index
+        (N, K) = data.shape
+        if index is None:
+            index = default_index(N)
+        else:
+            index = ensure_index(index)
+        if columns is None:
+            columns = default_index(K)
+        else:
+            columns = ensure_index(columns)
+        if len(columns) != K:
+            raise ValueError(f'Column length mismatch: {len(columns)} vs. {K}')
+        if len(index) != N:
+            raise ValueError(f'Index length mismatch: {len(index)} vs. {N}')
+        return (index, columns)
+
+# File: pandas-main/pandas/core/arrays/sparse/array.py
+""""""
+from __future__ import annotations
+from collections import abc
+import numbers
+import operator
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
+import warnings
+import numpy as np
+from pandas._config.config import get_option
+from pandas._libs import lib
+import pandas._libs.sparse as splib
+from pandas._libs.sparse import BlockIndex, IntIndex, SparseIndex
+from pandas._libs.tslibs import NaT
+from pandas.compat.numpy import function as nv
+from pandas.errors import PerformanceWarning
+from pandas.util._decorators import doc
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import validate_bool_kwarg, validate_insert_loc
+from pandas.core.dtypes.astype import astype_array
+from pandas.core.dtypes.cast import find_common_type, maybe_box_datetimelike
+from pandas.core.dtypes.common import is_bool_dtype, is_integer, is_list_like, is_object_dtype, is_scalar, is_string_dtype, pandas_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype, SparseDtype
+from pandas.core.dtypes.generic import ABCIndex, ABCSeries
+from pandas.core.dtypes.missing import isna, na_value_for_dtype, notna
+from pandas.core import arraylike
+import pandas.core.algorithms as algos
+from pandas.core.arraylike import OpsMixin
+from pandas.core.arrays import ExtensionArray
+from pandas.core.base import PandasObject
+import pandas.core.common as com
+from pandas.core.construction import ensure_wrapped_if_datetimelike, extract_array, sanitize_array
+from pandas.core.indexers import check_array_indexer, unpack_tuple_and_ellipses
+from pandas.core.nanops import check_below_min_count
+from pandas.io.formats import printing
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+    from enum import Enum
+
+    class ellipsis(Enum):
+        Ellipsis = '...'
+    Ellipsis = ellipsis.Ellipsis
+    from scipy.sparse import spmatrix
+    from pandas._typing import NumpySorter
+    SparseIndexKind = Literal['integer', 'block']
+    from pandas._typing import ArrayLike, AstypeArg, Axis, AxisInt, Dtype, NpDtype, PositionalIndexer, Scalar, ScalarIndexer, Self, SequenceIndexer, npt
+    from pandas import Series
+else:
+    ellipsis = type(Ellipsis)
+_sparray_doc_kwargs = {'klass': 'SparseArray'}
+
+def _get_fill(arr: SparseArray) -> np.ndarray:
+    try:
+        return np.asarray(arr.fill_value, dtype=arr.dtype.subtype)
+    except ValueError:
+        return np.asarray(arr.fill_value)
+
+def _sparse_array_op(left: SparseArray, right: SparseArray, op: Callable, name: str) -> SparseArray:
+    if name.startswith('__'):
+        name = name[2:-2]
+    ltype = left.dtype.subtype
+    rtype = right.dtype.subtype
+    if ltype != rtype:
+        subtype = find_common_type([ltype, rtype])
+        ltype = SparseDtype(subtype, left.fill_value)
+        rtype = SparseDtype(subtype, right.fill_value)
+        left = left.astype(ltype, copy=False)
+        right = right.astype(rtype, copy=False)
+        dtype = ltype.subtype
+    else:
+        dtype = ltype
+    result_dtype = None
+    if left.sp_index.ngaps == 0 or right.sp_index.ngaps == 0:
+        with np.errstate(all='ignore'):
+            result = op(left.to_dense(), right.to_dense())
+            fill = op(_get_fill(left), _get_fill(right))
+        if left.sp_index.ngaps == 0:
+            index = left.sp_index
+        else:
+            index = right.sp_index
+    elif left.sp_index.equals(right.sp_index):
+        with np.errstate(all='ignore'):
+            result = op(left.sp_values, right.sp_values)
+            fill = op(_get_fill(left), _get_fill(right))
+        index = left.sp_index
+    else:
+        if name[0] == 'r':
+            (left, right) = (right, left)
+            name = name[1:]
+        if name in ('and', 'or', 'xor') and dtype == 'bool':
+            opname = f'sparse_{name}_uint8'
+            left_sp_values = left.sp_values.view(np.uint8)
+            right_sp_values = right.sp_values.view(np.uint8)
+            result_dtype = bool
+        else:
+            opname = f'sparse_{name}_{dtype}'
+            left_sp_values = left.sp_values
+            right_sp_values = right.sp_values
+        if name in ['floordiv', 'mod'] and (right == 0).any() and (left.dtype.kind in 'iu'):
+            opname = f'sparse_{name}_float64'
+            left_sp_values = left_sp_values.astype('float64')
+            right_sp_values = right_sp_values.astype('float64')
+        sparse_op = getattr(splib, opname)
+        with np.errstate(all='ignore'):
+            (result, index, fill) = sparse_op(left_sp_values, left.sp_index, left.fill_value, right_sp_values, right.sp_index, right.fill_value)
+    if name == 'divmod':
+        return (_wrap_result(name, result[0], index, fill[0], dtype=result_dtype), _wrap_result(name, result[1], index, fill[1], dtype=result_dtype))
+    if result_dtype is None:
+        result_dtype = result.dtype
+    return _wrap_result(name, result, index, fill, dtype=result_dtype)
+
+def _wrap_result(name: str, data, sparse_index, fill_value, dtype: Dtype | None=None) -> SparseArray:
+    if name.startswith('__'):
+        name = name[2:-2]
+    if name in ('eq', 'ne', 'lt', 'gt', 'le', 'ge'):
+        dtype = bool
+    fill_value = lib.item_from_zerodim(fill_value)
+    if is_bool_dtype(dtype):
+        fill_value = bool(fill_value)
+    return SparseArray(data, sparse_index=sparse_index, fill_value=fill_value, dtype=dtype)
+
+class SparseArray(OpsMixin, PandasObject, ExtensionArray):
+    _subtyp = 'sparse_array'
+    _hidden_attrs = PandasObject._hidden_attrs | frozenset([])
+    _sparse_index: SparseIndex
+    _sparse_values: np.ndarray
+    _dtype: SparseDtype
+
+    def __init__(self, data, sparse_index=None, fill_value=None, kind: SparseIndexKind='integer', dtype: Dtype | None=None, copy: bool=False) -> None:
+        if fill_value is None and isinstance(dtype, SparseDtype):
+            fill_value = dtype.fill_value
+        if isinstance(data, type(self)):
+            if sparse_index is None:
+                sparse_index = data.sp_index
+            if fill_value is None:
+                fill_value = data.fill_value
+            if dtype is None:
+                dtype = data.dtype
+            data = data.sp_values
+        if isinstance(dtype, str):
+            try:
+                dtype = SparseDtype.construct_from_string(dtype)
+            except TypeError:
+                dtype = pandas_dtype(dtype)
+        if isinstance(dtype, SparseDtype):
+            if fill_value is None:
+                fill_value = dtype.fill_value
+            dtype = dtype.subtype
+        if is_scalar(data):
+            raise TypeError(f'Cannot construct {type(self).__name__} from scalar data. Pass a sequence instead.')
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+        if data is None:
+            data = np.array([], dtype=dtype)
+        try:
+            data = sanitize_array(data, index=None)
+        except ValueError:
+            if dtype is None:
+                dtype = np.dtype(object)
+                data = np.atleast_1d(np.asarray(data, dtype=dtype))
+            else:
+                raise
+        if copy:
+            data = data.copy()
+        if fill_value is None:
+            fill_value_dtype = data.dtype if dtype is None else dtype
+            if fill_value_dtype is None:
+                fill_value = np.nan
+            else:
+                fill_value = na_value_for_dtype(fill_value_dtype)
+        if isinstance(data, type(self)) and sparse_index is None:
+            sparse_index = data._sparse_index
+            sparse_values = np.asarray(data.sp_values, dtype=dtype)
+        elif sparse_index is None:
+            data = extract_array(data, extract_numpy=True)
+            if not isinstance(data, np.ndarray):
+                if isinstance(data.dtype, DatetimeTZDtype):
+                    warnings.warn(f'Creating SparseArray from {data.dtype} data loses timezone information. Cast to object before sparse to retain timezone information.', UserWarning, stacklevel=find_stack_level())
+                    data = np.asarray(data, dtype='datetime64[ns]')
+                    if fill_value is NaT:
+                        fill_value = np.datetime64('NaT', 'ns')
+                data = np.asarray(data)
+            (sparse_values, sparse_index, fill_value) = _make_sparse(data, kind=kind, fill_value=fill_value, dtype=dtype)
+        else:
+            sparse_values = np.asarray(data, dtype=dtype)
+            if len(sparse_values) != sparse_index.npoints:
+                raise AssertionError(f'Non array-like type {type(sparse_values)} must have the same length as the index')
+        self._sparse_index = sparse_index
+        self._sparse_values = sparse_values
+        self._dtype = SparseDtype(sparse_values.dtype, fill_value)
+
+    @classmethod
+    def _simple_new(cls, sparse_array: np.ndarray, sparse_index: SparseIndex, dtype: SparseDtype) -> Self:
+        new = object.__new__(cls)
+        new._sparse_index = sparse_index
+        new._sparse_values = sparse_array
+        new._dtype = dtype
+        return new
+
+    @classmethod
+    def from_spmatrix(cls, data: spmatrix) -> Self:
+        (length, ncol) = data.shape
+        if ncol != 1:
+            raise ValueError(f"'data' must have a single column, not '{ncol}'")
+        data = data.tocsc()
+        data.sort_indices()
+        arr = data.data
+        idx = data.indices
+        zero = np.array(0, dtype=arr.dtype).item()
+        dtype = SparseDtype(arr.dtype, zero)
+        index = IntIndex(length, idx)
+        return cls._simple_new(arr, index, dtype)
+
+    def __array__(self, dtype: NpDtype | None=None, copy: bool | None=None) -> np.ndarray:
+        fill_value = self.fill_value
+        if self.sp_index.ngaps == 0:
+            return self.sp_values
+        if dtype is None:
+            if self.sp_values.dtype.kind == 'M':
+                if fill_value is NaT:
+                    fill_value = np.datetime64('NaT')
+            try:
+                dtype = np.result_type(self.sp_values.dtype, type(fill_value))
+            except TypeError:
+                dtype = object
+        out = np.full(self.shape, fill_value, dtype=dtype)
+        out[self.sp_index.indices] = self.sp_values
+        return out
+
+    def __setitem__(self, key, value) -> None:
+        msg = 'SparseArray does not support item assignment via setitem'
+        raise TypeError(msg)
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype: Dtype | None=None, copy: bool=False) -> Self:
+        return cls(scalars, dtype=dtype)
+
+    @classmethod
+    def _from_factorized(cls, values, original) -> Self:
+        return cls(values, dtype=original.dtype)
+
+    @property
+    def sp_index(self) -> SparseIndex:
+        return self._sparse_index
+
+    @property
+    def sp_values(self) -> np.ndarray:
+        return self._sparse_values
+
+    @property
+    def dtype(self) -> SparseDtype:
+        return self._dtype
+
+    @property
+    def fill_value(self):
+        return self.dtype.fill_value
+
+    @fill_value.setter
+    def fill_value(self, value) -> None:
+        self._dtype = SparseDtype(self.dtype.subtype, value)
+
+    @property
+    def kind(self) -> SparseIndexKind:
+        if isinstance(self.sp_index, IntIndex):
+            return 'integer'
+        else:
+            return 'block'
+
+    @property
+    def _valid_sp_values(self) -> np.ndarray:
+        sp_vals = self.sp_values
+        mask = notna(sp_vals)
+        return sp_vals[mask]
+
+    def __len__(self) -> int:
+        return self.sp_index.length
+
+    @property
+    def _null_fill_value(self) -> bool:
+        return self._dtype._is_na_fill_value
+
+    @property
+    def nbytes(self) -> int:
+        return self.sp_values.nbytes + self.sp_index.nbytes
+
+    @property
+    def density(self) -> float:
+        return self.sp_index.npoints / self.sp_index.length
+
+    @property
+    def npoints(self) -> int:
+        return self.sp_index.npoints
+
+    def isna(self) -> Self:
+        dtype = SparseDtype(bool, self._null_fill_value)
+        if self._null_fill_value:
+            return type(self)._simple_new(isna(self.sp_values), self.sp_index, dtype)
+        mask = np.full(len(self), False, dtype=np.bool_)
+        mask[self.sp_index.indices] = isna(self.sp_values)
+        return type(self)(mask, fill_value=False, dtype=dtype)
+
+    def fillna(self, value, limit: int | None=None, copy: bool=True) -> Self:
+        if limit is not None:
+            raise ValueError('limit must be None')
+        new_values = np.where(isna(self.sp_values), value, self.sp_values)
+        if self._null_fill_value:
+            new_dtype = SparseDtype(self.dtype.subtype, fill_value=value)
+        else:
+            new_dtype = self.dtype
+        return self._simple_new(new_values, self._sparse_index, new_dtype)
+
+    def shift(self, periods: int=1, fill_value=None) -> Self:
+        if not len(self) or periods == 0:
+            return self.copy()
+        if isna(fill_value):
+            fill_value = self.dtype.na_value
+        subtype = np.result_type(fill_value, self.dtype.subtype)
+        if subtype != self.dtype.subtype:
+            arr = self.astype(SparseDtype(subtype, self.fill_value))
+        else:
+            arr = self
+        empty = self._from_sequence([fill_value] * min(abs(periods), len(self)), dtype=arr.dtype)
+        if periods > 0:
+            a = empty
+            b = arr[:-periods]
+        else:
+            a = arr[abs(periods):]
+            b = empty
+        return arr._concat_same_type([a, b])
+
+    def _first_fill_value_loc(self):
+        if len(self) == 0 or self.sp_index.npoints == len(self):
+            return -1
+        indices = self.sp_index.indices
+        if not len(indices) or indices[0] > 0:
+            return 0
+        diff = np.r_[np.diff(indices), 2]
+        return indices[(diff > 1).argmax()] + 1
+
+    @doc(ExtensionArray.duplicated)
+    def duplicated(self, keep: Literal['first', 'last', False]='first') -> npt.NDArray[np.bool_]:
+        values = np.asarray(self)
+        mask = np.asarray(self.isna())
+        return algos.duplicated(values, keep=keep, mask=mask)
+
+    def unique(self) -> Self:
+        uniques = algos.unique(self.sp_values)
+        if len(self.sp_values) != len(self):
+            fill_loc = self._first_fill_value_loc()
+            insert_loc = len(algos.unique(self.sp_values[:fill_loc]))
+            uniques = np.insert(uniques, insert_loc, self.fill_value)
+        return type(self)._from_sequence(uniques, dtype=self.dtype)
+
+    def _values_for_factorize(self):
+        return (np.asarray(self), self.fill_value)
+
+    def factorize(self, use_na_sentinel: bool=True) -> tuple[np.ndarray, SparseArray]:
+        (codes, uniques) = algos.factorize(np.asarray(self), use_na_sentinel=use_na_sentinel)
+        uniques_sp = SparseArray(uniques, dtype=self.dtype)
+        return (codes, uniques_sp)
+
+    def value_counts(self, dropna: bool=True) -> Series:
+        from pandas import Index, Series
+        (keys, counts, _) = algos.value_counts_arraylike(self.sp_values, dropna=dropna)
+        fcounts = self.sp_index.ngaps
+        if fcounts > 0 and (not self._null_fill_value or not dropna):
+            mask = isna(keys) if self._null_fill_value else keys == self.fill_value
+            if mask.any():
+                counts[mask] += fcounts
+            else:
+                keys = np.insert(keys, 0, self.fill_value)
+                counts = np.insert(counts, 0, fcounts)
+        if not isinstance(keys, ABCIndex):
+            index = Index(keys)
+        else:
+            index = keys
+        return Series(counts, index=index, copy=False)
+
+    @overload
+    def __getitem__(self, key: ScalarIndexer) -> Any:
+        ...
+
+    @overload
+    def __getitem__(self, key: SequenceIndexer | tuple[int | ellipsis, ...]) -> Self:
+        ...
+
+    def __getitem__(self, key: PositionalIndexer | tuple[int | ellipsis, ...]) -> Self | Any:
+        if isinstance(key, tuple):
+            key = unpack_tuple_and_ellipses(key)
+            if key is Ellipsis:
+                raise ValueError('Cannot slice with Ellipsis')
+        if is_integer(key):
+            return self._get_val_at(key)
+        elif isinstance(key, tuple):
+            data_slice = self.to_dense()[key]
+        elif isinstance(key, slice):
+            if key.step is None or key.step == 1:
+                start = 0 if key.start is None else key.start
+                if start < 0:
+                    start += len(self)
+                end = len(self) if key.stop is None else key.stop
+                if end < 0:
+                    end += len(self)
+                indices = self.sp_index.indices
+                keep_inds = np.flatnonzero((indices >= start) & (indices < end))
+                sp_vals = self.sp_values[keep_inds]
+                sp_index = indices[keep_inds].copy()
+                if start > 0:
+                    sp_index -= start
+                new_len = len(range(len(self))[key])
+                new_sp_index = make_sparse_index(new_len, sp_index, self.kind)
+                return type(self)._simple_new(sp_vals, new_sp_index, self.dtype)
+            else:
+                indices = np.arange(len(self), dtype=np.int32)[key]
+                return self.take(indices)
+        elif not is_list_like(key):
+            raise IndexError('only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices')
+        else:
+            if isinstance(key, SparseArray):
+                if is_bool_dtype(key):
+                    if isna(key.fill_value):
+                        return self.take(key.sp_index.indices[key.sp_values])
+                    if not key.fill_value:
+                        return self.take(key.sp_index.indices)
+                    n = len(self)
+                    mask = np.full(n, True, dtype=np.bool_)
+                    mask[key.sp_index.indices] = False
+                    return self.take(np.arange(n)[mask])
+                else:
+                    key = np.asarray(key)
+            key = check_array_indexer(self, key)
+            if com.is_bool_indexer(key):
+                key = cast(np.ndarray, key)
+                return self.take(np.arange(len(key), dtype=np.int32)[key])
+            elif hasattr(key, '__len__'):
+                return self.take(key)
+            else:
+                raise ValueError(f"Cannot slice with '{key}'")
+        return type(self)(data_slice, kind=self.kind)
+
+    def _get_val_at(self, loc):
+        loc = validate_insert_loc(loc, len(self))
+        sp_loc = self.sp_index.lookup(loc)
+        if sp_loc == -1:
+            return self.fill_value
+        else:
+            val = self.sp_values[sp_loc]
+            val = maybe_box_datetimelike(val, self.sp_values.dtype)
+            return val
+
+    def take(self, indices, *, allow_fill: bool=False, fill_value=None) -> Self:
+        if is_scalar(indices):
+            raise ValueError(f"'indices' must be an array, not a scalar '{indices}'.")
+        indices = np.asarray(indices, dtype=np.int32)
+        dtype = None
+        if indices.size == 0:
+            result = np.array([], dtype='object')
+            dtype = self.dtype
+        elif allow_fill:
+            result = self._take_with_fill(indices, fill_value=fill_value)
+        else:
+            return self._take_without_fill(indices)
+        return type(self)(result, fill_value=self.fill_value, kind=self.kind, dtype=dtype)
+
+    def _take_with_fill(self, indices, fill_value=None) -> np.ndarray:
+        if fill_value is None:
+            fill_value = self.dtype.na_value
+        if indices.min() < -1:
+            raise ValueError("Invalid value in 'indices'. Must be between -1 and the length of the array.")
+        if indices.max() >= len(self):
+            raise IndexError("out of bounds value in 'indices'.")
+        if len(self) == 0:
+            if (indices == -1).all():
+                dtype = np.result_type(self.sp_values, type(fill_value))
+                taken = np.empty_like(indices, dtype=dtype)
+                taken.fill(fill_value)
+                return taken
+            else:
+                raise IndexError('cannot do a non-empty take from an empty axes.')
+        sp_indexer = self.sp_index.lookup_array(indices)
+        new_fill_indices = indices == -1
+        old_fill_indices = (sp_indexer == -1) & ~new_fill_indices
+        if self.sp_index.npoints == 0 and old_fill_indices.all():
+            taken = np.full(sp_indexer.shape, fill_value=self.fill_value, dtype=self.dtype.subtype)
+        elif self.sp_index.npoints == 0:
+            _dtype = np.result_type(self.dtype.subtype, type(fill_value))
+            taken = np.full(sp_indexer.shape, fill_value=fill_value, dtype=_dtype)
+            taken[old_fill_indices] = self.fill_value
+        else:
+            taken = self.sp_values.take(sp_indexer)
+            m0 = sp_indexer[old_fill_indices] < 0
+            m1 = sp_indexer[new_fill_indices] < 0
+            result_type = taken.dtype
+            if m0.any():
+                result_type = np.result_type(result_type, type(self.fill_value))
+                taken = taken.astype(result_type)
+                taken[old_fill_indices] = self.fill_value
+            if m1.any():
+                result_type = np.result_type(result_type, type(fill_value))
+                taken = taken.astype(result_type)
+                taken[new_fill_indices] = fill_value
+        return taken
+
+    def _take_without_fill(self, indices) -> Self:
+        to_shift = indices < 0
+        n = len(self)
+        if indices.max() >= n or indices.min() < -n:
+            if n == 0:
+                raise IndexError('cannot do a non-empty take from an empty axes.')
+            raise IndexError("out of bounds value in 'indices'.")
+        if to_shift.any():
+            indices = indices.copy()
+            indices[to_shift] += n
+        sp_indexer = self.sp_index.lookup_array(indices)
+        value_mask = sp_indexer != -1
+        new_sp_values = self.sp_values[sp_indexer[value_mask]]
+        value_indices = np.flatnonzero(value_mask).astype(np.int32, copy=False)
+        new_sp_index = make_sparse_index(len(indices), value_indices, kind=self.kind)
+        return type(self)._simple_new(new_sp_values, new_sp_index, dtype=self.dtype)
+
+    def searchsorted(self, v: ArrayLike | object, side: Literal['left', 'right']='left', sorter: NumpySorter | None=None) -> npt.NDArray[np.intp] | np.intp:
+        if get_option('performance_warnings'):
+            msg = 'searchsorted requires high memory usage.'
+            warnings.warn(msg, PerformanceWarning, stacklevel=find_stack_level())
+        v = np.asarray(v)
+        return np.asarray(self, dtype=self.dtype.subtype).searchsorted(v, side, sorter)
+
+    def copy(self) -> Self:
+        values = self.sp_values.copy()
+        return self._simple_new(values, self.sp_index, self.dtype)
+
+    @classmethod
+    def _concat_same_type(cls, to_concat: Sequence[Self]) -> Self:
+        fill_value = to_concat[0].fill_value
+        values = []
+        length = 0
+        if to_concat:
+            sp_kind = to_concat[0].kind
+        else:
+            sp_kind = 'integer'
+        sp_index: SparseIndex
+        if sp_kind == 'integer':
+            indices = []
+            for arr in to_concat:
+                int_idx = arr.sp_index.indices.copy()
+                int_idx += length
+                length += arr.sp_index.length
+                values.append(arr.sp_values)
+                indices.append(int_idx)
+            data = np.concatenate(values)
+            indices_arr = np.concatenate(indices)
+            sp_index = IntIndex(length, indices_arr)
+        else:
+            blengths = []
+            blocs = []
+            for arr in to_concat:
+                block_idx = arr.sp_index.to_block_index()
+                values.append(arr.sp_values)
+                blocs.append(block_idx.blocs.copy() + length)
+                blengths.append(block_idx.blengths)
+                length += arr.sp_index.length
+            data = np.concatenate(values)
+            blocs_arr = np.concatenate(blocs)
+            blengths_arr = np.concatenate(blengths)
+            sp_index = BlockIndex(length, blocs_arr, blengths_arr)
+        return cls(data, sparse_index=sp_index, fill_value=fill_value)
+
+    def astype(self, dtype: AstypeArg | None=None, copy: bool=True):
+        if dtype == self._dtype:
+            if not copy:
+                return self
+            else:
+                return self.copy()
+        future_dtype = pandas_dtype(dtype)
+        if not isinstance(future_dtype, SparseDtype):
+            values = np.asarray(self)
+            values = ensure_wrapped_if_datetimelike(values)
+            return astype_array(values, dtype=future_dtype, copy=False)
+        dtype = self.dtype.update_dtype(dtype)
+        subtype = pandas_dtype(dtype._subtype_with_str)
+        subtype = cast(np.dtype, subtype)
+        values = ensure_wrapped_if_datetimelike(self.sp_values)
+        sp_values = astype_array(values, subtype, copy=copy)
+        sp_values = np.asarray(sp_values)
+        return self._simple_new(sp_values, self.sp_index, dtype)
+
+    def map(self, mapper, na_action: Literal['ignore'] | None=None) -> Self:
+        is_map = isinstance(mapper, (abc.Mapping, ABCSeries))
+        fill_val = self.fill_value
+        if na_action is None or notna(fill_val):
+            fill_val = mapper.get(fill_val, fill_val) if is_map else mapper(fill_val)
+
+        def func(sp_val):
+            new_sp_val = mapper.get(sp_val, None) if is_map else mapper(sp_val)
+            if new_sp_val is fill_val or new_sp_val == fill_val:
+                msg = 'fill value in the sparse values not supported'
+                raise ValueError(msg)
+            return new_sp_val
+        sp_values = [func(x) for x in self.sp_values]
+        return type(self)(sp_values, sparse_index=self.sp_index, fill_value=fill_val)
+
+    def to_dense(self) -> np.ndarray:
+        return np.asarray(self, dtype=self.sp_values.dtype)
+
+    def _where(self, mask, value):
+        naive_implementation = np.where(mask, self, value)
+        dtype = SparseDtype(naive_implementation.dtype, fill_value=self.fill_value)
+        result = type(self)._from_sequence(naive_implementation, dtype=dtype)
+        return result
+
+    def __setstate__(self, state) -> None:
+        if isinstance(state, tuple):
+            (nd_state, (fill_value, sp_index)) = state
+            sparse_values = np.array([])
+            sparse_values.__setstate__(nd_state)
+            self._sparse_values = sparse_values
+            self._sparse_index = sp_index
+            self._dtype = SparseDtype(sparse_values.dtype, fill_value)
+        else:
+            self.__dict__.update(state)
+
+    def nonzero(self) -> tuple[npt.NDArray[np.int32]]:
+        if self.fill_value == 0:
+            return (self.sp_index.indices,)
+        else:
+            return (self.sp_index.indices[self.sp_values != 0],)
+
+    def _reduce(self, name: str, *, skipna: bool=True, keepdims: bool=False, **kwargs):
+        method = getattr(self, name, None)
+        if method is None:
+            raise TypeError(f'cannot perform {name} with type {self.dtype}')
+        if skipna:
+            arr = self
+        else:
+            arr = self.dropna()
+        result = getattr(arr, name)(**kwargs)
+        if keepdims:
+            return type(self)([result], dtype=self.dtype)
+        else:
+            return result
+
+    def all(self, axis=None, *args, **kwargs):
+        nv.validate_all(args, kwargs)
+        values = self.sp_values
+        if len(values) != len(self) and (not np.all(self.fill_value)):
+            return False
+        return values.all()
+
+    def any(self, axis: AxisInt=0, *args, **kwargs) -> bool:
+        nv.validate_any(args, kwargs)
+        values = self.sp_values
+        if len(values) != len(self) and np.any(self.fill_value):
+            return True
+        return values.any().item()
+
+    def sum(self, axis: AxisInt=0, min_count: int=0, skipna: bool=True, *args, **kwargs) -> Scalar:
+        nv.validate_sum(args, kwargs)
+        valid_vals = self._valid_sp_values
+        sp_sum = valid_vals.sum()
+        has_na = self.sp_index.ngaps > 0 and (not self._null_fill_value)
+        if has_na and (not skipna):
+            return na_value_for_dtype(self.dtype.subtype, compat=False)
+        if self._null_fill_value:
+            if check_below_min_count(valid_vals.shape, None, min_count):
+                return na_value_for_dtype(self.dtype.subtype, compat=False)
+            return sp_sum
+        else:
+            nsparse = self.sp_index.ngaps
+            if check_below_min_count(valid_vals.shape, None, min_count - nsparse):
+                return na_value_for_dtype(self.dtype.subtype, compat=False)
+            return sp_sum + self.fill_value * nsparse
+
+    def cumsum(self, axis: AxisInt=0, *args, **kwargs) -> SparseArray:
+        nv.validate_cumsum(args, kwargs)
+        if axis is not None and axis >= self.ndim:
+            raise ValueError(f'axis(={axis}) out of bounds')
+        if not self._null_fill_value:
+            return SparseArray(self.to_dense()).cumsum()
+        return SparseArray(self.sp_values.cumsum(), sparse_index=self.sp_index, fill_value=self.fill_value)
+
+    def mean(self, axis: Axis=0, *args, **kwargs):
+        nv.validate_mean(args, kwargs)
+        valid_vals = self._valid_sp_values
+        sp_sum = valid_vals.sum()
+        ct = len(valid_vals)
+        if self._null_fill_value:
+            return sp_sum / ct
+        else:
+            nsparse = self.sp_index.ngaps
+            return (sp_sum + self.fill_value * nsparse) / (ct + nsparse)
+
+    def max(self, *, axis: AxisInt | None=None, skipna: bool=True):
+        nv.validate_minmax_axis(axis, self.ndim)
+        return self._min_max('max', skipna=skipna)
+
+    def min(self, *, axis: AxisInt | None=None, skipna: bool=True):
+        nv.validate_minmax_axis(axis, self.ndim)
+        return self._min_max('min', skipna=skipna)
+
+    def _min_max(self, kind: Literal['min', 'max'], skipna: bool) -> Scalar:
+        valid_vals = self._valid_sp_values
+        has_nonnull_fill_vals = not self._null_fill_value and self.sp_index.ngaps > 0
+        if len(valid_vals) > 0:
+            sp_min_max = getattr(valid_vals, kind)()
+            if has_nonnull_fill_vals:
+                func = max if kind == 'max' else min
+                return func(sp_min_max, self.fill_value)
+            elif skipna:
+                return sp_min_max
+            elif self.sp_index.ngaps == 0:
+                return sp_min_max
+            else:
+                return na_value_for_dtype(self.dtype.subtype, compat=False)
+        elif has_nonnull_fill_vals:
+            return self.fill_value
+        else:
+            return na_value_for_dtype(self.dtype.subtype, compat=False)
+
+    def _argmin_argmax(self, kind: Literal['argmin', 'argmax']) -> int:
+        values = self._sparse_values
+        index = self._sparse_index.indices
+        mask = np.asarray(isna(values))
+        func = np.argmax if kind == 'argmax' else np.argmin
+        idx = np.arange(values.shape[0])
+        non_nans = values[~mask]
+        non_nan_idx = idx[~mask]
+        _candidate = non_nan_idx[func(non_nans)]
+        candidate = index[_candidate]
+        if isna(self.fill_value):
+            return candidate
+        if kind == 'argmin' and self[candidate] < self.fill_value:
+            return candidate
+        if kind == 'argmax' and self[candidate] > self.fill_value:
+            return candidate
+        _loc = self._first_fill_value_loc()
+        if _loc == -1:
+            return candidate
+        else:
+            return _loc
+
+    def argmax(self, skipna: bool=True) -> int:
+        validate_bool_kwarg(skipna, 'skipna')
+        if not skipna and self._hasna:
+            raise ValueError('Encountered an NA value with skipna=False')
+        return self._argmin_argmax('argmax')
+
+    def argmin(self, skipna: bool=True) -> int:
+        validate_bool_kwarg(skipna, 'skipna')
+        if not skipna and self._hasna:
+            raise ValueError('Encountered an NA value with skipna=False')
+        return self._argmin_argmax('argmin')
+    _HANDLED_TYPES = (np.ndarray, numbers.Number)
+
+    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
+        out = kwargs.get('out', ())
+        for x in inputs + out:
+            if not isinstance(x, self._HANDLED_TYPES + (SparseArray,)):
+                return NotImplemented
+        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(self, ufunc, method, *inputs, **kwargs)
+        if result is not NotImplemented:
+            return result
+        if 'out' in kwargs:
+            res = arraylike.dispatch_ufunc_with_out(self, ufunc, method, *inputs, **kwargs)
+            return res
+        if method == 'reduce':
+            result = arraylike.dispatch_reduction_ufunc(self, ufunc, method, *inputs, **kwargs)
+            if result is not NotImplemented:
+                return result
+        if len(inputs) == 1:
+            sp_values = getattr(ufunc, method)(self.sp_values, **kwargs)
+            fill_value = getattr(ufunc, method)(self.fill_value, **kwargs)
+            if ufunc.nout > 1:
+                arrays = tuple((self._simple_new(sp_value, self.sp_index, SparseDtype(sp_value.dtype, fv)) for (sp_value, fv) in zip(sp_values, fill_value)))
+                return arrays
+            elif method == 'reduce':
+                return sp_values
+            return self._simple_new(sp_values, self.sp_index, SparseDtype(sp_values.dtype, fill_value))
+        new_inputs = tuple((np.asarray(x) for x in inputs))
+        result = getattr(ufunc, method)(*new_inputs, **kwargs)
+        if out:
+            if len(out) == 1:
+                out = out[0]
+            return out
+        if ufunc.nout > 1:
+            return tuple((type(self)(x) for x in result))
+        elif method == 'at':
+            return None
+        else:
+            return type(self)(result)
+
+    def _arith_method(self, other, op):
+        op_name = op.__name__
+        if isinstance(other, SparseArray):
+            return _sparse_array_op(self, other, op, op_name)
+        elif is_scalar(other):
+            with np.errstate(all='ignore'):
+                fill = op(_get_fill(self), np.asarray(other))
+                result = op(self.sp_values, other)
+            if op_name == 'divmod':
+                (left, right) = result
+                (lfill, rfill) = fill
+                return (_wrap_result(op_name, left, self.sp_index, lfill), _wrap_result(op_name, right, self.sp_index, rfill))
+            return _wrap_result(op_name, result, self.sp_index, fill)
+        else:
+            other = np.asarray(other)
+            with np.errstate(all='ignore'):
+                if len(self) != len(other):
+                    raise AssertionError(f'length mismatch: {len(self)} vs. {len(other)}')
+                if not isinstance(other, SparseArray):
+                    dtype = getattr(other, 'dtype', None)
+                    other = SparseArray(other, fill_value=self.fill_value, dtype=dtype)
+                return _sparse_array_op(self, other, op, op_name)
+
+    def _cmp_method(self, other, op) -> SparseArray:
+        if not is_scalar(other) and (not isinstance(other, type(self))):
+            other = np.asarray(other)
+        if isinstance(other, np.ndarray):
+            other = SparseArray(other, fill_value=self.fill_value)
+        if isinstance(other, SparseArray):
+            if len(self) != len(other):
+                raise ValueError(f'operands have mismatched length {len(self)} and {len(other)}')
+            op_name = op.__name__.strip('_')
+            return _sparse_array_op(self, other, op, op_name)
+        else:
+            fill_value = op(self.fill_value, other)
+            result = np.full(len(self), fill_value, dtype=np.bool_)
+            result[self.sp_index.indices] = op(self.sp_values, other)
+            return type(self)(result, fill_value=fill_value, dtype=np.bool_)
+    _logical_method = _cmp_method
+
+    def _unary_method(self, op) -> SparseArray:
+        fill_value = op(np.array(self.fill_value)).item()
+        dtype = SparseDtype(self.dtype.subtype, fill_value)
+        if isna(self.fill_value) or fill_value == self.fill_value:
+            values = op(self.sp_values)
+            return type(self)._simple_new(values, self.sp_index, self.dtype)
+        return type(self)(op(self.to_dense()), dtype=dtype)
+
+    def __pos__(self) -> SparseArray:
+        return self._unary_method(operator.pos)
+
+    def __neg__(self) -> SparseArray:
+        return self._unary_method(operator.neg)
+
+    def __invert__(self) -> SparseArray:
+        return self._unary_method(operator.invert)
+
+    def __abs__(self) -> SparseArray:
+        return self._unary_method(operator.abs)
+
+    def __repr__(self) -> str:
+        pp_str = printing.pprint_thing(self)
+        pp_fill = printing.pprint_thing(self.fill_value)
+        pp_index = printing.pprint_thing(self.sp_index)
+        return f'{pp_str}\nFill: {pp_fill}\n{pp_index}'
+
+    def _formatter(self, boxed: bool=False) -> None:
+        return None
+
+def _make_sparse(arr: np.ndarray, kind: SparseIndexKind='block', fill_value=None, dtype: np.dtype | None=None):
+    assert isinstance(arr, np.ndarray)
+    if arr.ndim > 1:
+        raise TypeError('expected dimension <= 1 data')
+    if fill_value is None:
+        fill_value = na_value_for_dtype(arr.dtype)
+    if isna(fill_value):
+        mask = notna(arr)
+    else:
+        if is_string_dtype(arr.dtype):
+            arr = arr.astype(object)
+        if is_object_dtype(arr.dtype):
+            mask = splib.make_mask_object_ndarray(arr, fill_value)
+        else:
+            mask = arr != fill_value
+    length = len(arr)
+    if length != len(mask):
+        indices = mask.sp_index.indices
+    else:
+        indices = mask.nonzero()[0].astype(np.int32)
+    index = make_sparse_index(length, indices, kind)
+    sparsified_values = arr[mask]
+    if dtype is not None:
+        sparsified_values = ensure_wrapped_if_datetimelike(sparsified_values)
+        sparsified_values = astype_array(sparsified_values, dtype=dtype)
+        sparsified_values = np.asarray(sparsified_values)
+    return (sparsified_values, index, fill_value)
+
+@overload
+def make_sparse_index(length: int, indices, kind: Literal['block']) -> BlockIndex:
+    ...
+
+@overload
+def make_sparse_index(length: int, indices, kind: Literal['integer']) -> IntIndex:
+    ...
+
+def make_sparse_index(length: int, indices, kind: SparseIndexKind) -> SparseIndex:
+    index: SparseIndex
+    if kind == 'block':
+        (locs, lens) = splib.get_blocks(indices)
+        index = BlockIndex(length, locs, lens)
+    elif kind == 'integer':
+        index = IntIndex(length, indices)
+    else:
+        raise ValueError('must be block or integer type')
+    return index
+
+# File: pandas-main/pandas/core/arrays/sparse/scipy_sparse.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from pandas._libs import lib
+from pandas.core.dtypes.missing import notna
+from pandas.core.algorithms import factorize
+from pandas.core.indexes.api import MultiIndex
+from pandas.core.series import Series
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    import numpy as np
+    import scipy.sparse
+    from pandas._typing import IndexLabel, npt
+
+def _check_is_partition(parts: Iterable, whole: Iterable) -> None:
+    whole = set(whole)
+    parts = [set(x) for x in parts]
+    if set.intersection(*parts) != set():
+        raise ValueError('Is not a partition because intersection is not null.')
+    if set.union(*parts) != whole:
+        raise ValueError('Is not a partition because union is not the whole.')
+
+def _levels_to_axis(ss, levels: tuple[int] | list[int], valid_ilocs: npt.NDArray[np.intp], sort_labels: bool=False) -> tuple[npt.NDArray[np.intp], list[IndexLabel]]:
+    if sort_labels and len(levels) == 1:
+        ax_coords = ss.index.codes[levels[0]][valid_ilocs]
+        ax_labels = ss.index.levels[levels[0]]
+    else:
+        levels_values = lib.fast_zip([ss.index.get_level_values(lvl).to_numpy() for lvl in levels])
+        (codes, ax_labels) = factorize(levels_values, sort=sort_labels)
+        ax_coords = codes[valid_ilocs]
+    ax_labels = ax_labels.tolist()
+    return (ax_coords, ax_labels)
+
+def _to_ijv(ss, row_levels: tuple[int] | list[int]=(0,), column_levels: tuple[int] | list[int]=(1,), sort_labels: bool=False) -> tuple[np.ndarray, npt.NDArray[np.intp], npt.NDArray[np.intp], list[IndexLabel], list[IndexLabel]]:
+    _check_is_partition([row_levels, column_levels], range(ss.index.nlevels))
+    sp_vals = ss.array.sp_values
+    na_mask = notna(sp_vals)
+    values = sp_vals[na_mask]
+    valid_ilocs = ss.array.sp_index.indices[na_mask]
+    (i_coords, i_labels) = _levels_to_axis(ss, row_levels, valid_ilocs, sort_labels=sort_labels)
+    (j_coords, j_labels) = _levels_to_axis(ss, column_levels, valid_ilocs, sort_labels=sort_labels)
+    return (values, i_coords, j_coords, i_labels, j_labels)
+
+def sparse_series_to_coo(ss: Series, row_levels: Iterable[int]=(0,), column_levels: Iterable[int]=(1,), sort_labels: bool=False) -> tuple[scipy.sparse.coo_matrix, list[IndexLabel], list[IndexLabel]]:
+    import scipy.sparse
+    if ss.index.nlevels < 2:
+        raise ValueError('to_coo requires MultiIndex with nlevels >= 2.')
+    if not ss.index.is_unique:
+        raise ValueError('Duplicate index entries are not allowed in to_coo transformation.')
+    row_levels = [ss.index._get_level_number(x) for x in row_levels]
+    column_levels = [ss.index._get_level_number(x) for x in column_levels]
+    (v, i, j, rows, columns) = _to_ijv(ss, row_levels=row_levels, column_levels=column_levels, sort_labels=sort_labels)
+    sparse_matrix = scipy.sparse.coo_matrix((v, (i, j)), shape=(len(rows), len(columns)))
+    return (sparse_matrix, rows, columns)
+
+def coo_to_sparse_series(A: scipy.sparse.coo_matrix, dense_index: bool=False) -> Series:
+    from pandas import SparseDtype
+    try:
+        ser = Series(A.data, MultiIndex.from_arrays((A.row, A.col)), copy=False)
+    except AttributeError as err:
+        raise TypeError(f'Expected coo_matrix. Got {type(A).__name__} instead.') from err
+    ser = ser.sort_index()
+    ser = ser.astype(SparseDtype(ser.dtype))
+    if dense_index:
+        ind = MultiIndex.from_product([A.row, A.col])
+        ser = ser.reindex(ind)
+    return ser
+
+# File: pandas-main/pandas/core/arrays/string_.py
+from __future__ import annotations
+import operator
+from typing import TYPE_CHECKING, Any, Literal, cast
+import numpy as np
+from pandas._config import get_option, using_string_dtype
+from pandas._libs import lib, missing as libmissing
+from pandas._libs.arrays import NDArrayBacked
+from pandas._libs.lib import ensure_string_array
+from pandas.compat import HAS_PYARROW, pa_version_under10p1
+from pandas.compat.numpy import function as nv
+from pandas.util._decorators import doc
+from pandas.core.dtypes.base import ExtensionDtype, StorageExtensionDtype, register_extension_dtype
+from pandas.core.dtypes.common import is_array_like, is_bool_dtype, is_integer_dtype, is_object_dtype, is_string_dtype, pandas_dtype
+from pandas.core import nanops, ops
+from pandas.core.algorithms import isin
+from pandas.core.array_algos import masked_reductions
+from pandas.core.arrays.base import ExtensionArray
+from pandas.core.arrays.floating import FloatingArray, FloatingDtype
+from pandas.core.arrays.integer import IntegerArray, IntegerDtype
+from pandas.core.arrays.numpy_ import NumpyExtensionArray
+from pandas.core.construction import extract_array
+from pandas.core.indexers import check_array_indexer
+from pandas.core.missing import isna
+if TYPE_CHECKING:
+    import pyarrow
+    from pandas._typing import ArrayLike, AxisInt, Dtype, DtypeObj, NumpySorter, NumpyValueArrayLike, Scalar, Self, npt, type_t
+    from pandas import Series
+
+@register_extension_dtype
+class StringDtype(StorageExtensionDtype):
+
+    @property
+    def name(self) -> str:
+        if self._na_value is libmissing.NA:
+            return 'string'
+        else:
+            return 'str'
+
+    @property
+    def na_value(self) -> libmissing.NAType | float:
+        return self._na_value
+    _metadata = ('storage', '_na_value')
+
+    def __init__(self, storage: str | None=None, na_value: libmissing.NAType | float=libmissing.NA) -> None:
+        if storage is None:
+            if na_value is not libmissing.NA:
+                storage = get_option('mode.string_storage')
+                if storage == 'auto':
+                    if HAS_PYARROW:
+                        storage = 'pyarrow'
+                    else:
+                        storage = 'python'
+            else:
+                storage = get_option('mode.string_storage')
+                if storage == 'auto':
+                    storage = 'python'
+        if storage == 'pyarrow_numpy':
+            storage = 'pyarrow'
+            na_value = np.nan
+        if storage not in {'python', 'pyarrow'}:
+            raise ValueError(f"Storage must be 'python' or 'pyarrow'. Got {storage} instead.")
+        if storage == 'pyarrow' and pa_version_under10p1:
+            raise ImportError('pyarrow>=10.0.1 is required for PyArrow backed StringArray.')
+        if isinstance(na_value, float) and np.isnan(na_value):
+            na_value = np.nan
+        elif na_value is not libmissing.NA:
+            raise ValueError(f"'na_value' must be np.nan or pd.NA, got {na_value}")
+        self.storage = cast(str, storage)
+        self._na_value = na_value
+
+    def __repr__(self) -> str:
+        if self._na_value is libmissing.NA:
+            return f'{self.name}[{self.storage}]'
+        else:
+            return self.name
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, str):
+            if other == 'string' or other == self.name:
+                return True
+            try:
+                other = self.construct_from_string(other)
+            except (TypeError, ImportError):
+                return False
+        if isinstance(other, type(self)):
+            return self.storage == other.storage and self.na_value is other.na_value
+        return False
+
+    def __hash__(self) -> int:
+        return super().__hash__()
+
+    def __reduce__(self):
+        return (StringDtype, (self.storage, self.na_value))
+
+    @property
+    def type(self) -> type[str]:
+        return str
+
+    @classmethod
+    def construct_from_string(cls, string) -> Self:
+        if not isinstance(string, str):
+            raise TypeError(f"'construct_from_string' expects a string, got {type(string)}")
+        if string == 'string':
+            return cls()
+        elif string == 'str' and using_string_dtype():
+            return cls(na_value=np.nan)
+        elif string == 'string[python]':
+            return cls(storage='python')
+        elif string == 'string[pyarrow]':
+            return cls(storage='pyarrow')
+        elif string == 'string[pyarrow_numpy]':
+            return cls(storage='pyarrow_numpy')
+        else:
+            raise TypeError(f"Cannot construct a '{cls.__name__}' from '{string}'")
+
+    def construct_array_type(self) -> type_t[BaseStringArray]:
+        from pandas.core.arrays.string_arrow import ArrowStringArray, ArrowStringArrayNumpySemantics
+        if self.storage == 'python' and self._na_value is libmissing.NA:
+            return StringArray
+        elif self.storage == 'pyarrow' and self._na_value is libmissing.NA:
+            return ArrowStringArray
+        elif self.storage == 'python':
+            return StringArrayNumpySemantics
+        else:
+            return ArrowStringArrayNumpySemantics
+
+    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
+        storages = set()
+        na_values = set()
+        for dtype in dtypes:
+            if isinstance(dtype, StringDtype):
+                storages.add(dtype.storage)
+                na_values.add(dtype.na_value)
+            elif isinstance(dtype, np.dtype) and dtype.kind in ('U', 'T'):
+                continue
+            else:
+                return None
+        if len(storages) == 2:
+            storage = 'pyarrow'
+        else:
+            storage = next(iter(storages))
+        na_value: libmissing.NAType | float
+        if len(na_values) == 2:
+            na_value = libmissing.NA
+        else:
+            na_value = next(iter(na_values))
+        return StringDtype(storage=storage, na_value=na_value)
+
+    def __from_arrow__(self, array: pyarrow.Array | pyarrow.ChunkedArray) -> BaseStringArray:
+        if self.storage == 'pyarrow':
+            if self._na_value is libmissing.NA:
+                from pandas.core.arrays.string_arrow import ArrowStringArray
+                return ArrowStringArray(array)
+            else:
+                from pandas.core.arrays.string_arrow import ArrowStringArrayNumpySemantics
+                return ArrowStringArrayNumpySemantics(array)
+        else:
+            import pyarrow
+            if isinstance(array, pyarrow.Array):
+                chunks = [array]
+            else:
+                chunks = array.chunks
+            results = []
+            for arr in chunks:
+                arr = arr.to_numpy(zero_copy_only=False)
+                arr = ensure_string_array(arr, na_value=self.na_value)
+                results.append(arr)
+        if len(chunks) == 0:
+            arr = np.array([], dtype=object)
+        else:
+            arr = np.concatenate(results)
+        new_string_array = StringArray.__new__(StringArray)
+        NDArrayBacked.__init__(new_string_array, arr, self)
+        return new_string_array
+
+class BaseStringArray(ExtensionArray):
+    dtype: StringDtype
+
+    @doc(ExtensionArray.tolist)
+    def tolist(self) -> list:
+        if self.ndim > 1:
+            return [x.tolist() for x in self]
+        return list(self.to_numpy())
+
+    @classmethod
+    def _from_scalars(cls, scalars, dtype: DtypeObj) -> Self:
+        if lib.infer_dtype(scalars, skipna=True) not in ['string', 'empty']:
+            raise ValueError
+        return cls._from_sequence(scalars, dtype=dtype)
+
+    def _str_map(self, f, na_value=None, dtype: Dtype | None=None, convert: bool=True):
+        if self.dtype.na_value is np.nan:
+            return self._str_map_nan_semantics(f, na_value=na_value, dtype=dtype)
+        from pandas.arrays import BooleanArray
+        if dtype is None:
+            dtype = self.dtype
+        if na_value is None:
+            na_value = self.dtype.na_value
+        mask = isna(self)
+        arr = np.asarray(self)
+        if is_integer_dtype(dtype) or is_bool_dtype(dtype):
+            constructor: type[IntegerArray | BooleanArray]
+            if is_integer_dtype(dtype):
+                constructor = IntegerArray
+            else:
+                constructor = BooleanArray
+            na_value_is_na = isna(na_value)
+            if na_value_is_na:
+                na_value = 1
+            elif dtype == np.dtype('bool'):
+                na_value = bool(na_value)
+            result = lib.map_infer_mask(arr, f, mask.view('uint8'), convert=False, na_value=na_value, dtype=np.dtype(cast(type, dtype)))
+            if not na_value_is_na:
+                mask[:] = False
+            return constructor(result, mask)
+        else:
+            return self._str_map_str_or_object(dtype, na_value, arr, f, mask)
+
+    def _str_map_str_or_object(self, dtype, na_value, arr: np.ndarray, f, mask: npt.NDArray[np.bool_]):
+        if is_string_dtype(dtype) and (not is_object_dtype(dtype)):
+            result = lib.map_infer_mask(arr, f, mask.view('uint8'), convert=False, na_value=na_value)
+            if self.dtype.storage == 'pyarrow':
+                import pyarrow as pa
+                result = pa.array(result, mask=mask, type=pa.large_string(), from_pandas=True)
+            return type(self)(result)
+        else:
+            return lib.map_infer_mask(arr, f, mask.view('uint8'))
+
+    def _str_map_nan_semantics(self, f, na_value=None, dtype: Dtype | None=None):
+        if dtype is None:
+            dtype = self.dtype
+        if na_value is None:
+            na_value = self.dtype.na_value
+        mask = isna(self)
+        arr = np.asarray(self)
+        if is_integer_dtype(dtype) or is_bool_dtype(dtype):
+            na_value_is_na = isna(na_value)
+            if na_value_is_na:
+                if is_integer_dtype(dtype):
+                    na_value = 0
+                else:
+                    na_value = True
+            result = lib.map_infer_mask(arr, f, mask.view('uint8'), convert=False, na_value=na_value, dtype=np.dtype(cast(type, dtype)))
+            if na_value_is_na and mask.any():
+                if is_integer_dtype(dtype):
+                    result = result.astype('float64')
+                else:
+                    result = result.astype('object')
+                result[mask] = np.nan
+            return result
+        else:
+            return self._str_map_str_or_object(dtype, na_value, arr, f, mask)
+
+class StringArray(BaseStringArray, NumpyExtensionArray):
+    _typ = 'extension'
+    _storage = 'python'
+    _na_value: libmissing.NAType | float = libmissing.NA
+
+    def __init__(self, values, copy: bool=False) -> None:
+        values = extract_array(values)
+        super().__init__(values, copy=copy)
+        if not isinstance(values, type(self)):
+            self._validate()
+        NDArrayBacked.__init__(self, self._ndarray, StringDtype(storage=self._storage, na_value=self._na_value))
+
+    def _validate(self) -> None:
+        if len(self._ndarray) and (not lib.is_string_array(self._ndarray, skipna=True)):
+            raise ValueError('StringArray requires a sequence of strings or pandas.NA')
+        if self._ndarray.dtype != 'object':
+            raise ValueError(f"StringArray requires a sequence of strings or pandas.NA. Got '{self._ndarray.dtype}' dtype instead.")
+        if self._ndarray.ndim > 2:
+            lib.convert_nans_to_NA(self._ndarray.ravel('K'))
+        else:
+            lib.convert_nans_to_NA(self._ndarray)
+
+    def _validate_scalar(self, value):
+        if isna(value):
+            return self.dtype.na_value
+        elif not isinstance(value, str):
+            raise TypeError(f"Cannot set non-string value '{value}' into a string array.")
+        return value
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype: Dtype | None=None, copy: bool=False) -> Self:
+        if dtype and (not (isinstance(dtype, str) and dtype == 'string')):
+            dtype = pandas_dtype(dtype)
+            assert isinstance(dtype, StringDtype) and dtype.storage == 'python'
+        elif using_string_dtype():
+            dtype = StringDtype(storage='python', na_value=np.nan)
+        else:
+            dtype = StringDtype(storage='python')
+        from pandas.core.arrays.masked import BaseMaskedArray
+        na_value = dtype.na_value
+        if isinstance(scalars, BaseMaskedArray):
+            na_values = scalars._mask
+            result = scalars._data
+            result = lib.ensure_string_array(result, copy=copy, convert_na_value=False)
+            result[na_values] = na_value
+        else:
+            if lib.is_pyarrow_array(scalars):
+                scalars = np.array(scalars)
+            result = lib.ensure_string_array(scalars, na_value=na_value, copy=copy)
+        new_string_array = cls.__new__(cls)
+        NDArrayBacked.__init__(new_string_array, result, dtype)
+        return new_string_array
+
+    @classmethod
+    def _from_sequence_of_strings(cls, strings, *, dtype: ExtensionDtype, copy: bool=False) -> Self:
+        return cls._from_sequence(strings, dtype=dtype, copy=copy)
+
+    @classmethod
+    def _empty(cls, shape, dtype) -> StringArray:
+        values = np.empty(shape, dtype=object)
+        values[:] = libmissing.NA
+        return cls(values).astype(dtype, copy=False)
+
+    def __arrow_array__(self, type=None):
+        import pyarrow as pa
+        if type is None:
+            type = pa.string()
+        values = self._ndarray.copy()
+        values[self.isna()] = None
+        return pa.array(values, type=type, from_pandas=True)
+
+    def _values_for_factorize(self) -> tuple[np.ndarray, libmissing.NAType | float]:
+        arr = self._ndarray
+        return (arr, self.dtype.na_value)
+
+    def __setitem__(self, key, value) -> None:
+        value = extract_array(value, extract_numpy=True)
+        if isinstance(value, type(self)):
+            value = value._ndarray
+        key = check_array_indexer(self, key)
+        scalar_key = lib.is_scalar(key)
+        scalar_value = lib.is_scalar(value)
+        if scalar_key and (not scalar_value):
+            raise ValueError('setting an array element with a sequence.')
+        if scalar_value:
+            if isna(value):
+                value = self.dtype.na_value
+            elif not isinstance(value, str):
+                raise TypeError(f"Cannot set non-string value '{value}' into a StringArray.")
+        else:
+            if not is_array_like(value):
+                value = np.asarray(value, dtype=object)
+            else:
+                value = np.asarray(value)
+            if len(value) and (not lib.is_string_array(value, skipna=True)):
+                raise TypeError('Must provide strings.')
+            mask = isna(value)
+            if mask.any():
+                value = value.copy()
+                value[isna(value)] = self.dtype.na_value
+        super().__setitem__(key, value)
+
+    def _putmask(self, mask: npt.NDArray[np.bool_], value) -> None:
+        ExtensionArray._putmask(self, mask, value)
+
+    def isin(self, values: ArrayLike) -> npt.NDArray[np.bool_]:
+        if isinstance(values, BaseStringArray) or (isinstance(values, ExtensionArray) and is_string_dtype(values.dtype)):
+            values = values.astype(self.dtype, copy=False)
+        else:
+            if not lib.is_string_array(np.asarray(values), skipna=True):
+                values = np.array([val for val in values if isinstance(val, str) or isna(val)], dtype=object)
+                if not len(values):
+                    return np.zeros(self.shape, dtype=bool)
+            values = self._from_sequence(values, dtype=self.dtype)
+        return isin(np.asarray(self), np.asarray(values))
+
+    def astype(self, dtype, copy: bool=True):
+        dtype = pandas_dtype(dtype)
+        if dtype == self.dtype:
+            if copy:
+                return self.copy()
+            return self
+        elif isinstance(dtype, IntegerDtype):
+            arr = self._ndarray.copy()
+            mask = self.isna()
+            arr[mask] = 0
+            values = arr.astype(dtype.numpy_dtype)
+            return IntegerArray(values, mask, copy=False)
+        elif isinstance(dtype, FloatingDtype):
+            arr_ea = self.copy()
+            mask = self.isna()
+            arr_ea[mask] = '0'
+            values = arr_ea.astype(dtype.numpy_dtype)
+            return FloatingArray(values, mask, copy=False)
+        elif isinstance(dtype, ExtensionDtype):
+            return ExtensionArray.astype(self, dtype, copy)
+        elif np.issubdtype(dtype, np.floating):
+            arr = self._ndarray.copy()
+            mask = self.isna()
+            arr[mask] = 0
+            values = arr.astype(dtype)
+            values[mask] = np.nan
+            return values
+        return super().astype(dtype, copy)
+
+    def _reduce(self, name: str, *, skipna: bool=True, keepdims: bool=False, axis: AxisInt | None=0, **kwargs):
+        if self.dtype.na_value is np.nan and name in ['any', 'all']:
+            if name == 'any':
+                return nanops.nanany(self._ndarray, skipna=skipna)
+            else:
+                return nanops.nanall(self._ndarray, skipna=skipna)
+        if name in ['min', 'max']:
+            result = getattr(self, name)(skipna=skipna, axis=axis)
+            if keepdims:
+                return self._from_sequence([result], dtype=self.dtype)
+            return result
+        raise TypeError(f"Cannot perform reduction '{name}' with string dtype")
+
+    def _wrap_reduction_result(self, axis: AxisInt | None, result) -> Any:
+        if self.dtype.na_value is np.nan and result is libmissing.NA:
+            return np.nan
+        return super()._wrap_reduction_result(axis, result)
+
+    def min(self, axis=None, skipna: bool=True, **kwargs) -> Scalar:
+        nv.validate_min((), kwargs)
+        result = masked_reductions.min(values=self.to_numpy(), mask=self.isna(), skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def max(self, axis=None, skipna: bool=True, **kwargs) -> Scalar:
+        nv.validate_max((), kwargs)
+        result = masked_reductions.max(values=self.to_numpy(), mask=self.isna(), skipna=skipna)
+        return self._wrap_reduction_result(axis, result)
+
+    def value_counts(self, dropna: bool=True) -> Series:
+        from pandas.core.algorithms import value_counts_internal as value_counts
+        result = value_counts(self._ndarray, sort=False, dropna=dropna)
+        result.index = result.index.astype(self.dtype)
+        if self.dtype.na_value is libmissing.NA:
+            result = result.astype('Int64')
+        return result
+
+    def memory_usage(self, deep: bool=False) -> int:
+        result = self._ndarray.nbytes
+        if deep:
+            return result + lib.memory_usage_of_objects(self._ndarray)
+        return result
+
+    @doc(ExtensionArray.searchsorted)
+    def searchsorted(self, value: NumpyValueArrayLike | ExtensionArray, side: Literal['left', 'right']='left', sorter: NumpySorter | None=None) -> npt.NDArray[np.intp] | np.intp:
+        if self._hasna:
+            raise ValueError('searchsorted requires array to be sorted, which is impossible with NAs present.')
+        return super().searchsorted(value=value, side=side, sorter=sorter)
+
+    def _cmp_method(self, other, op):
+        from pandas.arrays import BooleanArray
+        if isinstance(other, StringArray):
+            other = other._ndarray
+        mask = isna(self) | isna(other)
+        valid = ~mask
+        if not lib.is_scalar(other):
+            if len(other) != len(self):
+                raise ValueError(f'Lengths of operands do not match: {len(self)} != {len(other)}')
+            if not is_array_like(other):
+                other = np.asarray(other)
+            other = other[valid]
+            other = np.asarray(other)
+        if op.__name__ in ops.ARITHMETIC_BINOPS:
+            result = np.empty_like(self._ndarray, dtype='object')
+            result[mask] = self.dtype.na_value
+            result[valid] = op(self._ndarray[valid], other)
+            return self._from_backing_data(result)
+        else:
+            result = np.zeros(len(self._ndarray), dtype='bool')
+            result[valid] = op(self._ndarray[valid], other)
+            res_arr = BooleanArray(result, mask)
+            if self.dtype.na_value is np.nan:
+                if op == operator.ne:
+                    return res_arr.to_numpy(np.bool_, na_value=True)
+                else:
+                    return res_arr.to_numpy(np.bool_, na_value=False)
+            return res_arr
+    _arith_method = _cmp_method
+
+class StringArrayNumpySemantics(StringArray):
+    _storage = 'python'
+    _na_value = np.nan
+
+    def _validate(self) -> None:
+        if len(self._ndarray) and (not lib.is_string_array(self._ndarray, skipna=True)):
+            raise ValueError('StringArrayNumpySemantics requires a sequence of strings or NaN')
+        if self._ndarray.dtype != 'object':
+            raise ValueError(f"StringArrayNumpySemantics requires a sequence of strings or NaN. Got '{self._ndarray.dtype}' dtype instead.")
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype: Dtype | None=None, copy: bool=False) -> Self:
+        if dtype is None:
+            dtype = StringDtype(storage='python', na_value=np.nan)
+        return super()._from_sequence(scalars, dtype=dtype, copy=copy)
+
+# File: pandas-main/pandas/core/arrays/string_arrow.py
+from __future__ import annotations
+import operator
+import re
+from typing import TYPE_CHECKING, Union
+import warnings
+import numpy as np
+from pandas._libs import lib, missing as libmissing
+from pandas.compat import pa_version_under10p1, pa_version_under13p0
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import is_scalar, pandas_dtype
+from pandas.core.dtypes.missing import isna
+from pandas.core.arrays._arrow_string_mixins import ArrowStringArrayMixin
+from pandas.core.arrays.arrow import ArrowExtensionArray
+from pandas.core.arrays.boolean import BooleanDtype
+from pandas.core.arrays.floating import Float64Dtype
+from pandas.core.arrays.integer import Int64Dtype
+from pandas.core.arrays.numeric import NumericDtype
+from pandas.core.arrays.string_ import BaseStringArray, StringDtype
+from pandas.core.strings.object_array import ObjectStringArrayMixin
+if not pa_version_under10p1:
+    import pyarrow as pa
+    import pyarrow.compute as pc
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+    from pandas._typing import ArrayLike, Dtype, NpDtype, Self, npt
+    from pandas.core.dtypes.dtypes import ExtensionDtype
+    from pandas import Series
+ArrowStringScalarOrNAT = Union[str, libmissing.NAType]
+
+def _chk_pyarrow_available() -> None:
+    if pa_version_under10p1:
+        msg = 'pyarrow>=10.0.1 is required for PyArrow backed ArrowExtensionArray.'
+        raise ImportError(msg)
+
+class ArrowStringArray(ObjectStringArrayMixin, ArrowExtensionArray, BaseStringArray):
+    _dtype: StringDtype
+    _storage = 'pyarrow'
+    _na_value: libmissing.NAType | float = libmissing.NA
+
+    def __init__(self, values) -> None:
+        _chk_pyarrow_available()
+        if isinstance(values, (pa.Array, pa.ChunkedArray)) and (pa.types.is_string(values.type) or (pa.types.is_dictionary(values.type) and (pa.types.is_string(values.type.value_type) or pa.types.is_large_string(values.type.value_type)))):
+            values = pc.cast(values, pa.large_string())
+        super().__init__(values)
+        self._dtype = StringDtype(storage=self._storage, na_value=self._na_value)
+        if not pa.types.is_large_string(self._pa_array.type):
+            raise ValueError('ArrowStringArray requires a PyArrow (chunked) array of large_string type')
+
+    @classmethod
+    def _box_pa_scalar(cls, value, pa_type: pa.DataType | None=None) -> pa.Scalar:
+        pa_scalar = super()._box_pa_scalar(value, pa_type)
+        if pa.types.is_string(pa_scalar.type) and pa_type is None:
+            pa_scalar = pc.cast(pa_scalar, pa.large_string())
+        return pa_scalar
+
+    @classmethod
+    def _box_pa_array(cls, value, pa_type: pa.DataType | None=None, copy: bool=False) -> pa.Array | pa.ChunkedArray:
+        pa_array = super()._box_pa_array(value, pa_type)
+        if pa.types.is_string(pa_array.type) and pa_type is None:
+            pa_array = pc.cast(pa_array, pa.large_string())
+        return pa_array
+
+    def __len__(self) -> int:
+        return len(self._pa_array)
+
+    @classmethod
+    def _from_sequence(cls, scalars, *, dtype: Dtype | None=None, copy: bool=False) -> Self:
+        from pandas.core.arrays.masked import BaseMaskedArray
+        _chk_pyarrow_available()
+        if dtype and (not (isinstance(dtype, str) and dtype == 'string')):
+            dtype = pandas_dtype(dtype)
+            assert isinstance(dtype, StringDtype) and dtype.storage == 'pyarrow'
+        if isinstance(scalars, BaseMaskedArray):
+            na_values = scalars._mask
+            result = scalars._data
+            result = lib.ensure_string_array(result, copy=copy, convert_na_value=False)
+            return cls(pa.array(result, mask=na_values, type=pa.large_string()))
+        elif isinstance(scalars, (pa.Array, pa.ChunkedArray)):
+            return cls(pc.cast(scalars, pa.large_string()))
+        result = lib.ensure_string_array(scalars, copy=copy)
+        return cls(pa.array(result, type=pa.large_string(), from_pandas=True))
+
+    @classmethod
+    def _from_sequence_of_strings(cls, strings, *, dtype: ExtensionDtype, copy: bool=False) -> Self:
+        return cls._from_sequence(strings, dtype=dtype, copy=copy)
+
+    @property
+    def dtype(self) -> StringDtype:
+        return self._dtype
+
+    def insert(self, loc: int, item) -> ArrowStringArray:
+        if self.dtype.na_value is np.nan and item is np.nan:
+            item = libmissing.NA
+        if not isinstance(item, str) and item is not libmissing.NA:
+            raise TypeError('Scalar must be NA or str')
+        return super().insert(loc, item)
+
+    def _convert_bool_result(self, values):
+        if self.dtype.na_value is np.nan:
+            return ArrowExtensionArray(values).to_numpy(na_value=np.nan)
+        return BooleanDtype().__from_arrow__(values)
+
+    def _maybe_convert_setitem_value(self, value):
+        if is_scalar(value):
+            if isna(value):
+                value = None
+            elif not isinstance(value, str):
+                raise TypeError('Scalar must be NA or str')
+        else:
+            value = np.array(value, dtype=object, copy=True)
+            value[isna(value)] = None
+            for v in value:
+                if not (v is None or isinstance(v, str)):
+                    raise TypeError('Must provide strings')
+        return super()._maybe_convert_setitem_value(value)
+
+    def isin(self, values: ArrayLike) -> npt.NDArray[np.bool_]:
+        value_set = [pa_scalar.as_py() for pa_scalar in [pa.scalar(value, from_pandas=True) for value in values] if pa_scalar.type in (pa.string(), pa.null(), pa.large_string())]
+        if not len(value_set):
+            return np.zeros(len(self), dtype=bool)
+        result = pc.is_in(self._pa_array, value_set=pa.array(value_set, type=self._pa_array.type))
+        return np.array(result, dtype=np.bool_)
+
+    def astype(self, dtype, copy: bool=True):
+        dtype = pandas_dtype(dtype)
+        if dtype == self.dtype:
+            if copy:
+                return self.copy()
+            return self
+        elif isinstance(dtype, NumericDtype):
+            data = self._pa_array.cast(pa.from_numpy_dtype(dtype.numpy_dtype))
+            return dtype.__from_arrow__(data)
+        elif isinstance(dtype, np.dtype) and np.issubdtype(dtype, np.floating):
+            return self.to_numpy(dtype=dtype, na_value=np.nan)
+        return super().astype(dtype, copy=copy)
+    _str_isalnum = ArrowStringArrayMixin._str_isalnum
+    _str_isalpha = ArrowStringArrayMixin._str_isalpha
+    _str_isdecimal = ArrowStringArrayMixin._str_isdecimal
+    _str_isdigit = ArrowStringArrayMixin._str_isdigit
+    _str_islower = ArrowStringArrayMixin._str_islower
+    _str_isnumeric = ArrowStringArrayMixin._str_isnumeric
+    _str_isspace = ArrowStringArrayMixin._str_isspace
+    _str_istitle = ArrowStringArrayMixin._str_istitle
+    _str_isupper = ArrowStringArrayMixin._str_isupper
+    _str_map = BaseStringArray._str_map
+    _str_startswith = ArrowStringArrayMixin._str_startswith
+    _str_endswith = ArrowStringArrayMixin._str_endswith
+    _str_pad = ArrowStringArrayMixin._str_pad
+    _str_match = ArrowStringArrayMixin._str_match
+    _str_fullmatch = ArrowStringArrayMixin._str_fullmatch
+    _str_lower = ArrowStringArrayMixin._str_lower
+    _str_upper = ArrowStringArrayMixin._str_upper
+    _str_strip = ArrowStringArrayMixin._str_strip
+    _str_lstrip = ArrowStringArrayMixin._str_lstrip
+    _str_rstrip = ArrowStringArrayMixin._str_rstrip
+    _str_removesuffix = ArrowStringArrayMixin._str_removesuffix
+    _str_get = ArrowStringArrayMixin._str_get
+    _str_capitalize = ArrowStringArrayMixin._str_capitalize
+    _str_title = ArrowStringArrayMixin._str_title
+    _str_swapcase = ArrowStringArrayMixin._str_swapcase
+    _str_slice_replace = ArrowStringArrayMixin._str_slice_replace
+    _str_len = ArrowStringArrayMixin._str_len
+    _str_slice = ArrowStringArrayMixin._str_slice
+
+    def _str_contains(self, pat, case: bool=True, flags: int=0, na=np.nan, regex: bool=True):
+        if flags:
+            return super()._str_contains(pat, case, flags, na, regex)
+        if not isna(na):
+            if not isinstance(na, bool):
+                warnings.warn("Allowing a non-bool 'na' in obj.str.contains is deprecated and will raise in a future version.", FutureWarning, stacklevel=find_stack_level())
+                na = bool(na)
+        return ArrowStringArrayMixin._str_contains(self, pat, case, flags, na, regex)
+
+    def _str_replace(self, pat: str | re.Pattern, repl: str | Callable, n: int=-1, case: bool=True, flags: int=0, regex: bool=True):
+        if isinstance(pat, re.Pattern) or callable(repl) or (not case) or flags:
+            return super()._str_replace(pat, repl, n, case, flags, regex)
+        return ArrowStringArrayMixin._str_replace(self, pat, repl, n, case, flags, regex)
+
+    def _str_repeat(self, repeats: int | Sequence[int]):
+        if not isinstance(repeats, int):
+            return super()._str_repeat(repeats)
+        else:
+            return ArrowExtensionArray._str_repeat(self, repeats=repeats)
+
+    def _str_removeprefix(self, prefix: str):
+        if not pa_version_under13p0:
+            return ArrowStringArrayMixin._str_removeprefix(self, prefix)
+        return super()._str_removeprefix(prefix)
+
+    def _str_count(self, pat: str, flags: int=0):
+        if flags:
+            return super()._str_count(pat, flags)
+        result = pc.count_substring_regex(self._pa_array, pat)
+        return self._convert_int_result(result)
+
+    def _str_find(self, sub: str, start: int=0, end: int | None=None):
+        if pa_version_under13p0 and (not (start != 0 and end is not None)) and (not (start == 0 and end is None)):
+            return super()._str_find(sub, start, end)
+        return ArrowStringArrayMixin._str_find(self, sub, start, end)
+
+    def _str_get_dummies(self, sep: str='|', dtype: NpDtype | None=None):
+        if dtype is None:
+            dtype = np.int64
+        (dummies_pa, labels) = ArrowExtensionArray(self._pa_array)._str_get_dummies(sep, dtype)
+        if len(labels) == 0:
+            return (np.empty(shape=(0, 0), dtype=dtype), labels)
+        dummies = np.vstack(dummies_pa.to_numpy())
+        _dtype = pandas_dtype(dtype)
+        dummies_dtype: NpDtype
+        if isinstance(_dtype, np.dtype):
+            dummies_dtype = _dtype
+        else:
+            dummies_dtype = np.bool_
+        return (dummies.astype(dummies_dtype, copy=False), labels)
+
+    def _convert_int_result(self, result):
+        if self.dtype.na_value is np.nan:
+            if isinstance(result, pa.Array):
+                result = result.to_numpy(zero_copy_only=False)
+            else:
+                result = result.to_numpy()
+            if result.dtype == np.int32:
+                result = result.astype(np.int64)
+            return result
+        return Int64Dtype().__from_arrow__(result)
+
+    def _convert_rank_result(self, result):
+        if self.dtype.na_value is np.nan:
+            if isinstance(result, pa.Array):
+                result = result.to_numpy(zero_copy_only=False)
+            else:
+                result = result.to_numpy()
+            return result.astype('float64', copy=False)
+        return Float64Dtype().__from_arrow__(result)
+
+    def _reduce(self, name: str, *, skipna: bool=True, keepdims: bool=False, **kwargs):
+        if self.dtype.na_value is np.nan and name in ['any', 'all']:
+            if not skipna:
+                nas = pc.is_null(self._pa_array)
+                arr = pc.or_kleene(nas, pc.not_equal(self._pa_array, ''))
+            else:
+                arr = pc.not_equal(self._pa_array, '')
+            return ArrowExtensionArray(arr)._reduce(name, skipna=skipna, keepdims=keepdims, **kwargs)
+        result = self._reduce_calc(name, skipna=skipna, keepdims=keepdims, **kwargs)
+        if name in ('argmin', 'argmax') and isinstance(result, pa.Array):
+            return self._convert_int_result(result)
+        elif isinstance(result, pa.Array):
+            return type(self)(result)
+        else:
+            return result
+
+    def value_counts(self, dropna: bool=True) -> Series:
+        result = super().value_counts(dropna=dropna)
+        if self.dtype.na_value is np.nan:
+            res_values = result._values.to_numpy()
+            return result._constructor(res_values, index=result.index, name=result.name, copy=False)
+        return result
+
+    def _cmp_method(self, other, op):
+        result = super()._cmp_method(other, op)
+        if self.dtype.na_value is np.nan:
+            if op == operator.ne:
+                return result.to_numpy(np.bool_, na_value=True)
+            else:
+                return result.to_numpy(np.bool_, na_value=False)
+        return result
+
+class ArrowStringArrayNumpySemantics(ArrowStringArray):
+    _na_value = np.nan
+
+# File: pandas-main/pandas/core/arrays/timedeltas.py
+from __future__ import annotations
+from datetime import timedelta
+import operator
+from typing import TYPE_CHECKING, cast
+import numpy as np
+from pandas._libs import lib, tslibs
+from pandas._libs.tslibs import NaT, NaTType, Tick, Timedelta, astype_overflowsafe, get_supported_dtype, iNaT, is_supported_dtype, periods_per_second
+from pandas._libs.tslibs.conversion import cast_from_unit_vectorized
+from pandas._libs.tslibs.fields import get_timedelta_days, get_timedelta_field
+from pandas._libs.tslibs.timedeltas import array_to_timedelta64, floordiv_object_array, ints_to_pytimedelta, parse_timedelta_unit, truediv_object_array
+from pandas.compat.numpy import function as nv
+from pandas.util._validators import validate_endpoints
+from pandas.core.dtypes.common import TD64NS_DTYPE, is_float_dtype, is_integer_dtype, is_object_dtype, is_scalar, is_string_dtype, pandas_dtype
+from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.missing import isna
+from pandas.core import nanops, roperator
+from pandas.core.array_algos import datetimelike_accumulations
+from pandas.core.arrays import datetimelike as dtl
+from pandas.core.arrays._ranges import generate_regular_range
+import pandas.core.common as com
+from pandas.core.ops.common import unpack_zerodim_and_defer
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from pandas._typing import AxisInt, DateTimeErrorChoices, DtypeObj, NpDtype, Self, npt
+    from pandas import DataFrame
+import textwrap
+
+def _field_accessor(name: str, alias: str, docstring: str):
+
+    def f(self) -> np.ndarray:
+        values = self.asi8
+        if alias == 'days':
+            result = get_timedelta_days(values, reso=self._creso)
+        else:
+            result = get_timedelta_field(values, alias, reso=self._creso)
+        if self._hasna:
+            result = self._maybe_mask_results(result, fill_value=None, convert='float64')
+        return result
+    f.__name__ = name
+    f.__doc__ = f'\n{docstring}\n'
+    return property(f)
+
+class TimedeltaArray(dtl.TimelikeOps):
+    _typ = 'timedeltaarray'
+    _internal_fill_value = np.timedelta64('NaT', 'ns')
+    _recognized_scalars = (timedelta, np.timedelta64, Tick)
+    _is_recognized_dtype = lambda x: lib.is_np_dtype(x, 'm')
+    _infer_matches = ('timedelta', 'timedelta64')
+
+    @property
+    def _scalar_type(self) -> type[Timedelta]:
+        return Timedelta
+    __array_priority__ = 1000
+    _other_ops: list[str] = []
+    _bool_ops: list[str] = []
+    _field_ops: list[str] = ['days', 'seconds', 'microseconds', 'nanoseconds']
+    _datetimelike_ops: list[str] = _field_ops + _bool_ops + ['unit', 'freq']
+    _datetimelike_methods: list[str] = ['to_pytimedelta', 'total_seconds', 'round', 'floor', 'ceil', 'as_unit']
+
+    def _box_func(self, x: np.timedelta64) -> Timedelta | NaTType:
+        y = x.view('i8')
+        if y == NaT._value:
+            return NaT
+        return Timedelta._from_value_and_reso(y, reso=self._creso)
+
+    @property
+    def dtype(self) -> np.dtype[np.timedelta64]:
+        return self._ndarray.dtype
+    _freq = None
+
+    @classmethod
+    def _validate_dtype(cls, values, dtype):
+        dtype = _validate_td64_dtype(dtype)
+        _validate_td64_dtype(values.dtype)
+        if dtype != values.dtype:
+            raise ValueError('Values resolution does not match dtype.')
+        return dtype
+
+    @classmethod
+    def _simple_new(cls, values: npt.NDArray[np.timedelta64], freq: Tick | None=None, dtype: np.dtype[np.timedelta64]=TD64NS_DTYPE) -> Self:
+        assert lib.is_np_dtype(dtype, 'm')
+        assert not tslibs.is_unitless(dtype)
+        assert isinstance(values, np.ndarray), type(values)
+        assert dtype == values.dtype
+        assert freq is None or isinstance(freq, Tick)
+        result = super()._simple_new(values=values, dtype=dtype)
+        result._freq = freq
+        return result
+
+    @classmethod
+    def _from_sequence(cls, data, *, dtype=None, copy: bool=False) -> Self:
+        if dtype:
+            dtype = _validate_td64_dtype(dtype)
+        (data, freq) = sequence_to_td64ns(data, copy=copy, unit=None)
+        if dtype is not None:
+            data = astype_overflowsafe(data, dtype=dtype, copy=False)
+        return cls._simple_new(data, dtype=data.dtype, freq=freq)
+
+    @classmethod
+    def _from_sequence_not_strict(cls, data, *, dtype=None, copy: bool=False, freq=lib.no_default, unit=None) -> Self:
+        if dtype:
+            dtype = _validate_td64_dtype(dtype)
+        assert unit not in ['Y', 'y', 'M']
+        (data, inferred_freq) = sequence_to_td64ns(data, copy=copy, unit=unit)
+        if dtype is not None:
+            data = astype_overflowsafe(data, dtype=dtype, copy=False)
+        result = cls._simple_new(data, dtype=data.dtype, freq=inferred_freq)
+        result._maybe_pin_freq(freq, {})
+        return result
+
+    @classmethod
+    def _generate_range(cls, start, end, periods, freq, closed=None, *, unit: str | None=None) -> Self:
+        periods = dtl.validate_periods(periods)
+        if freq is None and any((x is None for x in [periods, start, end])):
+            raise ValueError('Must provide freq argument if no data is supplied')
+        if com.count_not_none(start, end, periods, freq) != 3:
+            raise ValueError('Of the four parameters: start, end, periods, and freq, exactly three must be specified')
+        if start is not None:
+            start = Timedelta(start).as_unit('ns')
+        if end is not None:
+            end = Timedelta(end).as_unit('ns')
+        if unit is not None:
+            if unit not in ['s', 'ms', 'us', 'ns']:
+                raise ValueError("'unit' must be one of 's', 'ms', 'us', 'ns'")
+        else:
+            unit = 'ns'
+        if start is not None and unit is not None:
+            start = start.as_unit(unit, round_ok=False)
+        if end is not None and unit is not None:
+            end = end.as_unit(unit, round_ok=False)
+        (left_closed, right_closed) = validate_endpoints(closed)
+        if freq is not None:
+            index = generate_regular_range(start, end, periods, freq, unit=unit)
+        else:
+            index = np.linspace(start._value, end._value, periods).astype('i8')
+        if not left_closed:
+            index = index[1:]
+        if not right_closed:
+            index = index[:-1]
+        td64values = index.view(f'm8[{unit}]')
+        return cls._simple_new(td64values, dtype=td64values.dtype, freq=freq)
+
+    def _unbox_scalar(self, value) -> np.timedelta64:
+        if not isinstance(value, self._scalar_type) and value is not NaT:
+            raise ValueError("'value' should be a Timedelta.")
+        self._check_compatible_with(value)
+        if value is NaT:
+            return np.timedelta64(value._value, self.unit)
+        else:
+            return value.as_unit(self.unit, round_ok=False).asm8
+
+    def _scalar_from_string(self, value) -> Timedelta | NaTType:
+        return Timedelta(value)
+
+    def _check_compatible_with(self, other) -> None:
+        pass
+
+    def astype(self, dtype, copy: bool=True):
+        dtype = pandas_dtype(dtype)
+        if lib.is_np_dtype(dtype, 'm'):
+            if dtype == self.dtype:
+                if copy:
+                    return self.copy()
+                return self
+            if is_supported_dtype(dtype):
+                res_values = astype_overflowsafe(self._ndarray, dtype, copy=False)
+                return type(self)._simple_new(res_values, dtype=res_values.dtype, freq=self.freq)
+            else:
+                raise ValueError(f"Cannot convert from {self.dtype} to {dtype}. Supported resolutions are 's', 'ms', 'us', 'ns'")
+        return dtl.DatetimeLikeArrayMixin.astype(self, dtype, copy=copy)
+
+    def __iter__(self) -> Iterator:
+        if self.ndim > 1:
+            for i in range(len(self)):
+                yield self[i]
+        else:
+            data = self._ndarray
+            length = len(self)
+            chunksize = 10000
+            chunks = length // chunksize + 1
+            for i in range(chunks):
+                start_i = i * chunksize
+                end_i = min((i + 1) * chunksize, length)
+                converted = ints_to_pytimedelta(data[start_i:end_i], box=True)
+                yield from converted
+
+    def sum(self, *, axis: AxisInt | None=None, dtype: NpDtype | None=None, out=None, keepdims: bool=False, initial=None, skipna: bool=True, min_count: int=0):
+        nv.validate_sum((), {'dtype': dtype, 'out': out, 'keepdims': keepdims, 'initial': initial})
+        result = nanops.nansum(self._ndarray, axis=axis, skipna=skipna, min_count=min_count)
+        return self._wrap_reduction_result(axis, result)
+
+    def std(self, *, axis: AxisInt | None=None, dtype: NpDtype | None=None, out=None, ddof: int=1, keepdims: bool=False, skipna: bool=True):
+        nv.validate_stat_ddof_func((), {'dtype': dtype, 'out': out, 'keepdims': keepdims}, fname='std')
+        result = nanops.nanstd(self._ndarray, axis=axis, skipna=skipna, ddof=ddof)
+        if axis is None or self.ndim == 1:
+            return self._box_func(result)
+        return self._from_backing_data(result)
+
+    def _accumulate(self, name: str, *, skipna: bool=True, **kwargs):
+        if name == 'cumsum':
+            op = getattr(datetimelike_accumulations, name)
+            result = op(self._ndarray.copy(), skipna=skipna, **kwargs)
+            return type(self)._simple_new(result, freq=None, dtype=self.dtype)
+        elif name == 'cumprod':
+            raise TypeError('cumprod not supported for Timedelta.')
+        else:
+            return super()._accumulate(name, skipna=skipna, **kwargs)
+
+    def _formatter(self, boxed: bool=False):
+        from pandas.io.formats.format import get_format_timedelta64
+        return get_format_timedelta64(self, box=True)
+
+    def _format_native_types(self, *, na_rep: str | float='NaT', date_format=None, **kwargs) -> npt.NDArray[np.object_]:
+        from pandas.io.formats.format import get_format_timedelta64
+        formatter = get_format_timedelta64(self, na_rep)
+        return np.frompyfunc(formatter, 1, 1)(self._ndarray)
+
+    def _add_offset(self, other):
+        assert not isinstance(other, Tick)
+        raise TypeError(f'cannot add the type {type(other).__name__} to a {type(self).__name__}')
+
+    @unpack_zerodim_and_defer('__mul__')
+    def __mul__(self, other) -> Self:
+        if is_scalar(other):
+            result = self._ndarray * other
+            if result.dtype.kind != 'm':
+                raise TypeError(f'Cannot multiply with {type(other).__name__}')
+            freq = None
+            if self.freq is not None and (not isna(other)):
+                freq = self.freq * other
+                if freq.n == 0:
+                    freq = None
+            return type(self)._simple_new(result, dtype=result.dtype, freq=freq)
+        if not hasattr(other, 'dtype'):
+            other = np.array(other)
+        if len(other) != len(self) and (not lib.is_np_dtype(other.dtype, 'm')):
+            raise ValueError('Cannot multiply with unequal lengths')
+        if is_object_dtype(other.dtype):
+            arr = self._ndarray
+            result = [arr[n] * other[n] for n in range(len(self))]
+            result = np.array(result)
+            return type(self)._simple_new(result, dtype=result.dtype)
+        result = self._ndarray * other
+        if result.dtype.kind != 'm':
+            raise TypeError(f'Cannot multiply with {type(other).__name__}')
+        return type(self)._simple_new(result, dtype=result.dtype)
+    __rmul__ = __mul__
+
+    def _scalar_divlike_op(self, other, op):
+        if isinstance(other, self._recognized_scalars):
+            other = Timedelta(other)
+            if cast('Timedelta | NaTType', other) is NaT:
+                res = np.empty(self.shape, dtype=np.float64)
+                res.fill(np.nan)
+                return res
+            return op(self._ndarray, other)
+        else:
+            if op in [roperator.rtruediv, roperator.rfloordiv]:
+                raise TypeError(f'Cannot divide {type(other).__name__} by {type(self).__name__}')
+            result = op(self._ndarray, other)
+            freq = None
+            if self.freq is not None:
+                freq = self.freq / other
+                if freq.nanos == 0 and self.freq.nanos != 0:
+                    freq = None
+            return type(self)._simple_new(result, dtype=result.dtype, freq=freq)
+
+    def _cast_divlike_op(self, other):
+        if not hasattr(other, 'dtype'):
+            other = np.array(other)
+        if len(other) != len(self):
+            raise ValueError('Cannot divide vectors with unequal lengths')
+        return other
+
+    def _vector_divlike_op(self, other, op) -> np.ndarray | Self:
+        result = op(self._ndarray, np.asarray(other))
+        if (is_integer_dtype(other.dtype) or is_float_dtype(other.dtype)) and op in [operator.truediv, operator.floordiv]:
+            return type(self)._simple_new(result, dtype=result.dtype)
+        if op in [operator.floordiv, roperator.rfloordiv]:
+            mask = self.isna() | isna(other)
+            if mask.any():
+                result = result.astype(np.float64)
+                np.putmask(result, mask, np.nan)
+        return result
+
+    @unpack_zerodim_and_defer('__truediv__')
+    def __truediv__(self, other):
+        op = operator.truediv
+        if is_scalar(other):
+            return self._scalar_divlike_op(other, op)
+        other = self._cast_divlike_op(other)
+        if lib.is_np_dtype(other.dtype, 'm') or is_integer_dtype(other.dtype) or is_float_dtype(other.dtype):
+            return self._vector_divlike_op(other, op)
+        if is_object_dtype(other.dtype):
+            other = np.asarray(other)
+            if self.ndim > 1:
+                res_cols = [left / right for (left, right) in zip(self, other)]
+                res_cols2 = [x.reshape(1, -1) for x in res_cols]
+                result = np.concatenate(res_cols2, axis=0)
+            else:
+                result = truediv_object_array(self._ndarray, other)
+            return result
+        else:
+            return NotImplemented
+
+    @unpack_zerodim_and_defer('__rtruediv__')
+    def __rtruediv__(self, other):
+        op = roperator.rtruediv
+        if is_scalar(other):
+            return self._scalar_divlike_op(other, op)
+        other = self._cast_divlike_op(other)
+        if lib.is_np_dtype(other.dtype, 'm'):
+            return self._vector_divlike_op(other, op)
+        elif is_object_dtype(other.dtype):
+            result_list = [other[n] / self[n] for n in range(len(self))]
+            return np.array(result_list)
+        else:
+            return NotImplemented
+
+    @unpack_zerodim_and_defer('__floordiv__')
+    def __floordiv__(self, other):
+        op = operator.floordiv
+        if is_scalar(other):
+            return self._scalar_divlike_op(other, op)
+        other = self._cast_divlike_op(other)
+        if lib.is_np_dtype(other.dtype, 'm') or is_integer_dtype(other.dtype) or is_float_dtype(other.dtype):
+            return self._vector_divlike_op(other, op)
+        elif is_object_dtype(other.dtype):
+            other = np.asarray(other)
+            if self.ndim > 1:
+                res_cols = [left // right for (left, right) in zip(self, other)]
+                res_cols2 = [x.reshape(1, -1) for x in res_cols]
+                result = np.concatenate(res_cols2, axis=0)
+            else:
+                result = floordiv_object_array(self._ndarray, other)
+            assert result.dtype == object
+            return result
+        else:
+            return NotImplemented
+
+    @unpack_zerodim_and_defer('__rfloordiv__')
+    def __rfloordiv__(self, other):
+        op = roperator.rfloordiv
+        if is_scalar(other):
+            return self._scalar_divlike_op(other, op)
+        other = self._cast_divlike_op(other)
+        if lib.is_np_dtype(other.dtype, 'm'):
+            return self._vector_divlike_op(other, op)
+        elif is_object_dtype(other.dtype):
+            result_list = [other[n] // self[n] for n in range(len(self))]
+            result = np.array(result_list)
+            return result
+        else:
+            return NotImplemented
+
+    @unpack_zerodim_and_defer('__mod__')
+    def __mod__(self, other):
+        if isinstance(other, self._recognized_scalars):
+            other = Timedelta(other)
+        return self - self // other * other
+
+    @unpack_zerodim_and_defer('__rmod__')
+    def __rmod__(self, other):
+        if isinstance(other, self._recognized_scalars):
+            other = Timedelta(other)
+        return other - other // self * self
+
+    @unpack_zerodim_and_defer('__divmod__')
+    def __divmod__(self, other):
+        if isinstance(other, self._recognized_scalars):
+            other = Timedelta(other)
+        res1 = self // other
+        res2 = self - res1 * other
+        return (res1, res2)
+
+    @unpack_zerodim_and_defer('__rdivmod__')
+    def __rdivmod__(self, other):
+        if isinstance(other, self._recognized_scalars):
+            other = Timedelta(other)
+        res1 = other // self
+        res2 = other - res1 * self
+        return (res1, res2)
+
+    def __neg__(self) -> TimedeltaArray:
+        freq = None
+        if self.freq is not None:
+            freq = -self.freq
+        return type(self)._simple_new(-self._ndarray, dtype=self.dtype, freq=freq)
+
+    def __pos__(self) -> TimedeltaArray:
+        return type(self)._simple_new(self._ndarray.copy(), dtype=self.dtype, freq=self.freq)
+
+    def __abs__(self) -> TimedeltaArray:
+        return type(self)._simple_new(np.abs(self._ndarray), dtype=self.dtype)
+
+    def total_seconds(self) -> npt.NDArray[np.float64]:
+        pps = periods_per_second(self._creso)
+        return self._maybe_mask_results(self.asi8 / pps, fill_value=None)
+
+    def to_pytimedelta(self) -> npt.NDArray[np.object_]:
+        return ints_to_pytimedelta(self._ndarray)
+    days_docstring = textwrap.dedent('Number of days for each element.\n\n    See Also\n    --------\n    Series.dt.seconds : Return number of seconds for each element.\n    Series.dt.microseconds : Return number of microseconds for each element.\n    Series.dt.nanoseconds : Return number of nanoseconds for each element.\n\n    Examples\n    --------\n    For Series:\n\n    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit=\'D\'))\n    >>> ser\n    0   1 days\n    1   2 days\n    2   3 days\n    dtype: timedelta64[ns]\n    >>> ser.dt.days\n    0    1\n    1    2\n    2    3\n    dtype: int64\n\n    For TimedeltaIndex:\n\n    >>> tdelta_idx = pd.to_timedelta(["0 days", "10 days", "20 days"])\n    >>> tdelta_idx\n    TimedeltaIndex([\'0 days\', \'10 days\', \'20 days\'],\n                    dtype=\'timedelta64[ns]\', freq=None)\n    >>> tdelta_idx.days\n    Index([0, 10, 20], dtype=\'int64\')')
+    days = _field_accessor('days', 'days', days_docstring)
+    seconds_docstring = textwrap.dedent("Number of seconds (>= 0 and less than 1 day) for each element.\n\n    See Also\n    --------\n    Series.dt.seconds : Return number of seconds for each element.\n    Series.dt.nanoseconds : Return number of nanoseconds for each element.\n\n    Examples\n    --------\n    For Series:\n\n    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='s'))\n    >>> ser\n    0   0 days 00:00:01\n    1   0 days 00:00:02\n    2   0 days 00:00:03\n    dtype: timedelta64[ns]\n    >>> ser.dt.seconds\n    0    1\n    1    2\n    2    3\n    dtype: int32\n\n    For TimedeltaIndex:\n\n    >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='s')\n    >>> tdelta_idx\n    TimedeltaIndex(['0 days 00:00:01', '0 days 00:00:02', '0 days 00:00:03'],\n                   dtype='timedelta64[ns]', freq=None)\n    >>> tdelta_idx.seconds\n    Index([1, 2, 3], dtype='int32')")
+    seconds = _field_accessor('seconds', 'seconds', seconds_docstring)
+    microseconds_docstring = textwrap.dedent("Number of microseconds (>= 0 and less than 1 second) for each element.\n\n    See Also\n    --------\n    pd.Timedelta.microseconds : Number of microseconds (>= 0 and less than 1 second).\n    pd.Timedelta.to_pytimedelta.microseconds : Number of microseconds (>= 0 and less\n        than 1 second) of a datetime.timedelta.\n\n    Examples\n    --------\n    For Series:\n\n    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='us'))\n    >>> ser\n    0   0 days 00:00:00.000001\n    1   0 days 00:00:00.000002\n    2   0 days 00:00:00.000003\n    dtype: timedelta64[ns]\n    >>> ser.dt.microseconds\n    0    1\n    1    2\n    2    3\n    dtype: int32\n\n    For TimedeltaIndex:\n\n    >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='us')\n    >>> tdelta_idx\n    TimedeltaIndex(['0 days 00:00:00.000001', '0 days 00:00:00.000002',\n                    '0 days 00:00:00.000003'],\n                   dtype='timedelta64[ns]', freq=None)\n    >>> tdelta_idx.microseconds\n    Index([1, 2, 3], dtype='int32')")
+    microseconds = _field_accessor('microseconds', 'microseconds', microseconds_docstring)
+    nanoseconds_docstring = textwrap.dedent("Number of nanoseconds (>= 0 and less than 1 microsecond) for each element.\n\n    See Also\n    --------\n    Series.dt.seconds : Return number of seconds for each element.\n    Series.dt.microseconds : Return number of nanoseconds for each element.\n\n    Examples\n    --------\n    For Series:\n\n    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='ns'))\n    >>> ser\n    0   0 days 00:00:00.000000001\n    1   0 days 00:00:00.000000002\n    2   0 days 00:00:00.000000003\n    dtype: timedelta64[ns]\n    >>> ser.dt.nanoseconds\n    0    1\n    1    2\n    2    3\n    dtype: int32\n\n    For TimedeltaIndex:\n\n    >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='ns')\n    >>> tdelta_idx\n    TimedeltaIndex(['0 days 00:00:00.000000001', '0 days 00:00:00.000000002',\n                    '0 days 00:00:00.000000003'],\n                   dtype='timedelta64[ns]', freq=None)\n    >>> tdelta_idx.nanoseconds\n    Index([1, 2, 3], dtype='int32')")
+    nanoseconds = _field_accessor('nanoseconds', 'nanoseconds', nanoseconds_docstring)
+
+    @property
+    def components(self) -> DataFrame:
+        from pandas import DataFrame
+        columns = ['days', 'hours', 'minutes', 'seconds', 'milliseconds', 'microseconds', 'nanoseconds']
+        hasnans = self._hasna
+        if hasnans:
+
+            def f(x):
+                if isna(x):
+                    return [np.nan] * len(columns)
+                return x.components
+        else:
+
+            def f(x):
+                return x.components
+        result = DataFrame([f(x) for x in self], columns=columns)
+        if not hasnans:
+            result = result.astype('int64')
+        return result
+
+def sequence_to_td64ns(data, copy: bool=False, unit=None, errors: DateTimeErrorChoices='raise') -> tuple[np.ndarray, Tick | None]:
+    assert unit not in ['Y', 'y', 'M']
+    inferred_freq = None
+    if unit is not None:
+        unit = parse_timedelta_unit(unit)
+    (data, copy) = dtl.ensure_arraylike_for_datetimelike(data, copy, cls_name='TimedeltaArray')
+    if isinstance(data, TimedeltaArray):
+        inferred_freq = data.freq
+    if data.dtype == object or is_string_dtype(data.dtype):
+        data = _objects_to_td64ns(data, unit=unit, errors=errors)
+        copy = False
+    elif is_integer_dtype(data.dtype):
+        (data, copy_made) = _ints_to_td64ns(data, unit=unit)
+        copy = copy and (not copy_made)
+    elif is_float_dtype(data.dtype):
+        if isinstance(data.dtype, ExtensionDtype):
+            mask = data._mask
+            data = data._data
+        else:
+            mask = np.isnan(data)
+        data = cast_from_unit_vectorized(data, unit or 'ns')
+        data[mask] = iNaT
+        data = data.view('m8[ns]')
+        copy = False
+    elif lib.is_np_dtype(data.dtype, 'm'):
+        if not is_supported_dtype(data.dtype):
+            new_dtype = get_supported_dtype(data.dtype)
+            data = astype_overflowsafe(data, dtype=new_dtype, copy=False)
+            copy = False
+    else:
+        raise TypeError(f'dtype {data.dtype} cannot be converted to timedelta64[ns]')
+    if not copy:
+        data = np.asarray(data)
+    else:
+        data = np.array(data, copy=copy)
+    assert data.dtype.kind == 'm'
+    assert data.dtype != 'm8'
+    return (data, inferred_freq)
+
+def _ints_to_td64ns(data, unit: str='ns') -> tuple[np.ndarray, bool]:
+    copy_made = False
+    unit = unit if unit is not None else 'ns'
+    if data.dtype != np.int64:
+        data = data.astype(np.int64)
+        copy_made = True
+    if unit != 'ns':
+        dtype_str = f'timedelta64[{unit}]'
+        data = data.view(dtype_str)
+        data = astype_overflowsafe(data, dtype=TD64NS_DTYPE)
+        copy_made = True
+    else:
+        data = data.view('timedelta64[ns]')
+    return (data, copy_made)
+
+def _objects_to_td64ns(data, unit=None, errors: DateTimeErrorChoices='raise') -> np.ndarray:
+    values = np.asarray(data, dtype=np.object_)
+    result = array_to_timedelta64(values, unit=unit, errors=errors)
+    return result.view('timedelta64[ns]')
+
+def _validate_td64_dtype(dtype) -> DtypeObj:
+    dtype = pandas_dtype(dtype)
+    if dtype == np.dtype('m8'):
+        msg = "Passing in 'timedelta' dtype with no precision is not allowed. Please pass in 'timedelta64[ns]' instead."
+        raise ValueError(msg)
+    if not lib.is_np_dtype(dtype, 'm'):
+        raise ValueError(f"dtype '{dtype}' is invalid, should be np.timedelta64 dtype")
+    elif not is_supported_dtype(dtype):
+        raise ValueError("Supported timedelta64 resolutions are 's', 'ms', 'us', 'ns'")
+    return dtype
+
+# File: pandas-main/pandas/core/base.py
+""""""
+from __future__ import annotations
+import textwrap
+from typing import TYPE_CHECKING, Any, Generic, Literal, cast, final, overload
+import numpy as np
+from pandas._libs import lib
+from pandas._typing import AxisInt, DtypeObj, IndexLabel, NDFrameT, Self, Shape, npt
+from pandas.compat import PYPY
+from pandas.compat.numpy import function as nv
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import cache_readonly, doc
+from pandas.core.dtypes.cast import can_hold_element
+from pandas.core.dtypes.common import is_object_dtype, is_scalar
+from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCIndex, ABCSeries
+from pandas.core.dtypes.missing import isna, remove_na_arraylike
+from pandas.core import algorithms, nanops, ops
+from pandas.core.accessor import DirNamesMixin
+from pandas.core.arraylike import OpsMixin
+from pandas.core.arrays import ExtensionArray
+from pandas.core.construction import ensure_wrapped_if_datetimelike, extract_array
+if TYPE_CHECKING:
+    from collections.abc import Hashable, Iterator
+    from pandas._typing import DropKeep, NumpySorter, NumpyValueArrayLike, ScalarLike_co
+    from pandas import DataFrame, Index, Series
+_shared_docs: dict[str, str] = {}
+
+class PandasObject(DirNamesMixin):
+    _cache: dict[str, Any]
+
+    @property
+    def _constructor(self) -> type[Self]:
+        return type(self)
+
+    def __repr__(self) -> str:
+        return object.__repr__(self)
+
+    def _reset_cache(self, key: str | None=None) -> None:
+        if not hasattr(self, '_cache'):
+            return
+        if key is None:
+            self._cache.clear()
+        else:
+            self._cache.pop(key, None)
+
+    def __sizeof__(self) -> int:
+        memory_usage = getattr(self, 'memory_usage', None)
+        if memory_usage:
+            mem = memory_usage(deep=True)
+            return int(mem if is_scalar(mem) else mem.sum())
+        return super().__sizeof__()
+
+class NoNewAttributesMixin:
+
+    def _freeze(self) -> None:
+        object.__setattr__(self, '__frozen', True)
+
+    def __setattr__(self, key: str, value) -> None:
+        if getattr(self, '__frozen', False) and (not (key == '_cache' or key in type(self).__dict__ or getattr(self, key, None) is not None)):
+            raise AttributeError(f"You cannot add any new attribute '{key}'")
+        object.__setattr__(self, key, value)
+
+class SelectionMixin(Generic[NDFrameT]):
+    obj: NDFrameT
+    _selection: IndexLabel | None = None
+    exclusions: frozenset[Hashable]
+    _internal_names = ['_cache', '__setstate__']
+    _internal_names_set = set(_internal_names)
+
+    @final
+    @property
+    def _selection_list(self):
+        if not isinstance(self._selection, (list, tuple, ABCSeries, ABCIndex, np.ndarray)):
+            return [self._selection]
+        return self._selection
+
+    @cache_readonly
+    def _selected_obj(self):
+        if self._selection is None or isinstance(self.obj, ABCSeries):
+            return self.obj
+        else:
+            return self.obj[self._selection]
+
+    @final
+    @cache_readonly
+    def ndim(self) -> int:
+        return self._selected_obj.ndim
+
+    @final
+    @cache_readonly
+    def _obj_with_exclusions(self):
+        if isinstance(self.obj, ABCSeries):
+            return self.obj
+        if self._selection is not None:
+            return self.obj[self._selection_list]
+        if len(self.exclusions) > 0:
+            return self.obj._drop_axis(self.exclusions, axis=1, only_slice=True)
+        else:
+            return self.obj
+
+    def __getitem__(self, key):
+        if self._selection is not None:
+            raise IndexError(f'Column(s) {self._selection} already selected')
+        if isinstance(key, (list, tuple, ABCSeries, ABCIndex, np.ndarray)):
+            if len(self.obj.columns.intersection(key)) != len(set(key)):
+                bad_keys = list(set(key).difference(self.obj.columns))
+                raise KeyError(f'Columns not found: {str(bad_keys)[1:-1]}')
+            return self._gotitem(list(key), ndim=2)
+        else:
+            if key not in self.obj:
+                raise KeyError(f'Column not found: {key}')
+            ndim = self.obj[key].ndim
+            return self._gotitem(key, ndim=ndim)
+
+    def _gotitem(self, key, ndim: int, subset=None):
+        raise AbstractMethodError(self)
+
+    @final
+    def _infer_selection(self, key, subset: Series | DataFrame):
+        selection = None
+        if subset.ndim == 2 and (lib.is_scalar(key) and key in subset or lib.is_list_like(key)):
+            selection = key
+        elif subset.ndim == 1 and lib.is_scalar(key) and (key == subset.name):
+            selection = key
+        return selection
+
+    def aggregate(self, func, *args, **kwargs):
+        raise AbstractMethodError(self)
+    agg = aggregate
+
+class IndexOpsMixin(OpsMixin):
+    __array_priority__ = 1000
+    _hidden_attrs: frozenset[str] = frozenset(['tolist'])
+
+    @property
+    def dtype(self) -> DtypeObj:
+        raise AbstractMethodError(self)
+
+    @property
+    def _values(self) -> ExtensionArray | np.ndarray:
+        raise AbstractMethodError(self)
+
+    @final
+    def transpose(self, *args, **kwargs) -> Self:
+        nv.validate_transpose(args, kwargs)
+        return self
+    T = property(transpose, doc="\n        Return the transpose, which is by definition self.\n\n        See Also\n        --------\n        Index : Immutable sequence used for indexing and alignment.\n\n        Examples\n        --------\n        For Series:\n\n        >>> s = pd.Series(['Ant', 'Bear', 'Cow'])\n        >>> s\n        0     Ant\n        1    Bear\n        2     Cow\n        dtype: object\n        >>> s.T\n        0     Ant\n        1    Bear\n        2     Cow\n        dtype: object\n\n        For Index:\n\n        >>> idx = pd.Index([1, 2, 3])\n        >>> idx.T\n        Index([1, 2, 3], dtype='int64')\n        ")
+
+    @property
+    def shape(self) -> Shape:
+        return self._values.shape
+
+    def __len__(self) -> int:
+        raise AbstractMethodError(self)
+
+    @property
+    def ndim(self) -> Literal[1]:
+        return 1
+
+    @final
+    def item(self):
+        if len(self) == 1:
+            return next(iter(self))
+        raise ValueError('can only convert an array of size 1 to a Python scalar')
+
+    @property
+    def nbytes(self) -> int:
+        return self._values.nbytes
+
+    @property
+    def size(self) -> int:
+        return len(self._values)
+
+    @property
+    def array(self) -> ExtensionArray:
+        raise AbstractMethodError(self)
+
+    def to_numpy(self, dtype: npt.DTypeLike | None=None, copy: bool=False, na_value: object=lib.no_default, **kwargs) -> np.ndarray:
+        if isinstance(self.dtype, ExtensionDtype):
+            return self.array.to_numpy(dtype, copy=copy, na_value=na_value, **kwargs)
+        elif kwargs:
+            bad_keys = next(iter(kwargs.keys()))
+            raise TypeError(f"to_numpy() got an unexpected keyword argument '{bad_keys}'")
+        fillna = na_value is not lib.no_default and (not (na_value is np.nan and np.issubdtype(self.dtype, np.floating)))
+        values = self._values
+        if fillna and self.hasnans:
+            if not can_hold_element(values, na_value):
+                values = np.asarray(values, dtype=dtype)
+            else:
+                values = values.copy()
+            values[np.asanyarray(isna(self))] = na_value
+        result = np.asarray(values, dtype=dtype)
+        if copy and (not fillna) or not copy:
+            if np.shares_memory(self._values[:2], result[:2]):
+                if not copy:
+                    result = result.view()
+                    result.flags.writeable = False
+                else:
+                    result = result.copy()
+        return result
+
+    @final
+    @property
+    def empty(self) -> bool:
+        return not self.size
+
+    @doc(op='max', oppose='min', value='largest')
+    def argmax(self, axis: AxisInt | None=None, skipna: bool=True, *args, **kwargs) -> int:
+        delegate = self._values
+        nv.validate_minmax_axis(axis)
+        skipna = nv.validate_argmax_with_skipna(skipna, args, kwargs)
+        if isinstance(delegate, ExtensionArray):
+            return delegate.argmax(skipna=skipna)
+        else:
+            result = nanops.nanargmax(delegate, skipna=skipna)
+            return result
+
+    @doc(argmax, op='min', oppose='max', value='smallest')
+    def argmin(self, axis: AxisInt | None=None, skipna: bool=True, *args, **kwargs) -> int:
+        delegate = self._values
+        nv.validate_minmax_axis(axis)
+        skipna = nv.validate_argmax_with_skipna(skipna, args, kwargs)
+        if isinstance(delegate, ExtensionArray):
+            return delegate.argmin(skipna=skipna)
+        else:
+            result = nanops.nanargmin(delegate, skipna=skipna)
+            return result
+
+    def tolist(self) -> list:
+        return self._values.tolist()
+    to_list = tolist
+
+    def __iter__(self) -> Iterator:
+        if not isinstance(self._values, np.ndarray):
+            return iter(self._values)
+        else:
+            return map(self._values.item, range(self._values.size))
+
+    @cache_readonly
+    def hasnans(self) -> bool:
+        return bool(isna(self).any())
+
+    @final
+    def _map_values(self, mapper, na_action=None):
+        arr = self._values
+        if isinstance(arr, ExtensionArray):
+            return arr.map(mapper, na_action=na_action)
+        return algorithms.map_array(arr, mapper, na_action=na_action)
+
+    def value_counts(self, normalize: bool=False, sort: bool=True, ascending: bool=False, bins=None, dropna: bool=True) -> Series:
+        return algorithms.value_counts_internal(self, sort=sort, ascending=ascending, normalize=normalize, bins=bins, dropna=dropna)
+
+    def unique(self):
+        values = self._values
+        if not isinstance(values, np.ndarray):
+            result = values.unique()
+        else:
+            result = algorithms.unique1d(values)
+        return result
+
+    @final
+    def nunique(self, dropna: bool=True) -> int:
+        uniqs = self.unique()
+        if dropna:
+            uniqs = remove_na_arraylike(uniqs)
+        return len(uniqs)
+
+    @property
+    def is_unique(self) -> bool:
+        return self.nunique(dropna=False) == len(self)
+
+    @property
+    def is_monotonic_increasing(self) -> bool:
+        from pandas import Index
+        return Index(self).is_monotonic_increasing
+
+    @property
+    def is_monotonic_decreasing(self) -> bool:
+        from pandas import Index
+        return Index(self).is_monotonic_decreasing
+
+    @final
+    def _memory_usage(self, deep: bool=False) -> int:
+        if hasattr(self.array, 'memory_usage'):
+            return self.array.memory_usage(deep=deep)
+        v = self.array.nbytes
+        if deep and is_object_dtype(self.dtype) and (not PYPY):
+            values = cast(np.ndarray, self._values)
+            v += lib.memory_usage_of_objects(values)
+        return v
+
+    @doc(algorithms.factorize, values='', order='', size_hint='', sort=textwrap.dedent('            sort : bool, default False\n                Sort `uniques` and shuffle `codes` to maintain the\n                relationship.\n            '))
+    def factorize(self, sort: bool=False, use_na_sentinel: bool=True) -> tuple[npt.NDArray[np.intp], Index]:
+        (codes, uniques) = algorithms.factorize(self._values, sort=sort, use_na_sentinel=use_na_sentinel)
+        if uniques.dtype == np.float16:
+            uniques = uniques.astype(np.float32)
+        if isinstance(self, ABCIndex):
+            uniques = self._constructor(uniques)
+        else:
+            from pandas import Index
+            uniques = Index(uniques)
+        return (codes, uniques)
+    _shared_docs['searchsorted'] = "\n        Find indices where elements should be inserted to maintain order.\n\n        Find the indices into a sorted {klass} `self` such that, if the\n        corresponding elements in `value` were inserted before the indices,\n        the order of `self` would be preserved.\n\n        .. note::\n\n            The {klass} *must* be monotonically sorted, otherwise\n            wrong locations will likely be returned. Pandas does *not*\n            check this for you.\n\n        Parameters\n        ----------\n        value : array-like or scalar\n            Values to insert into `self`.\n        side : {{'left', 'right'}}, optional\n            If 'left', the index of the first suitable location found is given.\n            If 'right', return the last such index.  If there is no suitable\n            index, return either 0 or N (where N is the length of `self`).\n        sorter : 1-D array-like, optional\n            Optional array of integer indices that sort `self` into ascending\n            order. They are typically the result of ``np.argsort``.\n\n        Returns\n        -------\n        int or array of int\n            A scalar or array of insertion points with the\n            same shape as `value`.\n\n        See Also\n        --------\n        sort_values : Sort by the values along either axis.\n        numpy.searchsorted : Similar method from NumPy.\n\n        Notes\n        -----\n        Binary search is used to find the required insertion points.\n\n        Examples\n        --------\n        >>> ser = pd.Series([1, 2, 3])\n        >>> ser\n        0    1\n        1    2\n        2    3\n        dtype: int64\n\n        >>> ser.searchsorted(4)\n        3\n\n        >>> ser.searchsorted([0, 4])\n        array([0, 3])\n\n        >>> ser.searchsorted([1, 3], side='left')\n        array([0, 2])\n\n        >>> ser.searchsorted([1, 3], side='right')\n        array([1, 3])\n\n        >>> ser = pd.Series(pd.to_datetime(['3/11/2000', '3/12/2000', '3/13/2000']))\n        >>> ser\n        0   2000-03-11\n        1   2000-03-12\n        2   2000-03-13\n        dtype: datetime64[s]\n\n        >>> ser.searchsorted('3/14/2000')\n        3\n\n        >>> ser = pd.Categorical(\n        ...     ['apple', 'bread', 'bread', 'cheese', 'milk'], ordered=True\n        ... )\n        >>> ser\n        ['apple', 'bread', 'bread', 'cheese', 'milk']\n        Categories (4, object): ['apple' < 'bread' < 'cheese' < 'milk']\n\n        >>> ser.searchsorted('bread')\n        1\n\n        >>> ser.searchsorted(['bread'], side='right')\n        array([3])\n\n        If the values are not monotonically sorted, wrong locations\n        may be returned:\n\n        >>> ser = pd.Series([2, 1, 3])\n        >>> ser\n        0    2\n        1    1\n        2    3\n        dtype: int64\n\n        >>> ser.searchsorted(1)  # doctest: +SKIP\n        0  # wrong result, correct would be 1\n        "
+
+    @overload
+    def searchsorted(self, value: ScalarLike_co, side: Literal['left', 'right']=..., sorter: NumpySorter=...) -> np.intp:
+        ...
+
+    @overload
+    def searchsorted(self, value: npt.ArrayLike | ExtensionArray, side: Literal['left', 'right']=..., sorter: NumpySorter=...) -> npt.NDArray[np.intp]:
+        ...
+
+    @doc(_shared_docs['searchsorted'], klass='Index')
+    def searchsorted(self, value: NumpyValueArrayLike | ExtensionArray, side: Literal['left', 'right']='left', sorter: NumpySorter | None=None) -> npt.NDArray[np.intp] | np.intp:
+        if isinstance(value, ABCDataFrame):
+            msg = f'Value must be 1-D array-like or scalar, {type(value).__name__} is not supported'
+            raise ValueError(msg)
+        values = self._values
+        if not isinstance(values, np.ndarray):
+            return values.searchsorted(value, side=side, sorter=sorter)
+        return algorithms.searchsorted(values, value, side=side, sorter=sorter)
+
+    def drop_duplicates(self, *, keep: DropKeep='first') -> Self:
+        duplicated = self._duplicated(keep=keep)
+        return self[~duplicated]
+
+    @final
+    def _duplicated(self, keep: DropKeep='first') -> npt.NDArray[np.bool_]:
+        arr = self._values
+        if isinstance(arr, ExtensionArray):
+            return arr.duplicated(keep=keep)
+        return algorithms.duplicated(arr, keep=keep)
+
+    def _arith_method(self, other, op):
+        res_name = ops.get_op_result_name(self, other)
+        lvalues = self._values
+        rvalues = extract_array(other, extract_numpy=True, extract_range=True)
+        rvalues = ops.maybe_prepare_scalar_for_op(rvalues, lvalues.shape)
+        rvalues = ensure_wrapped_if_datetimelike(rvalues)
+        if isinstance(rvalues, range):
+            rvalues = np.arange(rvalues.start, rvalues.stop, rvalues.step)
+        with np.errstate(all='ignore'):
+            result = ops.arithmetic_op(lvalues, rvalues, op)
+        return self._construct_result(result, name=res_name)
+
+    def _construct_result(self, result, name):
+        raise AbstractMethodError(self)
+
+# File: pandas-main/pandas/core/common.py
+""""""
+from __future__ import annotations
+import builtins
+from collections import abc, defaultdict
+from collections.abc import Callable, Collection, Generator, Hashable, Iterable, Sequence
+import contextlib
+from functools import partial
+import inspect
+from typing import TYPE_CHECKING, Any, TypeVar, cast, overload
+import warnings
+import numpy as np
+from pandas._libs import lib
+from pandas.compat.numpy import np_version_gte1p24
+from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
+from pandas.core.dtypes.common import is_bool_dtype, is_integer
+from pandas.core.dtypes.generic import ABCExtensionArray, ABCIndex, ABCMultiIndex, ABCSeries
+from pandas.core.dtypes.inference import iterable_not_string
+if TYPE_CHECKING:
+    from pandas._typing import AnyArrayLike, ArrayLike, Concatenate, NpDtype, P, RandomState, T
+    from pandas import Index
+
+def flatten(line):
+    for element in line:
+        if iterable_not_string(element):
+            yield from flatten(element)
+        else:
+            yield element
+
+def consensus_name_attr(objs):
+    name = objs[0].name
+    for obj in objs[1:]:
+        try:
+            if obj.name != name:
+                name = None
+        except ValueError:
+            name = None
+    return name
+
+def is_bool_indexer(key: Any) -> bool:
+    if isinstance(key, (ABCSeries, np.ndarray, ABCIndex, ABCExtensionArray)) and (not isinstance(key, ABCMultiIndex)):
+        if key.dtype == np.object_:
+            key_array = np.asarray(key)
+            if not lib.is_bool_array(key_array):
+                na_msg = 'Cannot mask with non-boolean array containing NA / NaN values'
+                if lib.is_bool_array(key_array, skipna=True):
+                    raise ValueError(na_msg)
+                return False
+            return True
+        elif is_bool_dtype(key.dtype):
+            return True
+    elif isinstance(key, list):
+        if len(key) > 0:
+            if type(key) is not list:
+                key = list(key)
+            return lib.is_bool_list(key)
+    return False
+
+def cast_scalar_indexer(val):
+    if lib.is_float(val) and val.is_integer():
+        raise IndexError('Indexing with a float is no longer supported. Manually convert to an integer key instead.')
+    return val
+
+def not_none(*args):
+    return (arg for arg in args if arg is not None)
+
+def any_none(*args) -> bool:
+    return any((arg is None for arg in args))
+
+def all_none(*args) -> bool:
+    return all((arg is None for arg in args))
+
+def any_not_none(*args) -> bool:
+    return any((arg is not None for arg in args))
+
+def all_not_none(*args) -> bool:
+    return all((arg is not None for arg in args))
+
+def count_not_none(*args) -> int:
+    return sum((x is not None for x in args))
+
+@overload
+def asarray_tuplesafe(values: ArrayLike | list | tuple | zip, dtype: NpDtype | None=...) -> np.ndarray:
+    ...
+
+@overload
+def asarray_tuplesafe(values: Iterable, dtype: NpDtype | None=...) -> ArrayLike:
+    ...
+
+def asarray_tuplesafe(values: Iterable, dtype: NpDtype | None=None) -> ArrayLike:
+    if not (isinstance(values, (list, tuple)) or hasattr(values, '__array__')):
+        values = list(values)
+    elif isinstance(values, ABCIndex):
+        return values._values
+    elif isinstance(values, ABCSeries):
+        return values._values
+    if isinstance(values, list) and dtype in [np.object_, object]:
+        return construct_1d_object_array_from_listlike(values)
+    try:
+        with warnings.catch_warnings():
+            if not np_version_gte1p24:
+                warnings.simplefilter('ignore', np.VisibleDeprecationWarning)
+            result = np.asarray(values, dtype=dtype)
+    except ValueError:
+        return construct_1d_object_array_from_listlike(values)
+    if issubclass(result.dtype.type, str):
+        result = np.asarray(values, dtype=object)
+    if result.ndim == 2:
+        values = [tuple(x) for x in values]
+        result = construct_1d_object_array_from_listlike(values)
+    return result
+
+def index_labels_to_array(labels: np.ndarray | Iterable, dtype: NpDtype | None=None) -> np.ndarray:
+    if isinstance(labels, (str, tuple)):
+        labels = [labels]
+    if not isinstance(labels, (list, np.ndarray)):
+        try:
+            labels = list(labels)
+        except TypeError:
+            labels = [labels]
+    labels = asarray_tuplesafe(labels, dtype=dtype)
+    return labels
+
+def maybe_make_list(obj):
+    if obj is not None and (not isinstance(obj, (tuple, list))):
+        return [obj]
+    return obj
+
+def maybe_iterable_to_list(obj: Iterable[T] | T) -> Collection[T] | T:
+    if isinstance(obj, abc.Iterable) and (not isinstance(obj, abc.Sized)):
+        return list(obj)
+    obj = cast(Collection, obj)
+    return obj
+
+def is_null_slice(obj) -> bool:
+    return isinstance(obj, slice) and obj.start is None and (obj.stop is None) and (obj.step is None)
+
+def is_empty_slice(obj) -> bool:
+    return isinstance(obj, slice) and obj.start is not None and (obj.stop is not None) and (obj.start == obj.stop)
+
+def is_true_slices(line: abc.Iterable) -> abc.Generator[bool, None, None]:
+    for k in line:
+        yield (isinstance(k, slice) and (not is_null_slice(k)))
+
+def is_full_slice(obj, line: int) -> bool:
+    return isinstance(obj, slice) and obj.start == 0 and (obj.stop == line) and (obj.step is None)
+
+def get_callable_name(obj):
+    if hasattr(obj, '__name__'):
+        return getattr(obj, '__name__')
+    if isinstance(obj, partial):
+        return get_callable_name(obj.func)
+    if callable(obj):
+        return type(obj).__name__
+    return None
+
+def apply_if_callable(maybe_callable, obj, **kwargs):
+    if callable(maybe_callable):
+        return maybe_callable(obj, **kwargs)
+    return maybe_callable
+
+def standardize_mapping(into):
+    if not inspect.isclass(into):
+        if isinstance(into, defaultdict):
+            return partial(defaultdict, into.default_factory)
+        into = type(into)
+    if not issubclass(into, abc.Mapping):
+        raise TypeError(f'unsupported type: {into}')
+    if into == defaultdict:
+        raise TypeError('to_dict() only accepts initialized defaultdicts')
+    return into
+
+@overload
+def random_state(state: np.random.Generator) -> np.random.Generator:
+    ...
+
+@overload
+def random_state(state: int | np.ndarray | np.random.BitGenerator | np.random.RandomState | None) -> np.random.RandomState:
+    ...
+
+def random_state(state: RandomState | None=None):
+    if is_integer(state) or isinstance(state, (np.ndarray, np.random.BitGenerator)):
+        return np.random.RandomState(state)
+    elif isinstance(state, np.random.RandomState):
+        return state
+    elif isinstance(state, np.random.Generator):
+        return state
+    elif state is None:
+        return np.random
+    else:
+        raise ValueError('random_state must be an integer, array-like, a BitGenerator, Generator, a numpy RandomState, or None')
+_T = TypeVar('_T')
+
+@overload
+def pipe(obj: _T, func: Callable[Concatenate[_T, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+    ...
+
+@overload
+def pipe(obj: Any, func: tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T:
+    ...
+
+def pipe(obj: _T, func: Callable[Concatenate[_T, P], T] | tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T:
+    if isinstance(func, tuple):
+        (func_, target) = func
+        if target in kwargs:
+            msg = f'{target} is both the pipe target and a keyword argument'
+            raise ValueError(msg)
+        kwargs[target] = obj
+        return func_(*args, **kwargs)
+    else:
+        return func(obj, *args, **kwargs)
+
+def get_rename_function(mapper):
+
+    def f(x):
+        if x in mapper:
+            return mapper[x]
+        else:
+            return x
+    return f if isinstance(mapper, (abc.Mapping, ABCSeries)) else mapper
+
+def convert_to_list_like(values: Hashable | Iterable | AnyArrayLike) -> list | AnyArrayLike:
+    if isinstance(values, (list, np.ndarray, ABCIndex, ABCSeries, ABCExtensionArray)):
+        return values
+    elif isinstance(values, abc.Iterable) and (not isinstance(values, str)):
+        return list(values)
+    return [values]
+
+@contextlib.contextmanager
+def temp_setattr(obj, attr: str, value, condition: bool=True) -> Generator[None, None, None]:
+    if condition:
+        old_value = getattr(obj, attr)
+        setattr(obj, attr, value)
+    try:
+        yield obj
+    finally:
+        if condition:
+            setattr(obj, attr, old_value)
+
+def require_length_match(data, index: Index) -> None:
+    if len(data) != len(index):
+        raise ValueError(f'Length of values ({len(data)}) does not match length of index ({len(index)})')
+_cython_table = {builtins.sum: 'sum', builtins.max: 'max', builtins.min: 'min', np.all: 'all', np.any: 'any', np.sum: 'sum', np.nansum: 'sum', np.mean: 'mean', np.nanmean: 'mean', np.prod: 'prod', np.nanprod: 'prod', np.std: 'std', np.nanstd: 'std', np.var: 'var', np.nanvar: 'var', np.median: 'median', np.nanmedian: 'median', np.max: 'max', np.nanmax: 'max', np.min: 'min', np.nanmin: 'min', np.cumprod: 'cumprod', np.nancumprod: 'cumprod', np.cumsum: 'cumsum', np.nancumsum: 'cumsum'}
+
+def get_cython_func(arg: Callable) -> str | None:
+    return _cython_table.get(arg)
+
+def fill_missing_names(names: Sequence[Hashable | None]) -> list[Hashable]:
+    return [f'level_{i}' if name is None else name for (i, name) in enumerate(names)]
+
+# File: pandas-main/pandas/core/computation/align.py
+""""""
+from __future__ import annotations
+from functools import partial, wraps
+from typing import TYPE_CHECKING
+import warnings
+import numpy as np
+from pandas._config.config import get_option
+from pandas.errors import PerformanceWarning
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.base import PandasObject
+import pandas.core.common as com
+from pandas.core.computation.common import result_type_many
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+    from pandas._typing import F
+    from pandas.core.generic import NDFrame
+    from pandas.core.indexes.api import Index
+
+def _align_core_single_unary_op(term) -> tuple[partial | type[NDFrame], dict[str, Index] | None]:
+    typ: partial | type[NDFrame]
+    axes: dict[str, Index] | None = None
+    if isinstance(term.value, np.ndarray):
+        typ = partial(np.asanyarray, dtype=term.value.dtype)
+    else:
+        typ = type(term.value)
+        if hasattr(term.value, 'axes'):
+            axes = _zip_axes_from_type(typ, term.value.axes)
+    return (typ, axes)
+
+def _zip_axes_from_type(typ: type[NDFrame], new_axes: Sequence[Index]) -> dict[str, Index]:
+    return {name: new_axes[i] for (i, name) in enumerate(typ._AXIS_ORDERS)}
+
+def _any_pandas_objects(terms) -> bool:
+    return any((isinstance(term.value, PandasObject) for term in terms))
+
+def _filter_special_cases(f) -> Callable[[F], F]:
+
+    @wraps(f)
+    def wrapper(terms):
+        if len(terms) == 1:
+            return _align_core_single_unary_op(terms[0])
+        term_values = (term.value for term in terms)
+        if not _any_pandas_objects(terms):
+            return (result_type_many(*term_values), None)
+        return f(terms)
+    return wrapper
+
+@_filter_special_cases
+def _align_core(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]
+    from pandas import Series
+    ndims = Series(dict(zip(term_index, term_dims)))
+    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, ABCSeries)
+        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].union(itm)
+    for (i, ndim) in ndims.items():
+        for (axis, items) in zip(range(ndim), axes):
+            ti = terms[i].value
+            if hasattr(ti, 'reindex'):
+                transpose = isinstance(ti, ABCSeries) 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 get_option('performance_warnings') and ordm >= 1 and (reindexer_size >= 10000):
+                    w = f'Alignment difference on axis {axis} is larger than an order of magnitude on term {terms[i].name!r}, by more than {ordm:.4g}; performance may suffer.'
+                    warnings.warn(w, category=PerformanceWarning, stacklevel=find_stack_level())
+                obj = ti.reindex(reindexer, axis=axis)
+                terms[i].update(obj)
+        terms[i].update(terms[i].value.values)
+    return (typ, _zip_axes_from_type(typ, axes))
+
+def align_terms(terms):
+    try:
+        terms = list(com.flatten(terms))
+    except TypeError:
+        if isinstance(terms.value, (ABCSeries, ABCDataFrame)):
+            typ = type(terms.value)
+            name = terms.value.name if isinstance(terms.value, ABCSeries) else None
+            return (typ, _zip_axes_from_type(typ, terms.value.axes), name)
+        return (np.result_type(terms.type), None, None)
+    if all((term.is_scalar for term in terms)):
+        return (result_type_many(*(term.value for term in terms)).type, None, None)
+    names = {term.value.name for term in terms if isinstance(term.value, ABCSeries)}
+    name = names.pop() if len(names) == 1 else None
+    (typ, axes) = _align_core(terms)
+    return (typ, axes, name)
+
+def reconstruct_object(typ, obj, axes, dtype, name):
+    try:
+        typ = typ.type
+    except AttributeError:
+        pass
+    res_t = np.result_type(obj.dtype, dtype)
+    if not isinstance(typ, partial) and issubclass(typ, PandasObject):
+        if name is None:
+            return typ(obj, dtype=res_t, **axes)
+        return typ(obj, dtype=res_t, name=name, **axes)
+    if hasattr(res_t, 'type') and typ == np.bool_ and (res_t != np.bool_):
+        ret_value = res_t.type(obj)
+    else:
+        ret_value = typ(obj).astype(res_t)
+        if len(obj.shape) == 1 and len(obj) == 1 and (not isinstance(ret_value, np.ndarray)):
+            ret_value = np.array([ret_value]).astype(res_t)
+    return ret_value
+
+# File: pandas-main/pandas/core/computation/common.py
+from __future__ import annotations
+from functools import reduce
+import numpy as np
+from pandas._config import get_option
+
+def ensure_decoded(s) -> str:
+    if isinstance(s, (np.bytes_, bytes)):
+        s = s.decode(get_option('display.encoding'))
+    return s
+
+def result_type_many(*arrays_and_dtypes):
+    try:
+        return np.result_type(*arrays_and_dtypes)
+    except ValueError:
+        return reduce(np.result_type, arrays_and_dtypes)
+    except TypeError:
+        from pandas.core.dtypes.cast import find_common_type
+        from pandas.core.dtypes.common import is_extension_array_dtype
+        arr_and_dtypes = list(arrays_and_dtypes)
+        (ea_dtypes, non_ea_dtypes) = ([], [])
+        for arr_or_dtype in arr_and_dtypes:
+            if is_extension_array_dtype(arr_or_dtype):
+                ea_dtypes.append(arr_or_dtype)
+            else:
+                non_ea_dtypes.append(arr_or_dtype)
+        if non_ea_dtypes:
+            try:
+                np_dtype = np.result_type(*non_ea_dtypes)
+            except ValueError:
+                np_dtype = reduce(np.result_type, arrays_and_dtypes)
+            return find_common_type(ea_dtypes + [np_dtype])
+        return find_common_type(ea_dtypes)
+
+# File: pandas-main/pandas/core/computation/engines.py
+""""""
+from __future__ import annotations
+import abc
+from typing import TYPE_CHECKING
+from pandas.errors import NumExprClobberingError
+from pandas.core.computation.align import align_terms, reconstruct_object
+from pandas.core.computation.ops import MATHOPS, REDUCTIONS
+from pandas.io.formats import printing
+if TYPE_CHECKING:
+    from pandas.core.computation.expr import Expr
+_ne_builtins = frozenset(MATHOPS + REDUCTIONS)
+
+def _check_ne_builtin_clash(expr: Expr) -> None:
+    names = expr.names
+    overlap = names & _ne_builtins
+    if overlap:
+        s = ', '.join([repr(x) for x in overlap])
+        raise NumExprClobberingError(f'Variables in expression "{expr}" overlap with builtins: ({s})')
+
+class AbstractEngine(metaclass=abc.ABCMeta):
+    has_neg_frac = False
+
+    def __init__(self, expr) -> None:
+        self.expr = expr
+        self.aligned_axes = None
+        self.result_type = None
+        self.result_name = None
+
+    def convert(self) -> str:
+        return printing.pprint_thing(self.expr)
+
+    def evaluate(self) -> object:
+        if not self._is_aligned:
+            (self.result_type, self.aligned_axes, self.result_name) = align_terms(self.expr.terms)
+        res = self._evaluate()
+        return reconstruct_object(self.result_type, res, self.aligned_axes, self.expr.terms.return_type, self.result_name)
+
+    @property
+    def _is_aligned(self) -> bool:
+        return self.aligned_axes is not None and self.result_type is not None
+
+    @abc.abstractmethod
+    def _evaluate(self):
+
+class NumExprEngine(AbstractEngine):
+    has_neg_frac = True
+
+    def _evaluate(self):
+        import numexpr as ne
+        s = self.convert()
+        env = self.expr.env
+        scope = env.full_scope
+        _check_ne_builtin_clash(self.expr)
+        return ne.evaluate(s, local_dict=scope)
+
+class PythonEngine(AbstractEngine):
+    has_neg_frac = False
+
+    def evaluate(self):
+        return self.expr()
+
+    def _evaluate(self) -> None:
+        pass
+ENGINES: dict[str, type[AbstractEngine]] = {'numexpr': NumExprEngine, 'python': PythonEngine}
+
+# File: pandas-main/pandas/core/computation/eval.py
+""""""
+from __future__ import annotations
+import tokenize
+from typing import TYPE_CHECKING, Any
+import warnings
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import validate_bool_kwarg
+from pandas.core.dtypes.common import is_extension_array_dtype
+from pandas.core.computation.engines import ENGINES
+from pandas.core.computation.expr import PARSERS, Expr
+from pandas.core.computation.parsing import tokenize_string
+from pandas.core.computation.scope import ensure_scope
+from pandas.core.generic import NDFrame
+from pandas.io.formats.printing import pprint_thing
+if TYPE_CHECKING:
+    from pandas.core.computation.ops import BinOp
+
+def _check_engine(engine: str | None) -> str:
+    from pandas.core.computation.check import NUMEXPR_INSTALLED
+    from pandas.core.computation.expressions import USE_NUMEXPR
+    if engine is None:
+        engine = 'numexpr' if USE_NUMEXPR else 'python'
+    if engine not in ENGINES:
+        valid_engines = list(ENGINES.keys())
+        raise KeyError(f"Invalid engine '{engine}' passed, valid engines are {valid_engines}")
+    if engine == 'numexpr' and (not NUMEXPR_INSTALLED):
+        raise ImportError("'numexpr' is not installed or an unsupported version. Cannot use engine='numexpr' for query/eval if 'numexpr' is not installed")
+    return engine
+
+def _check_parser(parser: str) -> None:
+    if parser not in PARSERS:
+        raise KeyError(f"Invalid parser '{parser}' passed, valid parsers are {PARSERS.keys()}")
+
+def _check_resolvers(resolvers) -> None:
+    if resolvers is not None:
+        for resolver in resolvers:
+            if not hasattr(resolver, '__getitem__'):
+                name = type(resolver).__name__
+                raise TypeError(f"Resolver of type '{name}' does not implement the __getitem__ method")
+
+def _check_expression(expr) -> None:
+    if not expr:
+        raise ValueError('expr cannot be an empty string')
+
+def _convert_expression(expr) -> str:
+    s = pprint_thing(expr)
+    _check_expression(s)
+    return s
+
+def _check_for_locals(expr: str, stack_level: int, parser: str) -> None:
+    at_top_of_stack = stack_level == 0
+    not_pandas_parser = parser != 'pandas'
+    if not_pandas_parser:
+        msg = "The '@' prefix is only supported by the pandas parser"
+    elif at_top_of_stack:
+        msg = "The '@' prefix is not allowed in top-level eval calls.\nplease refer to your variables by name without the '@' prefix."
+    if at_top_of_stack or not_pandas_parser:
+        for (toknum, tokval) in tokenize_string(expr):
+            if toknum == tokenize.OP and tokval == '@':
+                raise SyntaxError(msg)
+
+def eval(expr: str | BinOp, parser: str='pandas', engine: str | None=None, local_dict=None, global_dict=None, resolvers=(), level: int=0, target=None, inplace: bool=False) -> Any:
+    inplace = validate_bool_kwarg(inplace, 'inplace')
+    exprs: list[str | BinOp]
+    if isinstance(expr, str):
+        _check_expression(expr)
+        exprs = [e.strip() for e in expr.splitlines() if e.strip() != '']
+    else:
+        exprs = [expr]
+    multi_line = len(exprs) > 1
+    if multi_line and target is None:
+        raise ValueError('multi-line expressions are only valid in the context of data, use DataFrame.eval')
+    engine = _check_engine(engine)
+    _check_parser(parser)
+    _check_resolvers(resolvers)
+    ret = None
+    first_expr = True
+    target_modified = False
+    for expr in exprs:
+        expr = _convert_expression(expr)
+        _check_for_locals(expr, level, parser)
+        env = ensure_scope(level + 1, global_dict=global_dict, local_dict=local_dict, resolvers=resolvers, target=target)
+        parsed_expr = Expr(expr, engine=engine, parser=parser, env=env)
+        if engine == 'numexpr' and (is_extension_array_dtype(parsed_expr.terms.return_type) or (getattr(parsed_expr.terms, 'operand_types', None) is not None and any((is_extension_array_dtype(elem) for elem in parsed_expr.terms.operand_types)))):
+            warnings.warn("Engine has switched to 'python' because numexpr does not support extension array dtypes. Please set your engine to python manually.", RuntimeWarning, stacklevel=find_stack_level())
+            engine = 'python'
+        eng = ENGINES[engine]
+        eng_inst = eng(parsed_expr)
+        ret = eng_inst.evaluate()
+        if parsed_expr.assigner is None:
+            if multi_line:
+                raise ValueError('Multi-line expressions are only valid if all expressions contain an assignment')
+            if inplace:
+                raise ValueError('Cannot operate inplace if there is no assignment')
+        assigner = parsed_expr.assigner
+        if env.target is not None and assigner is not None:
+            target_modified = True
+            if not inplace and first_expr:
+                try:
+                    target = env.target
+                    if isinstance(target, NDFrame):
+                        target = target.copy(deep=False)
+                    else:
+                        target = target.copy()
+                except AttributeError as err:
+                    raise ValueError('Cannot return a copy of the target') from err
+            else:
+                target = env.target
+            try:
+                if inplace and isinstance(target, NDFrame):
+                    target.loc[:, assigner] = ret
+                else:
+                    target[assigner] = ret
+            except (TypeError, IndexError) as err:
+                raise ValueError('Cannot assign expression output to target') from err
+            if not resolvers:
+                resolvers = ({assigner: ret},)
+            else:
+                for resolver in resolvers:
+                    if assigner in resolver:
+                        resolver[assigner] = ret
+                        break
+                else:
+                    resolvers += ({assigner: ret},)
+            ret = None
+            first_expr = False
+    if inplace is False:
+        return target if target_modified else ret
+
+# File: pandas-main/pandas/core/computation/expr.py
+""""""
+from __future__ import annotations
+import ast
+from functools import partial, reduce
+from keyword import iskeyword
+import tokenize
+from typing import TYPE_CHECKING, ClassVar, TypeVar
+import numpy as np
+from pandas.errors import UndefinedVariableError
+import pandas.core.common as com
+from pandas.core.computation.ops import ARITH_OPS_SYMS, BOOL_OPS_SYMS, CMP_OPS_SYMS, LOCAL_TAG, MATHOPS, REDUCTIONS, UNARY_OPS_SYMS, BinOp, Constant, FuncNode, Op, Term, UnaryOp, is_term
+from pandas.core.computation.parsing import clean_backtick_quoted_toks, tokenize_string
+from pandas.core.computation.scope import Scope
+from pandas.io.formats import printing
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+def _rewrite_assign(tok: tuple[int, str]) -> tuple[int, str]:
+    (toknum, tokval) = tok
+    return (toknum, '==' if tokval == '=' else tokval)
+
+def _replace_booleans(tok: tuple[int, str]) -> tuple[int, str]:
+    (toknum, tokval) = tok
+    if toknum == tokenize.OP:
+        if tokval == '&':
+            return (tokenize.NAME, 'and')
+        elif tokval == '|':
+            return (tokenize.NAME, 'or')
+        return (toknum, tokval)
+    return (toknum, tokval)
+
+def _replace_locals(tok: tuple[int, str]) -> tuple[int, str]:
+    (toknum, tokval) = tok
+    if toknum == tokenize.OP and tokval == '@':
+        return (tokenize.OP, LOCAL_TAG)
+    return (toknum, tokval)
+
+def _compose2(f, g):
+    return lambda *args, **kwargs: f(g(*args, **kwargs))
+
+def _compose(*funcs):
+    assert len(funcs) > 1, 'At least 2 callables must be passed to compose'
+    return reduce(_compose2, funcs)
+
+def _preparse(source: str, f=_compose(_replace_locals, _replace_booleans, _rewrite_assign, clean_backtick_quoted_toks)) -> str:
+    assert callable(f), 'f must be callable'
+    return tokenize.untokenize((f(x) for x in tokenize_string(source)))
+
+def _is_type(t):
+    return lambda x: isinstance(x.value, t)
+_is_list = _is_type(list)
+_is_str = _is_type(str)
+_all_nodes = frozenset((node for node in (getattr(ast, name) for name in dir(ast)) if isinstance(node, type) and issubclass(node, ast.AST)))
+
+def _filter_nodes(superclass, all_nodes=_all_nodes):
+    node_names = (node.__name__ for node in all_nodes if issubclass(node, superclass))
+    return frozenset(node_names)
+_all_node_names = frozenset((x.__name__ for x in _all_nodes))
+_mod_nodes = _filter_nodes(ast.mod)
+_stmt_nodes = _filter_nodes(ast.stmt)
+_expr_nodes = _filter_nodes(ast.expr)
+_expr_context_nodes = _filter_nodes(ast.expr_context)
+_boolop_nodes = _filter_nodes(ast.boolop)
+_operator_nodes = _filter_nodes(ast.operator)
+_unary_op_nodes = _filter_nodes(ast.unaryop)
+_cmp_op_nodes = _filter_nodes(ast.cmpop)
+_comprehension_nodes = _filter_nodes(ast.comprehension)
+_handler_nodes = _filter_nodes(ast.excepthandler)
+_arguments_nodes = _filter_nodes(ast.arguments)
+_keyword_nodes = _filter_nodes(ast.keyword)
+_alias_nodes = _filter_nodes(ast.alias)
+_hacked_nodes = frozenset(['Assign', 'Module', 'Expr'])
+_unsupported_expr_nodes = frozenset(['Yield', 'GeneratorExp', 'IfExp', 'DictComp', 'SetComp', 'Repr', 'Lambda', 'Set', 'AST', 'Is', 'IsNot'])
+_unsupported_nodes = (_stmt_nodes | _mod_nodes | _handler_nodes | _arguments_nodes | _keyword_nodes | _alias_nodes | _expr_context_nodes | _unsupported_expr_nodes) - _hacked_nodes
+_base_supported_nodes = _all_node_names - _unsupported_nodes | _hacked_nodes
+intersection = _unsupported_nodes & _base_supported_nodes
+_msg = f'cannot both support and not support {intersection}'
+assert not intersection, _msg
+
+def _node_not_implemented(node_name: str) -> Callable[..., None]:
+
+    def f(self, *args, **kwargs):
+        raise NotImplementedError(f"'{node_name}' nodes are not implemented")
+    return f
+_T = TypeVar('_T')
+
+def disallow(nodes: set[str]) -> Callable[[type[_T]], type[_T]]:
+
+    def disallowed(cls: type[_T]) -> type[_T]:
+        cls.unsupported_nodes = ()
+        for node in nodes:
+            new_method = _node_not_implemented(node)
+            name = f'visit_{node}'
+            cls.unsupported_nodes += (name,)
+            setattr(cls, name, new_method)
+        return cls
+    return disallowed
+
+def _op_maker(op_class, op_symbol):
+
+    def f(self, node, *args, **kwargs):
+        return partial(op_class, op_symbol, *args, **kwargs)
+    return f
+_op_classes = {'binary': BinOp, 'unary': UnaryOp}
+
+def add_ops(op_classes):
+
+    def f(cls):
+        for (op_attr_name, op_class) in op_classes.items():
+            ops = getattr(cls, f'{op_attr_name}_ops')
+            ops_map = getattr(cls, f'{op_attr_name}_op_nodes_map')
+            for op in ops:
+                op_node = ops_map[op]
+                if op_node is not None:
+                    made_op = _op_maker(op_class, op)
+                    setattr(cls, f'visit_{op_node}', made_op)
+        return cls
+    return f
+
+@disallow(_unsupported_nodes)
+@add_ops(_op_classes)
+class BaseExprVisitor(ast.NodeVisitor):
+    const_type: ClassVar[type[Term]] = Constant
+    term_type: ClassVar[type[Term]] = Term
+    binary_ops = CMP_OPS_SYMS + BOOL_OPS_SYMS + ARITH_OPS_SYMS
+    binary_op_nodes = ('Gt', 'Lt', 'GtE', 'LtE', 'Eq', 'NotEq', 'In', 'NotIn', 'BitAnd', 'BitOr', 'And', 'Or', 'Add', 'Sub', 'Mult', 'Div', 'Pow', 'FloorDiv', 'Mod')
+    binary_op_nodes_map = dict(zip(binary_ops, binary_op_nodes))
+    unary_ops = UNARY_OPS_SYMS
+    unary_op_nodes = ('UAdd', 'USub', 'Invert', 'Not')
+    unary_op_nodes_map = dict(zip(unary_ops, unary_op_nodes))
+    rewrite_map = {ast.Eq: ast.In, ast.NotEq: ast.NotIn, ast.In: ast.In, ast.NotIn: ast.NotIn}
+    unsupported_nodes: tuple[str, ...]
+
+    def __init__(self, env, engine, parser, preparser=_preparse) -> None:
+        self.env = env
+        self.engine = engine
+        self.parser = parser
+        self.preparser = preparser
+        self.assigner = None
+
+    def visit(self, node, **kwargs):
+        if isinstance(node, str):
+            clean = self.preparser(node)
+            try:
+                node = ast.fix_missing_locations(ast.parse(clean))
+            except SyntaxError as e:
+                if any((iskeyword(x) for x in clean.split())):
+                    e.msg = 'Python keyword not valid identifier in numexpr query'
+                raise e
+        method = f'visit_{type(node).__name__}'
+        visitor = getattr(self, method)
+        return visitor(node, **kwargs)
+
+    def visit_Module(self, node, **kwargs):
+        if len(node.body) != 1:
+            raise SyntaxError('only a single expression is allowed')
+        expr = node.body[0]
+        return self.visit(expr, **kwargs)
+
+    def visit_Expr(self, node, **kwargs):
+        return self.visit(node.value, **kwargs)
+
+    def _rewrite_membership_op(self, node, left, right):
+        op_instance = node.op
+        op_type = type(op_instance)
+        if is_term(left) and is_term(right) and (op_type in self.rewrite_map):
+            (left_list, right_list) = map(_is_list, (left, right))
+            (left_str, right_str) = map(_is_str, (left, right))
+            if left_list or right_list or left_str or right_str:
+                op_instance = self.rewrite_map[op_type]()
+            if right_str:
+                name = self.env.add_tmp([right.value])
+                right = self.term_type(name, self.env)
+            if left_str:
+                name = self.env.add_tmp([left.value])
+                left = self.term_type(name, self.env)
+        op = self.visit(op_instance)
+        return (op, op_instance, left, right)
+
+    def _maybe_transform_eq_ne(self, node, left=None, right=None):
+        if left is None:
+            left = self.visit(node.left, side='left')
+        if right is None:
+            right = self.visit(node.right, side='right')
+        (op, op_class, left, right) = self._rewrite_membership_op(node, left, right)
+        return (op, op_class, left, right)
+
+    def _maybe_downcast_constants(self, left, right):
+        f32 = np.dtype(np.float32)
+        if left.is_scalar and hasattr(left, 'value') and (not right.is_scalar) and (right.return_type == f32):
+            name = self.env.add_tmp(np.float32(left.value))
+            left = self.term_type(name, self.env)
+        if right.is_scalar and hasattr(right, 'value') and (not left.is_scalar) and (left.return_type == f32):
+            name = self.env.add_tmp(np.float32(right.value))
+            right = self.term_type(name, self.env)
+        return (left, right)
+
+    def _maybe_eval(self, binop, eval_in_python):
+        return binop.evaluate(self.env, self.engine, self.parser, self.term_type, eval_in_python)
+
+    def _maybe_evaluate_binop(self, op, op_class, lhs, rhs, eval_in_python=('in', 'not in'), maybe_eval_in_python=('==', '!=', '<', '>', '<=', '>=')):
+        res = op(lhs, rhs)
+        if res.has_invalid_return_type:
+            raise TypeError(f"unsupported operand type(s) for {res.op}: '{lhs.type}' and '{rhs.type}'")
+        if self.engine != 'pytables' and (res.op in CMP_OPS_SYMS and getattr(lhs, 'is_datetime', False) or getattr(rhs, 'is_datetime', False)):
+            return self._maybe_eval(res, self.binary_ops)
+        if res.op in eval_in_python:
+            return self._maybe_eval(res, eval_in_python)
+        elif self.engine != 'pytables':
+            if getattr(lhs, 'return_type', None) == object or getattr(rhs, 'return_type', None) == object:
+                return self._maybe_eval(res, eval_in_python + maybe_eval_in_python)
+        return res
+
+    def visit_BinOp(self, node, **kwargs):
+        (op, op_class, left, right) = self._maybe_transform_eq_ne(node)
+        (left, right) = self._maybe_downcast_constants(left, right)
+        return self._maybe_evaluate_binop(op, op_class, left, right)
+
+    def visit_UnaryOp(self, node, **kwargs):
+        op = self.visit(node.op)
+        operand = self.visit(node.operand)
+        return op(operand)
+
+    def visit_Name(self, node, **kwargs) -> Term:
+        return self.term_type(node.id, self.env, **kwargs)
+
+    def visit_NameConstant(self, node, **kwargs) -> Term:
+        return self.const_type(node.value, self.env)
+
+    def visit_Num(self, node, **kwargs) -> Term:
+        return self.const_type(node.value, self.env)
+
+    def visit_Constant(self, node, **kwargs) -> Term:
+        return self.const_type(node.value, self.env)
+
+    def visit_Str(self, node, **kwargs) -> Term:
+        name = self.env.add_tmp(node.s)
+        return self.term_type(name, self.env)
+
+    def visit_List(self, node, **kwargs) -> Term:
+        name = self.env.add_tmp([self.visit(e)(self.env) for e in node.elts])
+        return self.term_type(name, self.env)
+    visit_Tuple = visit_List
+
+    def visit_Index(self, node, **kwargs):
+        return self.visit(node.value)
+
+    def visit_Subscript(self, node, **kwargs) -> Term:
+        from pandas import eval as pd_eval
+        value = self.visit(node.value)
+        slobj = self.visit(node.slice)
+        result = pd_eval(slobj, local_dict=self.env, engine=self.engine, parser=self.parser)
+        try:
+            v = value.value[result]
+        except AttributeError:
+            lhs = pd_eval(value, local_dict=self.env, engine=self.engine, parser=self.parser)
+            v = lhs[result]
+        name = self.env.add_tmp(v)
+        return self.term_type(name, env=self.env)
+
+    def visit_Slice(self, node, **kwargs) -> slice:
+        lower = node.lower
+        if lower is not None:
+            lower = self.visit(lower).value
+        upper = node.upper
+        if upper is not None:
+            upper = self.visit(upper).value
+        step = node.step
+        if step is not None:
+            step = self.visit(step).value
+        return slice(lower, upper, step)
+
+    def visit_Assign(self, node, **kwargs):
+        if len(node.targets) != 1:
+            raise SyntaxError('can only assign a single expression')
+        if not isinstance(node.targets[0], ast.Name):
+            raise SyntaxError('left hand side of an assignment must be a single name')
+        if self.env.target is None:
+            raise ValueError('cannot assign without a target object')
+        try:
+            assigner = self.visit(node.targets[0], **kwargs)
+        except UndefinedVariableError:
+            assigner = node.targets[0].id
+        self.assigner = getattr(assigner, 'name', assigner)
+        if self.assigner is None:
+            raise SyntaxError('left hand side of an assignment must be a single resolvable name')
+        return self.visit(node.value, **kwargs)
+
+    def visit_Attribute(self, node, **kwargs):
+        attr = node.attr
+        value = node.value
+        ctx = node.ctx
+        if isinstance(ctx, ast.Load):
+            resolved = self.visit(value).value
+            try:
+                v = getattr(resolved, attr)
+                name = self.env.add_tmp(v)
+                return self.term_type(name, self.env)
+            except AttributeError:
+                if isinstance(value, ast.Name) and value.id == attr:
+                    return resolved
+                raise
+        raise ValueError(f'Invalid Attribute context {type(ctx).__name__}')
+
+    def visit_Call(self, node, side=None, **kwargs):
+        if isinstance(node.func, ast.Attribute) and node.func.attr != '__call__':
+            res = self.visit_Attribute(node.func)
+        elif not isinstance(node.func, ast.Name):
+            raise TypeError('Only named functions are supported')
+        else:
+            try:
+                res = self.visit(node.func)
+            except UndefinedVariableError:
+                try:
+                    res = FuncNode(node.func.id)
+                except ValueError:
+                    raise
+        if res is None:
+            raise ValueError(f'Invalid function call {node.func.id}')
+        if hasattr(res, 'value'):
+            res = res.value
+        if isinstance(res, FuncNode):
+            new_args = [self.visit(arg) for arg in node.args]
+            if node.keywords:
+                raise TypeError(f'Function "{res.name}" does not support keyword arguments')
+            return res(*new_args)
+        else:
+            new_args = [self.visit(arg)(self.env) for arg in node.args]
+            for key in node.keywords:
+                if not isinstance(key, ast.keyword):
+                    raise ValueError(f"keyword error in function call '{node.func.id}'")
+                if key.arg:
+                    kwargs[key.arg] = self.visit(key.value)(self.env)
+            name = self.env.add_tmp(res(*new_args, **kwargs))
+            return self.term_type(name=name, env=self.env)
+
+    def translate_In(self, op):
+        return op
+
+    def visit_Compare(self, node, **kwargs):
+        ops = node.ops
+        comps = node.comparators
+        if len(comps) == 1:
+            op = self.translate_In(ops[0])
+            binop = ast.BinOp(op=op, left=node.left, right=comps[0])
+            return self.visit(binop)
+        left = node.left
+        values = []
+        for (op, comp) in zip(ops, comps):
+            new_node = self.visit(ast.Compare(comparators=[comp], left=left, ops=[self.translate_In(op)]))
+            left = comp
+            values.append(new_node)
+        return self.visit(ast.BoolOp(op=ast.And(), values=values))
+
+    def _try_visit_binop(self, bop):
+        if isinstance(bop, (Op, Term)):
+            return bop
+        return self.visit(bop)
+
+    def visit_BoolOp(self, node, **kwargs):
+
+        def visitor(x, y):
+            lhs = self._try_visit_binop(x)
+            rhs = self._try_visit_binop(y)
+            (op, op_class, lhs, rhs) = self._maybe_transform_eq_ne(node, lhs, rhs)
+            return self._maybe_evaluate_binop(op, node.op, lhs, rhs)
+        operands = node.values
+        return reduce(visitor, operands)
+_python_not_supported = frozenset(['Dict', 'BoolOp', 'In', 'NotIn'])
+_numexpr_supported_calls = frozenset(REDUCTIONS + MATHOPS)
+
+@disallow((_unsupported_nodes | _python_not_supported) - (_boolop_nodes | frozenset(['BoolOp', 'Attribute', 'In', 'NotIn', 'Tuple'])))
+class PandasExprVisitor(BaseExprVisitor):
+
+    def __init__(self, env, engine, parser, preparser=partial(_preparse, f=_compose(_replace_locals, _replace_booleans, clean_backtick_quoted_toks))) -> None:
+        super().__init__(env, engine, parser, preparser)
+
+@disallow(_unsupported_nodes | _python_not_supported | frozenset(['Not']))
+class PythonExprVisitor(BaseExprVisitor):
+
+    def __init__(self, env, engine, parser, preparser=lambda source, f=None: source) -> None:
+        super().__init__(env, engine, parser, preparser=preparser)
+
+class Expr:
+    env: Scope
+    engine: str
+    parser: str
+
+    def __init__(self, expr, engine: str='numexpr', parser: str='pandas', env: Scope | None=None, level: int=0) -> None:
+        self.expr = expr
+        self.env = env or Scope(level=level + 1)
+        self.engine = engine
+        self.parser = parser
+        self._visitor = PARSERS[parser](self.env, self.engine, self.parser)
+        self.terms = self.parse()
+
+    @property
+    def assigner(self):
+        return getattr(self._visitor, 'assigner', None)
+
+    def __call__(self):
+        return self.terms(self.env)
+
+    def __repr__(self) -> str:
+        return printing.pprint_thing(self.terms)
+
+    def __len__(self) -> int:
+        return len(self.expr)
+
+    def parse(self):
+        return self._visitor.visit(self.expr)
+
+    @property
+    def names(self):
+        if is_term(self.terms):
+            return frozenset([self.terms.name])
+        return frozenset((term.name for term in com.flatten(self.terms)))
+PARSERS = {'python': PythonExprVisitor, 'pandas': PandasExprVisitor}
+
+# File: pandas-main/pandas/core/computation/expressions.py
+""""""
+from __future__ import annotations
+import operator
+from typing import TYPE_CHECKING
+import warnings
+import numpy as np
+from pandas._config import get_option
+from pandas.util._exceptions import find_stack_level
+from pandas.core import roperator
+from pandas.core.computation.check import NUMEXPR_INSTALLED
+if NUMEXPR_INSTALLED:
+    import numexpr as ne
+if TYPE_CHECKING:
+    from pandas._typing import FuncType
+_TEST_MODE: bool | None = None
+_TEST_RESULT: list[bool] = []
+USE_NUMEXPR = NUMEXPR_INSTALLED
+_evaluate: FuncType | None = None
+_where: FuncType | None = None
+_ALLOWED_DTYPES = {'evaluate': {'int64', 'int32', 'float64', 'float32', 'bool'}, 'where': {'int64', 'float64', 'bool'}}
+_MIN_ELEMENTS = 1000000
+
+def set_use_numexpr(v: bool=True) -> None:
+    global USE_NUMEXPR
+    if NUMEXPR_INSTALLED:
+        USE_NUMEXPR = v
+    global _evaluate, _where
+    _evaluate = _evaluate_numexpr if USE_NUMEXPR else _evaluate_standard
+    _where = _where_numexpr if USE_NUMEXPR else _where_standard
+
+def set_numexpr_threads(n=None) -> None:
+    if NUMEXPR_INSTALLED and USE_NUMEXPR:
+        if n is None:
+            n = ne.detect_number_of_cores()
+        ne.set_num_threads(n)
+
+def _evaluate_standard(op, op_str, a, b):
+    if _TEST_MODE:
+        _store_test_result(False)
+    return op(a, b)
+
+def _can_use_numexpr(op, op_str, a, b, dtype_check) -> bool:
+    if op_str is not None:
+        if a.size > _MIN_ELEMENTS:
+            dtypes: set[str] = set()
+            for o in [a, b]:
+                if hasattr(o, 'dtype'):
+                    dtypes |= {o.dtype.name}
+            if not len(dtypes) or _ALLOWED_DTYPES[dtype_check] >= dtypes:
+                return True
+    return False
+
+def _evaluate_numexpr(op, op_str, a, b):
+    result = None
+    if _can_use_numexpr(op, op_str, a, b, 'evaluate'):
+        is_reversed = op.__name__.strip('_').startswith('r')
+        if is_reversed:
+            (a, b) = (b, a)
+        a_value = a
+        b_value = b
+        try:
+            result = ne.evaluate(f'a_value {op_str} b_value', local_dict={'a_value': a_value, 'b_value': b_value}, casting='safe')
+        except TypeError:
+            pass
+        except NotImplementedError:
+            if _bool_arith_fallback(op_str, a, b):
+                pass
+            else:
+                raise
+        if is_reversed:
+            (a, b) = (b, a)
+    if _TEST_MODE:
+        _store_test_result(result is not None)
+    if result is None:
+        result = _evaluate_standard(op, op_str, a, b)
+    return result
+_op_str_mapping = {operator.add: '+', roperator.radd: '+', operator.mul: '*', roperator.rmul: '*', operator.sub: '-', roperator.rsub: '-', operator.truediv: '/', roperator.rtruediv: '/', operator.floordiv: None, roperator.rfloordiv: None, operator.mod: None, roperator.rmod: None, operator.pow: '**', roperator.rpow: '**', operator.eq: '==', operator.ne: '!=', operator.le: '<=', operator.lt: '<', operator.ge: '>=', operator.gt: '>', operator.and_: '&', roperator.rand_: '&', operator.or_: '|', roperator.ror_: '|', operator.xor: '^', roperator.rxor: '^', divmod: None, roperator.rdivmod: None}
+
+def _where_standard(cond, a, b):
+    return np.where(cond, a, b)
+
+def _where_numexpr(cond, a, b):
+    result = None
+    if _can_use_numexpr(None, 'where', a, b, 'where'):
+        result = ne.evaluate('where(cond_value, a_value, b_value)', local_dict={'cond_value': cond, 'a_value': a, 'b_value': b}, casting='safe')
+    if result is None:
+        result = _where_standard(cond, a, b)
+    return result
+set_use_numexpr(get_option('compute.use_numexpr'))
+
+def _has_bool_dtype(x):
+    try:
+        return x.dtype == bool
+    except AttributeError:
+        return isinstance(x, (bool, np.bool_))
+_BOOL_OP_UNSUPPORTED = {'+': '|', '*': '&', '-': '^'}
+
+def _bool_arith_fallback(op_str, a, b) -> bool:
+    if _has_bool_dtype(a) and _has_bool_dtype(b):
+        if op_str in _BOOL_OP_UNSUPPORTED:
+            warnings.warn(f'evaluating in Python space because the {op_str!r} operator is not supported by numexpr for the bool dtype, use {_BOOL_OP_UNSUPPORTED[op_str]!r} instead.', stacklevel=find_stack_level())
+            return True
+    return False
+
+def evaluate(op, a, b, use_numexpr: bool=True):
+    op_str = _op_str_mapping[op]
+    if op_str is not None:
+        if use_numexpr:
+            return _evaluate(op, op_str, a, b)
+    return _evaluate_standard(op, op_str, a, b)
+
+def where(cond, a, b, use_numexpr: bool=True):
+    assert _where is not None
+    return _where(cond, a, b) if use_numexpr else _where_standard(cond, a, b)
+
+def set_test_mode(v: bool=True) -> None:
+    global _TEST_MODE, _TEST_RESULT
+    _TEST_MODE = v
+    _TEST_RESULT = []
+
+def _store_test_result(used_numexpr: bool) -> None:
+    if used_numexpr:
+        _TEST_RESULT.append(used_numexpr)
+
+def get_test_result() -> list[bool]:
+    global _TEST_RESULT
+    res = _TEST_RESULT
+    _TEST_RESULT = []
+    return res
+
+# File: pandas-main/pandas/core/computation/ops.py
+""""""
+from __future__ import annotations
+from datetime import datetime
+from functools import partial
+import operator
+from typing import TYPE_CHECKING, Literal
+import numpy as np
+from pandas._libs.tslibs import Timestamp
+from pandas.core.dtypes.common import is_list_like, is_scalar
+import pandas.core.common as com
+from pandas.core.computation.common import ensure_decoded, result_type_many
+from pandas.core.computation.scope import DEFAULT_GLOBALS
+from pandas.io.formats.printing import pprint_thing, pprint_thing_encoded
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Iterator
+REDUCTIONS = ('sum', 'prod', 'min', 'max')
+_unary_math_ops = ('sin', 'cos', 'tan', 'exp', 'log', 'expm1', 'log1p', 'sqrt', 'sinh', 'cosh', 'tanh', 'arcsin', 'arccos', 'arctan', 'arccosh', 'arcsinh', 'arctanh', 'abs', 'log10', 'floor', 'ceil')
+_binary_math_ops = ('arctan2',)
+MATHOPS = _unary_math_ops + _binary_math_ops
+LOCAL_TAG = '__pd_eval_local_'
+
+class Term:
+
+    def __new__(cls, name, env, side=None, encoding=None):
+        klass = Constant if not isinstance(name, str) else cls
+        supr_new = super(Term, klass).__new__
+        return supr_new(klass)
+    is_local: bool
+
+    def __init__(self, name, env, side=None, encoding=None) -> None:
+        self._name = name
+        self.env = env
+        self.side = side
+        tname = str(name)
+        self.is_local = tname.startswith(LOCAL_TAG) or tname in DEFAULT_GLOBALS
+        self._value = self._resolve_name()
+        self.encoding = encoding
+
+    @property
+    def local_name(self) -> str:
+        return self.name.replace(LOCAL_TAG, '')
+
+    def __repr__(self) -> str:
+        return pprint_thing(self.name)
+
+    def __call__(self, *args, **kwargs):
+        return self.value
+
+    def evaluate(self, *args, **kwargs) -> Term:
+        return self
+
+    def _resolve_name(self):
+        local_name = str(self.local_name)
+        is_local = self.is_local
+        if local_name in self.env.scope and isinstance(self.env.scope[local_name], type):
+            is_local = False
+        res = self.env.resolve(local_name, is_local=is_local)
+        self.update(res)
+        if hasattr(res, 'ndim') and isinstance(res.ndim, int) and (res.ndim > 2):
+            raise NotImplementedError('N-dimensional objects, where N > 2, are not supported with eval')
+        return res
+
+    def update(self, value) -> None:
+        key = self.name
+        if isinstance(key, str):
+            self.env.swapkey(self.local_name, key, new_value=value)
+        self.value = value
+
+    @property
+    def is_scalar(self) -> bool:
+        return is_scalar(self._value)
+
+    @property
+    def type(self):
+        try:
+            return self._value.values.dtype
+        except AttributeError:
+            try:
+                return self._value.dtype
+            except AttributeError:
+                return type(self._value)
+    return_type = type
+
+    @property
+    def raw(self) -> str:
+        return f'{type(self).__name__}(name={self.name!r}, type={self.type})'
+
+    @property
+    def is_datetime(self) -> bool:
+        try:
+            t = self.type.type
+        except AttributeError:
+            t = self.type
+        return issubclass(t, (datetime, np.datetime64))
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, new_value) -> None:
+        self._value = new_value
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def ndim(self) -> int:
+        return self._value.ndim
+
+class Constant(Term):
+
+    def _resolve_name(self):
+        return self._name
+
+    @property
+    def name(self):
+        return self.value
+
+    def __repr__(self) -> str:
+        return repr(self.name)
+_bool_op_map = {'not': '~', 'and': '&', 'or': '|'}
+
+class Op:
+    op: str
+
+    def __init__(self, op: str, operands: Iterable[Term | Op], encoding=None) -> None:
+        self.op = _bool_op_map.get(op, op)
+        self.operands = operands
+        self.encoding = encoding
+
+    def __iter__(self) -> Iterator:
+        return iter(self.operands)
+
+    def __repr__(self) -> str:
+        parened = (f'({pprint_thing(opr)})' for opr in self.operands)
+        return pprint_thing(f' {self.op} '.join(parened))
+
+    @property
+    def return_type(self):
+        if self.op in CMP_OPS_SYMS + BOOL_OPS_SYMS:
+            return np.bool_
+        return result_type_many(*(term.type for term in com.flatten(self)))
+
+    @property
+    def has_invalid_return_type(self) -> bool:
+        types = self.operand_types
+        obj_dtype_set = frozenset([np.dtype('object')])
+        return self.return_type == object and types - obj_dtype_set
+
+    @property
+    def operand_types(self):
+        return frozenset((term.type for term in com.flatten(self)))
+
+    @property
+    def is_scalar(self) -> bool:
+        return all((operand.is_scalar for operand in self.operands))
+
+    @property
+    def is_datetime(self) -> bool:
+        try:
+            t = self.return_type.type
+        except AttributeError:
+            t = self.return_type
+        return issubclass(t, (datetime, np.datetime64))
+
+def _in(x, y):
+    try:
+        return x.isin(y)
+    except AttributeError:
+        if is_list_like(x):
+            try:
+                return y.isin(x)
+            except AttributeError:
+                pass
+        return x in y
+
+def _not_in(x, y):
+    try:
+        return ~x.isin(y)
+    except AttributeError:
+        if is_list_like(x):
+            try:
+                return ~y.isin(x)
+            except AttributeError:
+                pass
+        return x not in y
+CMP_OPS_SYMS = ('>', '<', '>=', '<=', '==', '!=', 'in', 'not in')
+_cmp_ops_funcs = (operator.gt, operator.lt, operator.ge, operator.le, operator.eq, operator.ne, _in, _not_in)
+_cmp_ops_dict = dict(zip(CMP_OPS_SYMS, _cmp_ops_funcs))
+BOOL_OPS_SYMS = ('&', '|', 'and', 'or')
+_bool_ops_funcs = (operator.and_, operator.or_, operator.and_, operator.or_)
+_bool_ops_dict = dict(zip(BOOL_OPS_SYMS, _bool_ops_funcs))
+ARITH_OPS_SYMS = ('+', '-', '*', '/', '**', '//', '%')
+_arith_ops_funcs = (operator.add, operator.sub, operator.mul, operator.truediv, operator.pow, operator.floordiv, operator.mod)
+_arith_ops_dict = dict(zip(ARITH_OPS_SYMS, _arith_ops_funcs))
+_binary_ops_dict = {}
+for d in (_cmp_ops_dict, _bool_ops_dict, _arith_ops_dict):
+    _binary_ops_dict.update(d)
+
+def is_term(obj) -> bool:
+    return isinstance(obj, Term)
+
+class BinOp(Op):
+
+    def __init__(self, op: str, lhs, rhs) -> None:
+        super().__init__(op, (lhs, rhs))
+        self.lhs = lhs
+        self.rhs = rhs
+        self._disallow_scalar_only_bool_ops()
+        self.convert_values()
+        try:
+            self.func = _binary_ops_dict[op]
+        except KeyError as err:
+            keys = list(_binary_ops_dict.keys())
+            raise ValueError(f'Invalid binary operator {op!r}, valid operators are {keys}') from err
+
+    def __call__(self, env):
+        left = self.lhs(env)
+        right = self.rhs(env)
+        return self.func(left, right)
+
+    def evaluate(self, env, engine: str, parser, term_type, eval_in_python):
+        if engine == 'python':
+            res = self(env)
+        else:
+            left = self.lhs.evaluate(env, engine=engine, parser=parser, term_type=term_type, eval_in_python=eval_in_python)
+            right = self.rhs.evaluate(env, engine=engine, parser=parser, term_type=term_type, eval_in_python=eval_in_python)
+            if self.op in eval_in_python:
+                res = self.func(left.value, right.value)
+            else:
+                from pandas.core.computation.eval import eval
+                res = eval(self, local_dict=env, engine=engine, parser=parser)
+        name = env.add_tmp(res)
+        return term_type(name, env=env)
+
+    def convert_values(self) -> None:
+
+        def stringify(value):
+            encoder: Callable
+            if self.encoding is not None:
+                encoder = partial(pprint_thing_encoded, encoding=self.encoding)
+            else:
+                encoder = pprint_thing
+            return encoder(value)
+        (lhs, rhs) = (self.lhs, self.rhs)
+        if is_term(lhs) and lhs.is_datetime and is_term(rhs) and rhs.is_scalar:
+            v = rhs.value
+            if isinstance(v, (int, float)):
+                v = stringify(v)
+            v = Timestamp(ensure_decoded(v))
+            if v.tz is not None:
+                v = v.tz_convert('UTC')
+            self.rhs.update(v)
+        if is_term(rhs) and rhs.is_datetime and is_term(lhs) and lhs.is_scalar:
+            v = lhs.value
+            if isinstance(v, (int, float)):
+                v = stringify(v)
+            v = Timestamp(ensure_decoded(v))
+            if v.tz is not None:
+                v = v.tz_convert('UTC')
+            self.lhs.update(v)
+
+    def _disallow_scalar_only_bool_ops(self) -> None:
+        rhs = self.rhs
+        lhs = self.lhs
+        rhs_rt = rhs.return_type
+        rhs_rt = getattr(rhs_rt, 'type', rhs_rt)
+        lhs_rt = lhs.return_type
+        lhs_rt = getattr(lhs_rt, 'type', lhs_rt)
+        if (lhs.is_scalar or rhs.is_scalar) and self.op in _bool_ops_dict and (not (issubclass(rhs_rt, (bool, np.bool_)) and issubclass(lhs_rt, (bool, np.bool_)))):
+            raise NotImplementedError('cannot evaluate scalar only bool ops')
+UNARY_OPS_SYMS = ('+', '-', '~', 'not')
+_unary_ops_funcs = (operator.pos, operator.neg, operator.invert, operator.invert)
+_unary_ops_dict = dict(zip(UNARY_OPS_SYMS, _unary_ops_funcs))
+
+class UnaryOp(Op):
+
+    def __init__(self, op: Literal['+', '-', '~', 'not'], operand) -> None:
+        super().__init__(op, (operand,))
+        self.operand = operand
+        try:
+            self.func = _unary_ops_dict[op]
+        except KeyError as err:
+            raise ValueError(f'Invalid unary operator {op!r}, valid operators are {UNARY_OPS_SYMS}') from err
+
+    def __call__(self, env) -> MathCall:
+        operand = self.operand(env)
+        return self.func(operand)
+
+    def __repr__(self) -> str:
+        return pprint_thing(f'{self.op}({self.operand})')
+
+    @property
+    def return_type(self) -> np.dtype:
+        operand = self.operand
+        if operand.return_type == np.dtype('bool'):
+            return np.dtype('bool')
+        if isinstance(operand, Op) and (operand.op in _cmp_ops_dict or operand.op in _bool_ops_dict):
+            return np.dtype('bool')
+        return np.dtype('int')
+
+class MathCall(Op):
+
+    def __init__(self, func, args) -> None:
+        super().__init__(func.name, args)
+        self.func = func
+
+    def __call__(self, env):
+        operands = [op(env) for op in self.operands]
+        return self.func.func(*operands)
+
+    def __repr__(self) -> str:
+        operands = map(str, self.operands)
+        return pprint_thing(f"{self.op}({','.join(operands)})")
+
+class FuncNode:
+
+    def __init__(self, name: str) -> None:
+        if name not in MATHOPS:
+            raise ValueError(f'"{name}" is not a supported function')
+        self.name = name
+        self.func = getattr(np, name)
+
+    def __call__(self, *args) -> MathCall:
+        return MathCall(self, args)
+
+# File: pandas-main/pandas/core/computation/parsing.py
+""""""
+from __future__ import annotations
+from enum import Enum
+from io import StringIO
+from keyword import iskeyword
+import token
+import tokenize
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from collections.abc import Hashable, Iterator
+BACKTICK_QUOTED_STRING = 100
+
+def create_valid_python_identifier(name: str) -> str:
+    if name.isidentifier() and (not iskeyword(name)):
+        return name
+    gen = ((c, ''.join((chr(b) for b in c.encode('ascii', 'backslashreplace')))) for c in name)
+    name = ''.join((c_escaped.replace('\\', '_UNICODE_' if c != c_escaped else '_BACKSLASH_') for (c, c_escaped) in gen))
+    special_characters_replacements = {char: f'_{token.tok_name[tokval]}_' for (char, tokval) in tokenize.EXACT_TOKEN_TYPES.items()}
+    special_characters_replacements.update({' ': '_', '?': '_QUESTIONMARK_', '!': '_EXCLAMATIONMARK_', '$': '_DOLLARSIGN_', '€': '_EUROSIGN_', '°': '_DEGREESIGN_', "'": '_SINGLEQUOTE_', '"': '_DOUBLEQUOTE_', '#': '_HASH_', '`': '_BACKTICK_'})
+    name = ''.join([special_characters_replacements.get(char, char) for char in name])
+    name = f'BACKTICK_QUOTED_STRING_{name}'
+    if not name.isidentifier():
+        raise SyntaxError(f"Could not convert '{name}' to a valid Python identifier.")
+    return name
+
+def clean_backtick_quoted_toks(tok: tuple[int, str]) -> tuple[int, str]:
+    (toknum, tokval) = tok
+    if toknum == BACKTICK_QUOTED_STRING:
+        return (tokenize.NAME, create_valid_python_identifier(tokval))
+    return (toknum, tokval)
+
+def clean_column_name(name: Hashable) -> Hashable:
+    try:
+        name = name.replace('`', '``') if isinstance(name, str) else name
+        tokenized = tokenize_string(f'`{name}`')
+        tokval = next(tokenized)[1]
+        return create_valid_python_identifier(tokval)
+    except SyntaxError:
+        return name
+
+def tokenize_backtick_quoted_string(token_generator: Iterator[tokenize.TokenInfo], source: str, string_start: int) -> tuple[int, str]:
+    for (_, tokval, start, _, _) in token_generator:
+        if tokval == '`':
+            string_end = start[1]
+            break
+    return (BACKTICK_QUOTED_STRING, source[string_start:string_end])
+
+class ParseState(Enum):
+    DEFAULT = 0
+    IN_BACKTICK = 1
+    IN_SINGLE_QUOTE = 2
+    IN_DOUBLE_QUOTE = 3
+
+def _split_by_backtick(s: str) -> list[tuple[bool, str]]:
+    substrings = []
+    substr: list[str] = []
+    i = 0
+    parse_state = ParseState.DEFAULT
+    while i < len(s):
+        char = s[i]
+        match char:
+            case '`':
+                if parse_state == ParseState.DEFAULT:
+                    if substr:
+                        substrings.append((False, ''.join(substr)))
+                    substr = [char]
+                    i += 1
+                    parse_state = ParseState.IN_BACKTICK
+                    continue
+                elif parse_state == ParseState.IN_BACKTICK:
+                    next_char = s[i + 1] if i != len(s) - 1 else None
+                    if next_char == '`':
+                        substr.append(char)
+                        substr.append(next_char)
+                        i += 2
+                        continue
+                    else:
+                        substr.append(char)
+                        substrings.append((True, ''.join(substr)))
+                        substr = []
+                        i += 1
+                        parse_state = ParseState.DEFAULT
+                        continue
+            case "'":
+                if parse_state == ParseState.DEFAULT:
+                    parse_state = ParseState.IN_SINGLE_QUOTE
+                elif parse_state == ParseState.IN_SINGLE_QUOTE and s[i - 1] != '\\':
+                    parse_state = ParseState.DEFAULT
+            case '"':
+                if parse_state == ParseState.DEFAULT:
+                    parse_state = ParseState.IN_DOUBLE_QUOTE
+                elif parse_state == ParseState.IN_DOUBLE_QUOTE and s[i - 1] != '\\':
+                    parse_state = ParseState.DEFAULT
+        substr.append(char)
+        i += 1
+    if substr:
+        substrings.append((False, ''.join(substr)))
+    return substrings
+
+def tokenize_string(source: str) -> Iterator[tuple[int, str]]:
+    source = ''.join((create_valid_python_identifier(substring[1:-1]) if is_backtick_quoted else substring for (is_backtick_quoted, substring) in _split_by_backtick(source)))
+    line_reader = StringIO(source).readline
+    token_generator = tokenize.generate_tokens(line_reader)
+    for (toknum, tokval, _, _, _) in token_generator:
+        yield (toknum, tokval)
+
+# File: pandas-main/pandas/core/computation/pytables.py
+""""""
+from __future__ import annotations
+import ast
+from decimal import Decimal, InvalidOperation
+from functools import partial
+from typing import TYPE_CHECKING, Any, ClassVar
+import numpy as np
+from pandas._libs.tslibs import Timedelta, Timestamp
+from pandas.errors import UndefinedVariableError
+from pandas.core.dtypes.common import is_list_like
+import pandas.core.common as com
+from pandas.core.computation import expr, ops, scope as _scope
+from pandas.core.computation.common import ensure_decoded
+from pandas.core.computation.expr import BaseExprVisitor
+from pandas.core.computation.ops import is_term
+from pandas.core.construction import extract_array
+from pandas.core.indexes.base import Index
+from pandas.io.formats.printing import pprint_thing, pprint_thing_encoded
+if TYPE_CHECKING:
+    from pandas._typing import Self, npt
+
+class PyTablesScope(_scope.Scope):
+    __slots__ = ('queryables',)
+    queryables: dict[str, Any]
+
+    def __init__(self, level: int, global_dict=None, local_dict=None, queryables: dict[str, Any] | None=None) -> None:
+        super().__init__(level + 1, global_dict=global_dict, local_dict=local_dict)
+        self.queryables = queryables or {}
+
+class Term(ops.Term):
+    env: PyTablesScope
+
+    def __new__(cls, name, env, side=None, encoding=None):
+        if isinstance(name, str):
+            klass = cls
+        else:
+            klass = Constant
+        return object.__new__(klass)
+
+    def __init__(self, name, env: PyTablesScope, side=None, encoding=None) -> None:
+        super().__init__(name, env, side=side, encoding=encoding)
+
+    def _resolve_name(self):
+        if self.side == 'left':
+            if self.name not in self.env.queryables:
+                raise NameError(f'name {self.name!r} is not defined')
+            return self.name
+        try:
+            return self.env.resolve(self.name, is_local=False)
+        except UndefinedVariableError:
+            return self.name
+
+    @property
+    def value(self):
+        return self._value
+
+class Constant(Term):
+
+    def __init__(self, name, env: PyTablesScope, side=None, encoding=None) -> None:
+        assert isinstance(env, PyTablesScope), type(env)
+        super().__init__(name, env, side=side, encoding=encoding)
+
+    def _resolve_name(self):
+        return self._name
+
+class BinOp(ops.BinOp):
+    _max_selectors = 31
+    op: str
+    queryables: dict[str, Any]
+    condition: str | None
+
+    def __init__(self, op: str, lhs, rhs, queryables: dict[str, Any], encoding) -> None:
+        super().__init__(op, lhs, rhs)
+        self.queryables = queryables
+        self.encoding = encoding
+        self.condition = None
+
+    def _disallow_scalar_only_bool_ops(self) -> None:
+        pass
+
+    def prune(self, klass):
+
+        def pr(left, right):
+            if left is None:
+                return right
+            elif right is None:
+                return left
+            k = klass
+            if isinstance(left, ConditionBinOp):
+                if isinstance(right, ConditionBinOp):
+                    k = JointConditionBinOp
+                elif isinstance(left, k):
+                    return left
+                elif isinstance(right, k):
+                    return right
+            elif isinstance(left, FilterBinOp):
+                if isinstance(right, FilterBinOp):
+                    k = JointFilterBinOp
+                elif isinstance(left, k):
+                    return left
+                elif isinstance(right, k):
+                    return right
+            return k(self.op, left, right, queryables=self.queryables, encoding=self.encoding).evaluate()
+        (left, right) = (self.lhs, self.rhs)
+        if is_term(left) and is_term(right):
+            res = pr(left.value, right.value)
+        elif not is_term(left) and is_term(right):
+            res = pr(left.prune(klass), right.value)
+        elif is_term(left) and (not is_term(right)):
+            res = pr(left.value, right.prune(klass))
+        elif not (is_term(left) or is_term(right)):
+            res = pr(left.prune(klass), right.prune(klass))
+        return res
+
+    def conform(self, rhs):
+        if not is_list_like(rhs):
+            rhs = [rhs]
+        if isinstance(rhs, np.ndarray):
+            rhs = rhs.ravel()
+        return rhs
+
+    @property
+    def is_valid(self) -> bool:
+        return self.lhs in self.queryables
+
+    @property
+    def is_in_table(self) -> bool:
+        return self.queryables.get(self.lhs) is not None
+
+    @property
+    def kind(self):
+        return getattr(self.queryables.get(self.lhs), 'kind', None)
+
+    @property
+    def meta(self):
+        return getattr(self.queryables.get(self.lhs), 'meta', None)
+
+    @property
+    def metadata(self):
+        return getattr(self.queryables.get(self.lhs), 'metadata', None)
+
+    def generate(self, v) -> str:
+        val = v.tostring(self.encoding)
+        return f'({self.lhs} {self.op} {val})'
+
+    def convert_value(self, v) -> TermValue:
+
+        def stringify(value):
+            if self.encoding is not None:
+                return pprint_thing_encoded(value, encoding=self.encoding)
+            return pprint_thing(value)
+        kind = ensure_decoded(self.kind)
+        meta = ensure_decoded(self.meta)
+        if kind == 'datetime' or (kind and kind.startswith('datetime64')):
+            if isinstance(v, (int, float)):
+                v = stringify(v)
+            v = ensure_decoded(v)
+            v = Timestamp(v).as_unit('ns')
+            if v.tz is not None:
+                v = v.tz_convert('UTC')
+            return TermValue(v, v._value, kind)
+        elif kind in ('timedelta64', 'timedelta'):
+            if isinstance(v, str):
+                v = Timedelta(v)
+            else:
+                v = Timedelta(v, unit='s')
+            v = v.as_unit('ns')._value
+            return TermValue(int(v), v, kind)
+        elif meta == 'category':
+            metadata = extract_array(self.metadata, extract_numpy=True)
+            result: npt.NDArray[np.intp] | np.intp | int
+            if v not in metadata:
+                result = -1
+            else:
+                result = metadata.searchsorted(v, side='left')
+            return TermValue(result, result, 'integer')
+        elif kind == 'integer':
+            try:
+                v_dec = Decimal(v)
+            except InvalidOperation:
+                float(v)
+            else:
+                v = int(v_dec.to_integral_exact(rounding='ROUND_HALF_EVEN'))
+            return TermValue(v, v, kind)
+        elif kind == 'float':
+            v = float(v)
+            return TermValue(v, v, kind)
+        elif kind == 'bool':
+            if isinstance(v, str):
+                v = v.strip().lower() not in ['false', 'f', 'no', 'n', 'none', '0', '[]', '{}', '']
+            else:
+                v = bool(v)
+            return TermValue(v, v, kind)
+        elif isinstance(v, str):
+            return TermValue(v, stringify(v), 'string')
+        else:
+            raise TypeError(f'Cannot compare {v} of type {type(v)} to {kind} column')
+
+    def convert_values(self) -> None:
+        pass
+
+class FilterBinOp(BinOp):
+    filter: tuple[Any, Any, Index] | None = None
+
+    def __repr__(self) -> str:
+        if self.filter is None:
+            return 'Filter: Not Initialized'
+        return pprint_thing(f'[Filter : [{self.filter[0]}] -> [{self.filter[1]}]')
+
+    def invert(self) -> Self:
+        if self.filter is not None:
+            self.filter = (self.filter[0], self.generate_filter_op(invert=True), self.filter[2])
+        return self
+
+    def format(self):
+        return [self.filter]
+
+    def evaluate(self) -> Self | None:
+        if not self.is_valid:
+            raise ValueError(f'query term is not valid [{self}]')
+        rhs = self.conform(self.rhs)
+        values = list(rhs)
+        if self.is_in_table:
+            if self.op in ['==', '!='] and len(values) > self._max_selectors:
+                filter_op = self.generate_filter_op()
+                self.filter = (self.lhs, filter_op, Index(values))
+                return self
+            return None
+        if self.op in ['==', '!=']:
+            filter_op = self.generate_filter_op()
+            self.filter = (self.lhs, filter_op, Index(values))
+        else:
+            raise TypeError(f'passing a filterable condition to a non-table indexer [{self}]')
+        return self
+
+    def generate_filter_op(self, invert: bool=False):
+        if self.op == '!=' and (not invert) or (self.op == '==' and invert):
+            return lambda axis, vals: ~axis.isin(vals)
+        else:
+            return lambda axis, vals: axis.isin(vals)
+
+class JointFilterBinOp(FilterBinOp):
+
+    def format(self):
+        raise NotImplementedError('unable to collapse Joint Filters')
+
+    def evaluate(self) -> Self:
+        return self
+
+class ConditionBinOp(BinOp):
+
+    def __repr__(self) -> str:
+        return pprint_thing(f'[Condition : [{self.condition}]]')
+
+    def invert(self):
+        raise NotImplementedError('cannot use an invert condition when passing to numexpr')
+
+    def format(self):
+        return self.condition
+
+    def evaluate(self) -> Self | None:
+        if not self.is_valid:
+            raise ValueError(f'query term is not valid [{self}]')
+        if not self.is_in_table:
+            return None
+        rhs = self.conform(self.rhs)
+        values = [self.convert_value(v) for v in rhs]
+        if self.op in ['==', '!=']:
+            if len(values) <= self._max_selectors:
+                vs = [self.generate(v) for v in values]
+                self.condition = f"({' | '.join(vs)})"
+            else:
+                return None
+        else:
+            self.condition = self.generate(values[0])
+        return self
+
+class JointConditionBinOp(ConditionBinOp):
+
+    def evaluate(self) -> Self:
+        self.condition = f'({self.lhs.condition} {self.op} {self.rhs.condition})'
+        return self
+
+class UnaryOp(ops.UnaryOp):
+
+    def prune(self, klass):
+        if self.op != '~':
+            raise NotImplementedError('UnaryOp only support invert type ops')
+        operand = self.operand
+        operand = operand.prune(klass)
+        if operand is not None and (issubclass(klass, ConditionBinOp) and operand.condition is not None or (not issubclass(klass, ConditionBinOp) and issubclass(klass, FilterBinOp) and (operand.filter is not None))):
+            return operand.invert()
+        return None
+
+class PyTablesExprVisitor(BaseExprVisitor):
+    const_type: ClassVar[type[ops.Term]] = Constant
+    term_type: ClassVar[type[Term]] = Term
+
+    def __init__(self, env, engine, parser, **kwargs) -> None:
+        super().__init__(env, engine, parser)
+        for bin_op in self.binary_ops:
+            bin_node = self.binary_op_nodes_map[bin_op]
+            setattr(self, f'visit_{bin_node}', lambda node, bin_op=bin_op: partial(BinOp, bin_op, **kwargs))
+
+    def visit_UnaryOp(self, node, **kwargs) -> ops.Term | UnaryOp | None:
+        if isinstance(node.op, (ast.Not, ast.Invert)):
+            return UnaryOp('~', self.visit(node.operand))
+        elif isinstance(node.op, ast.USub):
+            return self.const_type(-self.visit(node.operand).value, self.env)
+        elif isinstance(node.op, ast.UAdd):
+            raise NotImplementedError('Unary addition not supported')
+        return None
+
+    def visit_Index(self, node, **kwargs):
+        return self.visit(node.value).value
+
+    def visit_Assign(self, node, **kwargs):
+        cmpr = ast.Compare(ops=[ast.Eq()], left=node.targets[0], comparators=[node.value])
+        return self.visit(cmpr)
+
+    def visit_Subscript(self, node, **kwargs) -> ops.Term:
+        value = self.visit(node.value)
+        slobj = self.visit(node.slice)
+        try:
+            value = value.value
+        except AttributeError:
+            pass
+        if isinstance(slobj, Term):
+            slobj = slobj.value
+        try:
+            return self.const_type(value[slobj], self.env)
+        except TypeError as err:
+            raise ValueError(f'cannot subscript {value!r} with {slobj!r}') from err
+
+    def visit_Attribute(self, node, **kwargs):
+        attr = node.attr
+        value = node.value
+        ctx = type(node.ctx)
+        if ctx == ast.Load:
+            resolved = self.visit(value)
+            try:
+                resolved = resolved.value
+            except AttributeError:
+                pass
+            try:
+                return self.term_type(getattr(resolved, attr), self.env)
+            except AttributeError:
+                if isinstance(value, ast.Name) and value.id == attr:
+                    return resolved
+        raise ValueError(f'Invalid Attribute context {ctx.__name__}')
+
+    def translate_In(self, op):
+        return ast.Eq() if isinstance(op, ast.In) else op
+
+    def _rewrite_membership_op(self, node, left, right):
+        return (self.visit(node.op), node.op, left, right)
+
+def _validate_where(w):
+    if not (isinstance(w, (PyTablesExpr, str)) or is_list_like(w)):
+        raise TypeError('where must be passed as a string, PyTablesExpr, or list-like of PyTablesExpr')
+    return w
+
+class PyTablesExpr(expr.Expr):
+    _visitor: PyTablesExprVisitor | None
+    env: PyTablesScope
+    expr: str
+
+    def __init__(self, where, queryables: dict[str, Any] | None=None, encoding=None, scope_level: int=0) -> None:
+        where = _validate_where(where)
+        self.encoding = encoding
+        self.condition = None
+        self.filter = None
+        self.terms = None
+        self._visitor = None
+        local_dict: _scope.DeepChainMap[Any, Any] | None = None
+        if isinstance(where, PyTablesExpr):
+            local_dict = where.env.scope
+            _where = where.expr
+        elif is_list_like(where):
+            where = list(where)
+            for (idx, w) in enumerate(where):
+                if isinstance(w, PyTablesExpr):
+                    local_dict = w.env.scope
+                else:
+                    where[idx] = _validate_where(w)
+            _where = ' & '.join([f'({w})' for w in com.flatten(where)])
+        else:
+            _where = where
+        self.expr = _where
+        self.env = PyTablesScope(scope_level + 1, local_dict=local_dict)
+        if queryables is not None and isinstance(self.expr, str):
+            self.env.queryables.update(queryables)
+            self._visitor = PyTablesExprVisitor(self.env, queryables=queryables, parser='pytables', engine='pytables', encoding=encoding)
+            self.terms = self.parse()
+
+    def __repr__(self) -> str:
+        if self.terms is not None:
+            return pprint_thing(self.terms)
+        return pprint_thing(self.expr)
+
+    def evaluate(self):
+        try:
+            self.condition = self.terms.prune(ConditionBinOp)
+        except AttributeError as err:
+            raise ValueError(f'cannot process expression [{self.expr}], [{self}] is not a valid condition') from err
+        try:
+            self.filter = self.terms.prune(FilterBinOp)
+        except AttributeError as err:
+            raise ValueError(f'cannot process expression [{self.expr}], [{self}] is not a valid filter') from err
+        return (self.condition, self.filter)
+
+class TermValue:
+
+    def __init__(self, value, converted, kind: str) -> None:
+        assert isinstance(kind, str), kind
+        self.value = value
+        self.converted = converted
+        self.kind = kind
+
+    def tostring(self, encoding) -> str:
+        if self.kind == 'string':
+            if encoding is not None:
+                return str(self.converted)
+            return f'"{self.converted}"'
+        elif self.kind == 'float':
+            return repr(self.converted)
+        return str(self.converted)
+
+def maybe_expression(s) -> bool:
+    if not isinstance(s, str):
+        return False
+    operations = PyTablesExprVisitor.binary_ops + PyTablesExprVisitor.unary_ops + ('=',)
+    return any((op in s for op in operations))
+
+# File: pandas-main/pandas/core/computation/scope.py
+""""""
+from __future__ import annotations
+from collections import ChainMap
+import datetime
+import inspect
+from io import StringIO
+import itertools
+import pprint
+import struct
+import sys
+from typing import TypeVar
+import numpy as np
+from pandas._libs.tslibs import Timestamp
+from pandas.errors import UndefinedVariableError
+_KT = TypeVar('_KT')
+_VT = TypeVar('_VT')
+
+class DeepChainMap(ChainMap[_KT, _VT]):
+
+    def __setitem__(self, key: _KT, value: _VT) -> None:
+        for mapping in self.maps:
+            if key in mapping:
+                mapping[key] = value
+                return
+        self.maps[0][key] = value
+
+    def __delitem__(self, key: _KT) -> None:
+        for mapping in self.maps:
+            if key in mapping:
+                del mapping[key]
+                return
+        raise KeyError(key)
+
+def ensure_scope(level: int, global_dict=None, local_dict=None, resolvers=(), target=None) -> Scope:
+    return Scope(level + 1, global_dict=global_dict, local_dict=local_dict, resolvers=resolvers, target=target)
+
+def _replacer(x) -> str:
+    try:
+        hexin = ord(x)
+    except TypeError:
+        hexin = x
+    return hex(hexin)
+
+def _raw_hex_id(obj) -> str:
+    packed = struct.pack('@P', id(obj))
+    return ''.join([_replacer(x) for x in packed])
+DEFAULT_GLOBALS = {'Timestamp': Timestamp, 'datetime': datetime.datetime, 'True': True, 'False': False, 'list': list, 'tuple': tuple, 'inf': np.inf, 'Inf': np.inf}
+
+def _get_pretty_string(obj) -> str:
+    sio = StringIO()
+    pprint.pprint(obj, stream=sio)
+    return sio.getvalue()
+
+class Scope:
+    __slots__ = ['level', 'scope', 'target', 'resolvers', 'temps']
+    level: int
+    scope: DeepChainMap
+    resolvers: DeepChainMap
+    temps: dict
+
+    def __init__(self, level: int, global_dict=None, local_dict=None, resolvers=(), target=None) -> None:
+        self.level = level + 1
+        self.scope = DeepChainMap(DEFAULT_GLOBALS.copy())
+        self.target = target
+        if isinstance(local_dict, Scope):
+            self.scope.update(local_dict.scope)
+            if local_dict.target is not None:
+                self.target = local_dict.target
+            self._update(local_dict.level)
+        frame = sys._getframe(self.level)
+        try:
+            scope_global = self.scope.new_child((global_dict if global_dict is not None else frame.f_globals).copy())
+            self.scope = DeepChainMap(scope_global)
+            if not isinstance(local_dict, Scope):
+                scope_local = self.scope.new_child((local_dict if local_dict is not None else frame.f_locals).copy())
+                self.scope = DeepChainMap(scope_local)
+        finally:
+            del frame
+        if isinstance(local_dict, Scope):
+            resolvers += tuple(local_dict.resolvers.maps)
+        self.resolvers = DeepChainMap(*resolvers)
+        self.temps = {}
+
+    def __repr__(self) -> str:
+        scope_keys = _get_pretty_string(list(self.scope.keys()))
+        res_keys = _get_pretty_string(list(self.resolvers.keys()))
+        return f'{type(self).__name__}(scope={scope_keys}, resolvers={res_keys})'
+
+    @property
+    def has_resolvers(self) -> bool:
+        return bool(len(self.resolvers))
+
+    def resolve(self, key: str, is_local: bool):
+        try:
+            if is_local:
+                return self.scope[key]
+            if self.has_resolvers:
+                return self.resolvers[key]
+            assert not is_local and (not self.has_resolvers)
+            return self.scope[key]
+        except KeyError:
+            try:
+                return self.temps[key]
+            except KeyError as err:
+                raise UndefinedVariableError(key, is_local) from err
+
+    def swapkey(self, old_key: str, new_key: str, new_value=None) -> None:
+        if self.has_resolvers:
+            maps = self.resolvers.maps + self.scope.maps
+        else:
+            maps = self.scope.maps
+        maps.append(self.temps)
+        for mapping in maps:
+            if old_key in mapping:
+                mapping[new_key] = new_value
+                return
+
+    def _get_vars(self, stack, scopes: list[str]) -> None:
+        variables = itertools.product(scopes, stack)
+        for (scope, (frame, _, _, _, _, _)) in variables:
+            try:
+                d = getattr(frame, f'f_{scope}')
+                self.scope = DeepChainMap(self.scope.new_child(d))
+            finally:
+                del frame
+
+    def _update(self, level: int) -> None:
+        sl = level + 1
+        stack = inspect.stack()
+        try:
+            self._get_vars(stack[:sl], scopes=['locals'])
+        finally:
+            del stack[:], stack
+
+    def add_tmp(self, value) -> str:
+        name = f'{type(value).__name__}_{self.ntemps}_{_raw_hex_id(self)}'
+        assert name not in self.temps
+        self.temps[name] = value
+        assert name in self.temps
+        return name
+
+    @property
+    def ntemps(self) -> int:
+        return len(self.temps)
+
+    @property
+    def full_scope(self) -> DeepChainMap:
+        maps = [self.temps] + self.resolvers.maps + self.scope.maps
+        return DeepChainMap(*maps)
+
+# File: pandas-main/pandas/core/config_init.py
+""""""
+from __future__ import annotations
+from collections.abc import Callable
+import os
+from typing import Any
+import pandas._config.config as cf
+from pandas._config.config import is_bool, is_callable, is_instance_factory, is_int, is_nonnegative_int, is_one_of_factory, is_str, is_text
+use_bottleneck_doc = '\n: bool\n    Use the bottleneck library to accelerate if it is installed,\n    the default is True\n    Valid values: False,True\n'
+
+def use_bottleneck_cb(key: str) -> None:
+    from pandas.core import nanops
+    nanops.set_use_bottleneck(cf.get_option(key))
+use_numexpr_doc = '\n: bool\n    Use the numexpr library to accelerate computation if it is installed,\n    the default is True\n    Valid values: False,True\n'
+
+def use_numexpr_cb(key: str) -> None:
+    from pandas.core.computation import expressions
+    expressions.set_use_numexpr(cf.get_option(key))
+use_numba_doc = '\n: bool\n    Use the numba engine option for select operations if it is installed,\n    the default is False\n    Valid values: False,True\n'
+
+def use_numba_cb(key: str) -> None:
+    from pandas.core.util import numba_
+    numba_.set_use_numba(cf.get_option(key))
+with cf.config_prefix('compute'):
+    cf.register_option('use_bottleneck', True, use_bottleneck_doc, validator=is_bool, cb=use_bottleneck_cb)
+    cf.register_option('use_numexpr', True, use_numexpr_doc, validator=is_bool, cb=use_numexpr_cb)
+    cf.register_option('use_numba', False, use_numba_doc, validator=is_bool, cb=use_numba_cb)
+pc_precision_doc = '\n: int\n    Floating point output precision in terms of number of places after the\n    decimal, for regular formatting as well as scientific notation. Similar\n    to ``precision`` in :meth:`numpy.set_printoptions`.\n'
+pc_max_rows_doc = "\n: int\n    If max_rows is exceeded, switch to truncate view. Depending on\n    `large_repr`, objects are either centrally truncated or printed as\n    a summary view. 'None' value means unlimited.\n\n    In case python/IPython is running in a terminal and `large_repr`\n    equals 'truncate' this can be set to 0 and pandas will auto-detect\n    the height of the terminal and print a truncated object which fits\n    the screen height. The IPython notebook, IPython qtconsole, or\n    IDLE do not run in a terminal and hence it is not possible to do\n    correct auto-detection.\n"
+pc_min_rows_doc = '\n: int\n    The numbers of rows to show in a truncated view (when `max_rows` is\n    exceeded). Ignored when `max_rows` is set to None or 0. When set to\n    None, follows the value of `max_rows`.\n'
+pc_max_cols_doc = "\n: int\n    If max_cols is exceeded, switch to truncate view. Depending on\n    `large_repr`, objects are either centrally truncated or printed as\n    a summary view. 'None' value means unlimited.\n\n    In case python/IPython is running in a terminal and `large_repr`\n    equals 'truncate' this can be set to 0 or None and pandas will auto-detect\n    the width of the terminal and print a truncated object which fits\n    the screen width. The IPython notebook, IPython qtconsole, or IDLE\n    do not run in a terminal and hence it is not possible to do\n    correct auto-detection and defaults to 20.\n"
+pc_max_categories_doc = '\n: int\n    This sets the maximum number of categories pandas should output when\n    printing out a `Categorical` or a Series of dtype "category".\n'
+pc_max_info_cols_doc = '\n: int\n    max_info_columns is used in DataFrame.info method to decide if\n    per column information will be printed.\n'
+pc_nb_repr_h_doc = '\n: boolean\n    When True, IPython notebook will use html representation for\n    pandas objects (if it is available).\n'
+pc_pprint_nest_depth = '\n: int\n    Controls the number of nested levels to process when pretty-printing\n'
+pc_multi_sparse_doc = '\n: boolean\n    "sparsify" MultiIndex display (don\'t display repeated\n    elements in outer levels within groups)\n'
+float_format_doc = '\n: callable\n    The callable should accept a floating point number and return\n    a string with the desired format of the number. This is used\n    in some places like SeriesFormatter.\n    See formats.format.EngFormatter for an example.\n'
+max_colwidth_doc = '\n: int or None\n    The maximum width in characters of a column in the repr of\n    a pandas data structure. When the column overflows, a "..."\n    placeholder is embedded in the output. A \'None\' value means unlimited.\n'
+colheader_justify_doc = "\n: 'left'/'right'\n    Controls the justification of column headers. used by DataFrameFormatter.\n"
+pc_expand_repr_doc = '\n: boolean\n    Whether to print out the full DataFrame repr for wide DataFrames across\n    multiple lines, `max_columns` is still respected, but the output will\n    wrap-around across multiple "pages" if its width exceeds `display.width`.\n'
+pc_show_dimensions_doc = "\n: boolean or 'truncate'\n    Whether to print out dimensions at the end of DataFrame repr.\n    If 'truncate' is specified, only print out the dimensions if the\n    frame is truncated (e.g. not display all rows and/or columns)\n"
+pc_east_asian_width_doc = '\n: boolean\n    Whether to use the Unicode East Asian Width to calculate the display text\n    width.\n    Enabling this may affect to the performance (default: False)\n'
+pc_table_schema_doc = '\n: boolean\n    Whether to publish a Table Schema representation for frontends\n    that support it.\n    (default: False)\n'
+pc_html_border_doc = '\n: int\n    A ``border=value`` attribute is inserted in the ``<table>`` tag\n    for the DataFrame HTML repr.\n'
+pc_html_use_mathjax_doc = ': boolean\n    When True, Jupyter notebook will process table contents using MathJax,\n    rendering mathematical expressions enclosed by the dollar symbol.\n    (default: True)\n'
+pc_max_dir_items = ": int\n    The number of items that will be added to `dir(...)`. 'None' value means\n    unlimited. Because dir is cached, changing this option will not immediately\n    affect already existing dataframes until a column is deleted or added.\n\n    This is for instance used to suggest columns from a dataframe to tab\n    completion.\n"
+pc_width_doc = '\n: int\n    Width of the display in characters. In case python/IPython is running in\n    a terminal this can be set to None and pandas will correctly auto-detect\n    the width.\n    Note that the IPython notebook, IPython qtconsole, or IDLE do not run in a\n    terminal and hence it is not possible to correctly detect the width.\n'
+pc_chop_threshold_doc = '\n: float or None\n    if set to a float value, all float values smaller than the given threshold\n    will be displayed as exactly 0 by repr and friends.\n'
+pc_max_seq_items = '\n: int or None\n    When pretty-printing a long sequence, no more then `max_seq_items`\n    will be printed. If items are omitted, they will be denoted by the\n    addition of "..." to the resulting string.\n\n    If set to None, the number of items to be printed is unlimited.\n'
+pc_max_info_rows_doc = '\n: int\n    df.info() will usually show null-counts for each column.\n    For large frames this can be quite slow. max_info_rows and max_info_cols\n    limit this null check only to frames with smaller dimensions than\n    specified.\n'
+pc_large_repr_doc = "\n: 'truncate'/'info'\n    For DataFrames exceeding max_rows/max_cols, the repr (and HTML repr) can\n    show a truncated table, or switch to the view from\n    df.info() (the behaviour in earlier versions of pandas).\n"
+pc_memory_usage_doc = "\n: bool, string or None\n    This specifies if the memory usage of a DataFrame should be displayed when\n    df.info() is called. Valid values True,False,'deep'\n"
+
+def table_schema_cb(key: str) -> None:
+    from pandas.io.formats.printing import enable_data_resource_formatter
+    enable_data_resource_formatter(cf.get_option(key))
+
+def is_terminal() -> bool:
+    try:
+        ip = get_ipython()
+    except NameError:
+        return True
+    else:
+        if hasattr(ip, 'kernel'):
+            return False
+        else:
+            return True
+with cf.config_prefix('display'):
+    cf.register_option('precision', 6, pc_precision_doc, validator=is_nonnegative_int)
+    cf.register_option('float_format', None, float_format_doc, validator=is_one_of_factory([None, is_callable]))
+    cf.register_option('max_info_rows', 1690785, pc_max_info_rows_doc, validator=is_int)
+    cf.register_option('max_rows', 60, pc_max_rows_doc, validator=is_nonnegative_int)
+    cf.register_option('min_rows', 10, pc_min_rows_doc, validator=is_instance_factory((type(None), int)))
+    cf.register_option('max_categories', 8, pc_max_categories_doc, validator=is_int)
+    cf.register_option('max_colwidth', 50, max_colwidth_doc, validator=is_nonnegative_int)
+    if is_terminal():
+        max_cols = 0
+    else:
+        max_cols = 20
+    cf.register_option('max_columns', max_cols, pc_max_cols_doc, validator=is_nonnegative_int)
+    cf.register_option('large_repr', 'truncate', pc_large_repr_doc, validator=is_one_of_factory(['truncate', 'info']))
+    cf.register_option('max_info_columns', 100, pc_max_info_cols_doc, validator=is_int)
+    cf.register_option('colheader_justify', 'right', colheader_justify_doc, validator=is_text)
+    cf.register_option('notebook_repr_html', True, pc_nb_repr_h_doc, validator=is_bool)
+    cf.register_option('pprint_nest_depth', 3, pc_pprint_nest_depth, validator=is_int)
+    cf.register_option('multi_sparse', True, pc_multi_sparse_doc, validator=is_bool)
+    cf.register_option('expand_frame_repr', True, pc_expand_repr_doc)
+    cf.register_option('show_dimensions', 'truncate', pc_show_dimensions_doc, validator=is_one_of_factory([True, False, 'truncate']))
+    cf.register_option('chop_threshold', None, pc_chop_threshold_doc)
+    cf.register_option('max_seq_items', 100, pc_max_seq_items)
+    cf.register_option('width', 80, pc_width_doc, validator=is_instance_factory((type(None), int)))
+    cf.register_option('memory_usage', True, pc_memory_usage_doc, validator=is_one_of_factory([None, True, False, 'deep']))
+    cf.register_option('unicode.east_asian_width', False, pc_east_asian_width_doc, validator=is_bool)
+    cf.register_option('unicode.ambiguous_as_wide', False, pc_east_asian_width_doc, validator=is_bool)
+    cf.register_option('html.table_schema', False, pc_table_schema_doc, validator=is_bool, cb=table_schema_cb)
+    cf.register_option('html.border', 1, pc_html_border_doc, validator=is_int)
+    cf.register_option('html.use_mathjax', True, pc_html_use_mathjax_doc, validator=is_bool)
+    cf.register_option('max_dir_items', 100, pc_max_dir_items, validator=is_nonnegative_int)
+tc_sim_interactive_doc = '\n: boolean\n    Whether to simulate interactive mode for purposes of testing\n'
+with cf.config_prefix('mode'):
+    cf.register_option('sim_interactive', False, tc_sim_interactive_doc)
+copy_on_write_doc = '\n: bool\n    Use new copy-view behaviour using Copy-on-Write. Defaults to False,\n    unless overridden by the \'PANDAS_COPY_ON_WRITE\' environment variable\n    (if set to "1" for True, needs to be set before pandas is imported).\n'
+with cf.config_prefix('mode'):
+    cf.register_option('copy_on_write', 'warn' if os.environ.get('PANDAS_COPY_ON_WRITE', '0') == 'warn' else os.environ.get('PANDAS_COPY_ON_WRITE', '0') == '1', copy_on_write_doc, validator=is_one_of_factory([True, False, 'warn']))
+chained_assignment = '\n: string\n    Raise an exception, warn, or no action if trying to use chained assignment,\n    The default is warn\n'
+with cf.config_prefix('mode'):
+    cf.register_option('chained_assignment', 'warn', chained_assignment, validator=is_one_of_factory([None, 'warn', 'raise']))
+performance_warnings = '\n: boolean\n    Whether to show or hide PerformanceWarnings.\n'
+with cf.config_prefix('mode'):
+    cf.register_option('performance_warnings', True, performance_warnings, validator=is_bool)
+string_storage_doc = '\n: string\n    The default storage for StringDtype.\n'
+
+def is_valid_string_storage(value: Any) -> None:
+    legal_values = ['auto', 'python', 'pyarrow']
+    if value not in legal_values:
+        msg = 'Value must be one of python|pyarrow'
+        if value == 'pyarrow_numpy':
+            msg += ". 'pyarrow_numpy' was specified, but this option should be enabled using pandas.options.future.infer_string instead"
+        raise ValueError(msg)
+with cf.config_prefix('mode'):
+    cf.register_option('string_storage', 'auto', string_storage_doc, validator=is_valid_string_storage)
+reader_engine_doc = "\n: string\n    The default Excel reader engine for '{ext}' files. Available options:\n    auto, {others}.\n"
+_xls_options = ['xlrd', 'calamine']
+_xlsm_options = ['xlrd', 'openpyxl', 'calamine']
+_xlsx_options = ['xlrd', 'openpyxl', 'calamine']
+_ods_options = ['odf', 'calamine']
+_xlsb_options = ['pyxlsb', 'calamine']
+with cf.config_prefix('io.excel.xls'):
+    cf.register_option('reader', 'auto', reader_engine_doc.format(ext='xls', others=', '.join(_xls_options)), validator=is_one_of_factory(_xls_options + ['auto']))
+with cf.config_prefix('io.excel.xlsm'):
+    cf.register_option('reader', 'auto', reader_engine_doc.format(ext='xlsm', others=', '.join(_xlsm_options)), validator=is_one_of_factory(_xlsm_options + ['auto']))
+with cf.config_prefix('io.excel.xlsx'):
+    cf.register_option('reader', 'auto', reader_engine_doc.format(ext='xlsx', others=', '.join(_xlsx_options)), validator=is_one_of_factory(_xlsx_options + ['auto']))
+with cf.config_prefix('io.excel.ods'):
+    cf.register_option('reader', 'auto', reader_engine_doc.format(ext='ods', others=', '.join(_ods_options)), validator=is_one_of_factory(_ods_options + ['auto']))
+with cf.config_prefix('io.excel.xlsb'):
+    cf.register_option('reader', 'auto', reader_engine_doc.format(ext='xlsb', others=', '.join(_xlsb_options)), validator=is_one_of_factory(_xlsb_options + ['auto']))
+writer_engine_doc = "\n: string\n    The default Excel writer engine for '{ext}' files. Available options:\n    auto, {others}.\n"
+_xlsm_options = ['openpyxl']
+_xlsx_options = ['openpyxl', 'xlsxwriter']
+_ods_options = ['odf']
+with cf.config_prefix('io.excel.xlsm'):
+    cf.register_option('writer', 'auto', writer_engine_doc.format(ext='xlsm', others=', '.join(_xlsm_options)), validator=str)
+with cf.config_prefix('io.excel.xlsx'):
+    cf.register_option('writer', 'auto', writer_engine_doc.format(ext='xlsx', others=', '.join(_xlsx_options)), validator=str)
+with cf.config_prefix('io.excel.ods'):
+    cf.register_option('writer', 'auto', writer_engine_doc.format(ext='ods', others=', '.join(_ods_options)), validator=str)
+parquet_engine_doc = "\n: string\n    The default parquet reader/writer engine. Available options:\n    'auto', 'pyarrow', 'fastparquet', the default is 'auto'\n"
+with cf.config_prefix('io.parquet'):
+    cf.register_option('engine', 'auto', parquet_engine_doc, validator=is_one_of_factory(['auto', 'pyarrow', 'fastparquet']))
+sql_engine_doc = "\n: string\n    The default sql reader/writer engine. Available options:\n    'auto', 'sqlalchemy', the default is 'auto'\n"
+with cf.config_prefix('io.sql'):
+    cf.register_option('engine', 'auto', sql_engine_doc, validator=is_one_of_factory(['auto', 'sqlalchemy']))
+plotting_backend_doc = '\n: str\n    The plotting backend to use. The default value is "matplotlib", the\n    backend provided with pandas. Other backends can be specified by\n    providing the name of the module that implements the backend.\n'
+
+def register_plotting_backend_cb(key: str | None) -> None:
+    if key == 'matplotlib':
+        return
+    from pandas.plotting._core import _get_plot_backend
+    _get_plot_backend(key)
+with cf.config_prefix('plotting'):
+    cf.register_option('backend', defval='matplotlib', doc=plotting_backend_doc, validator=register_plotting_backend_cb)
+register_converter_doc = "\n: bool or 'auto'.\n    Whether to register converters with matplotlib's units registry for\n    dates, times, datetimes, and Periods. Toggling to False will remove\n    the converters, restoring any converters that pandas overwrote.\n"
+
+def register_converter_cb(key: str) -> None:
+    from pandas.plotting import deregister_matplotlib_converters, register_matplotlib_converters
+    if cf.get_option(key):
+        register_matplotlib_converters()
+    else:
+        deregister_matplotlib_converters()
+with cf.config_prefix('plotting.matplotlib'):
+    cf.register_option('register_converters', 'auto', register_converter_doc, validator=is_one_of_factory(['auto', True, False]), cb=register_converter_cb)
+styler_sparse_index_doc = '\n: bool\n    Whether to sparsify the display of a hierarchical index. Setting to False will\n    display each explicit level element in a hierarchical key for each row.\n'
+styler_sparse_columns_doc = '\n: bool\n    Whether to sparsify the display of hierarchical columns. Setting to False will\n    display each explicit level element in a hierarchical key for each column.\n'
+styler_render_repr = '\n: str\n    Determine which output to use in Jupyter Notebook in {"html", "latex"}.\n'
+styler_max_elements = '\n: int\n    The maximum number of data-cell (<td>) elements that will be rendered before\n    trimming will occur over columns, rows or both if needed.\n'
+styler_max_rows = '\n: int, optional\n    The maximum number of rows that will be rendered. May still be reduced to\n    satisfy ``max_elements``, which takes precedence.\n'
+styler_max_columns = '\n: int, optional\n    The maximum number of columns that will be rendered. May still be reduced to\n    satisfy ``max_elements``, which takes precedence.\n'
+styler_precision = '\n: int\n    The precision for floats and complex numbers.\n'
+styler_decimal = '\n: str\n    The character representation for the decimal separator for floats and complex.\n'
+styler_thousands = '\n: str, optional\n    The character representation for thousands separator for floats, int and complex.\n'
+styler_na_rep = '\n: str, optional\n    The string representation for values identified as missing.\n'
+styler_escape = '\n: str, optional\n    Whether to escape certain characters according to the given context; html or latex.\n'
+styler_formatter = '\n: str, callable, dict, optional\n    A formatter object to be used as default within ``Styler.format``.\n'
+styler_multirow_align = '\n: {"c", "t", "b"}\n    The specifier for vertical alignment of sparsified LaTeX multirows.\n'
+styler_multicol_align = '\n: {"r", "c", "l", "naive-l", "naive-r"}\n    The specifier for horizontal alignment of sparsified LaTeX multicolumns. Pipe\n    decorators can also be added to non-naive values to draw vertical\n    rules, e.g. "\\|r" will draw a rule on the left side of right aligned merged cells.\n'
+styler_hrules = '\n: bool\n    Whether to add horizontal rules on top and bottom and below the headers.\n'
+styler_environment = '\n: str\n    The environment to replace ``\\begin{table}``. If "longtable" is used results\n    in a specific longtable environment format.\n'
+styler_encoding = '\n: str\n    The encoding used for output HTML and LaTeX files.\n'
+styler_mathjax = '\n: bool\n    If False will render special CSS classes to table attributes that indicate Mathjax\n    will not be used in Jupyter Notebook.\n'
+with cf.config_prefix('styler'):
+    cf.register_option('sparse.index', True, styler_sparse_index_doc, validator=is_bool)
+    cf.register_option('sparse.columns', True, styler_sparse_columns_doc, validator=is_bool)
+    cf.register_option('render.repr', 'html', styler_render_repr, validator=is_one_of_factory(['html', 'latex']))
+    cf.register_option('render.max_elements', 2 ** 18, styler_max_elements, validator=is_nonnegative_int)
+    cf.register_option('render.max_rows', None, styler_max_rows, validator=is_nonnegative_int)
+    cf.register_option('render.max_columns', None, styler_max_columns, validator=is_nonnegative_int)
+    cf.register_option('render.encoding', 'utf-8', styler_encoding, validator=is_str)
+    cf.register_option('format.decimal', '.', styler_decimal, validator=is_str)
+    cf.register_option('format.precision', 6, styler_precision, validator=is_nonnegative_int)
+    cf.register_option('format.thousands', None, styler_thousands, validator=is_instance_factory((type(None), str)))
+    cf.register_option('format.na_rep', None, styler_na_rep, validator=is_instance_factory((type(None), str)))
+    cf.register_option('format.escape', None, styler_escape, validator=is_one_of_factory([None, 'html', 'latex', 'latex-math']))
+    cf.register_option('format.formatter', None, styler_formatter, validator=is_instance_factory((type(None), dict, Callable, str)))
+    cf.register_option('html.mathjax', True, styler_mathjax, validator=is_bool)
+    cf.register_option('latex.multirow_align', 'c', styler_multirow_align, validator=is_one_of_factory(['c', 't', 'b', 'naive']))
+    val_mca = ['r', '|r|', '|r', 'r|', 'c', '|c|', '|c', 'c|', 'l', '|l|', '|l', 'l|']
+    val_mca += ['naive-l', 'naive-r']
+    cf.register_option('latex.multicol_align', 'r', styler_multicol_align, validator=is_one_of_factory(val_mca))
+    cf.register_option('latex.hrules', False, styler_hrules, validator=is_bool)
+    cf.register_option('latex.environment', None, styler_environment, validator=is_instance_factory((type(None), str)))
+with cf.config_prefix('future'):
+    cf.register_option('infer_string', True if os.environ.get('PANDAS_FUTURE_INFER_STRING', '0') == '1' else False, 'Whether to infer sequence of str objects as pyarrow string dtype, which will be the default in pandas 3.0 (at which point this option will be deprecated).', validator=is_one_of_factory([True, False]))
+    cf.register_option('no_silent_downcasting', False, 'Whether to opt-in to the future behavior which will *not* silently downcast results from Series and DataFrame `where`, `mask`, and `clip` methods. Silent downcasting will be removed in pandas 3.0 (at which point this option will be deprecated).', validator=is_one_of_factory([True, False]))
+
+# File: pandas-main/pandas/core/construction.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, cast, overload
+import numpy as np
+from numpy import ma
+from pandas._config import using_string_dtype
+from pandas._libs import lib
+from pandas._libs.tslibs import get_supported_dtype, is_supported_dtype
+from pandas.core.dtypes.base import ExtensionDtype
+from pandas.core.dtypes.cast import construct_1d_arraylike_from_scalar, construct_1d_object_array_from_listlike, maybe_cast_to_datetime, maybe_cast_to_integer_array, maybe_convert_platform, maybe_infer_to_datetimelike, maybe_promote
+from pandas.core.dtypes.common import ensure_object, is_list_like, is_object_dtype, pandas_dtype
+from pandas.core.dtypes.dtypes import NumpyEADtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCExtensionArray, ABCIndex, ABCSeries
+from pandas.core.dtypes.missing import isna
+import pandas.core.common as com
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pandas._typing import AnyArrayLike, ArrayLike, Dtype, DtypeObj, T
+    from pandas import Index, Series
+    from pandas.core.arrays import DatetimeArray, ExtensionArray, TimedeltaArray
+
+def array(data: Sequence[object] | AnyArrayLike, dtype: Dtype | None=None, copy: bool=True) -> ExtensionArray:
+    from pandas.core.arrays import BooleanArray, DatetimeArray, ExtensionArray, FloatingArray, IntegerArray, NumpyExtensionArray, TimedeltaArray
+    from pandas.core.arrays.string_ import StringDtype
+    if lib.is_scalar(data):
+        msg = f"Cannot pass scalar '{data}' to 'pandas.array'."
+        raise ValueError(msg)
+    elif isinstance(data, ABCDataFrame):
+        raise TypeError("Cannot pass DataFrame to 'pandas.array'")
+    if dtype is None and isinstance(data, (ABCSeries, ABCIndex, ExtensionArray)):
+        dtype = data.dtype
+    data = extract_array(data, extract_numpy=True)
+    if dtype is not None:
+        dtype = pandas_dtype(dtype)
+    if isinstance(data, ExtensionArray) and (dtype is None or data.dtype == dtype):
+        if copy:
+            return data.copy()
+        return data
+    if isinstance(dtype, ExtensionDtype):
+        cls = dtype.construct_array_type()
+        return cls._from_sequence(data, dtype=dtype, copy=copy)
+    if dtype is None:
+        was_ndarray = isinstance(data, np.ndarray)
+        if not was_ndarray or data.dtype == object:
+            result = lib.maybe_convert_objects(ensure_object(data), convert_non_numeric=True, convert_to_nullable_dtype=True, dtype_if_all_nat=None)
+            result = ensure_wrapped_if_datetimelike(result)
+            if isinstance(result, np.ndarray):
+                if len(result) == 0 and (not was_ndarray):
+                    return FloatingArray._from_sequence(data, dtype='Float64')
+                return NumpyExtensionArray._from_sequence(data, dtype=result.dtype, copy=copy)
+            if result is data and copy:
+                return result.copy()
+            return result
+        data = cast(np.ndarray, data)
+        result = ensure_wrapped_if_datetimelike(data)
+        if result is not data:
+            result = cast('DatetimeArray | TimedeltaArray', result)
+            if copy and result.dtype == data.dtype:
+                return result.copy()
+            return result
+        if data.dtype.kind in 'SU':
+            dtype = StringDtype()
+            cls = dtype.construct_array_type()
+            return cls._from_sequence(data, dtype=dtype, copy=copy)
+        elif data.dtype.kind in 'iu':
+            return IntegerArray._from_sequence(data, copy=copy)
+        elif data.dtype.kind == 'f':
+            if data.dtype == np.float16:
+                return NumpyExtensionArray._from_sequence(data, dtype=data.dtype, copy=copy)
+            return FloatingArray._from_sequence(data, copy=copy)
+        elif data.dtype.kind == 'b':
+            return BooleanArray._from_sequence(data, dtype='boolean', copy=copy)
+        else:
+            return NumpyExtensionArray._from_sequence(data, dtype=data.dtype, copy=copy)
+    if lib.is_np_dtype(dtype, 'M') and is_supported_dtype(dtype):
+        return DatetimeArray._from_sequence(data, dtype=dtype, copy=copy)
+    if lib.is_np_dtype(dtype, 'm') and is_supported_dtype(dtype):
+        return TimedeltaArray._from_sequence(data, dtype=dtype, copy=copy)
+    elif lib.is_np_dtype(dtype, 'mM'):
+        raise ValueError("datetime64 and timedelta64 dtype resolutions other than 's', 'ms', 'us', and 'ns' are no longer supported.")
+    return NumpyExtensionArray._from_sequence(data, dtype=dtype, copy=copy)
+_typs = frozenset({'index', 'rangeindex', 'multiindex', 'datetimeindex', 'timedeltaindex', 'periodindex', 'categoricalindex', 'intervalindex', 'series'})
+
+@overload
+def extract_array(obj: Series | Index, extract_numpy: bool=..., extract_range: bool=...) -> ArrayLike:
+    ...
+
+@overload
+def extract_array(obj: T, extract_numpy: bool=..., extract_range: bool=...) -> T | ArrayLike:
+    ...
+
+def extract_array(obj: T, extract_numpy: bool=False, extract_range: bool=False) -> T | ArrayLike:
+    typ = getattr(obj, '_typ', None)
+    if typ in _typs:
+        if typ == 'rangeindex':
+            if extract_range:
+                return obj._values
+            return obj
+        return obj._values
+    elif extract_numpy and typ == 'npy_extension':
+        return obj.to_numpy()
+    return obj
+
+def ensure_wrapped_if_datetimelike(arr):
+    if isinstance(arr, np.ndarray):
+        if arr.dtype.kind == 'M':
+            from pandas.core.arrays import DatetimeArray
+            dtype = get_supported_dtype(arr.dtype)
+            return DatetimeArray._from_sequence(arr, dtype=dtype)
+        elif arr.dtype.kind == 'm':
+            from pandas.core.arrays import TimedeltaArray
+            dtype = get_supported_dtype(arr.dtype)
+            return TimedeltaArray._from_sequence(arr, dtype=dtype)
+    return arr
+
+def sanitize_masked_array(data: ma.MaskedArray) -> np.ndarray:
+    mask = ma.getmaskarray(data)
+    if mask.any():
+        (dtype, fill_value) = maybe_promote(data.dtype, np.nan)
+        dtype = cast(np.dtype, dtype)
+        data = ma.asarray(data.astype(dtype, copy=True))
+        data.soften_mask()
+        data[mask] = fill_value
+    else:
+        data = data.copy()
+    return data
+
+def sanitize_array(data, index: Index | None, dtype: DtypeObj | None=None, copy: bool=False, *, allow_2d: bool=False) -> ArrayLike:
+    original_dtype = dtype
+    if isinstance(data, ma.MaskedArray):
+        data = sanitize_masked_array(data)
+    if isinstance(dtype, NumpyEADtype):
+        dtype = dtype.numpy_dtype
+    infer_object = not isinstance(data, (ABCIndex, ABCSeries))
+    data = extract_array(data, extract_numpy=True, extract_range=True)
+    if isinstance(data, np.ndarray) and data.ndim == 0:
+        if dtype is None:
+            dtype = data.dtype
+        data = lib.item_from_zerodim(data)
+    elif isinstance(data, range):
+        data = range_to_ndarray(data)
+        copy = False
+    if not is_list_like(data):
+        if index is None:
+            raise ValueError('index must be specified when data is not list-like')
+        if isinstance(data, str) and using_string_dtype() and (original_dtype is None):
+            from pandas.core.arrays.string_ import StringDtype
+            dtype = StringDtype(na_value=np.nan)
+        data = construct_1d_arraylike_from_scalar(data, len(index), dtype)
+        return data
+    elif isinstance(data, ABCExtensionArray):
+        if dtype is not None:
+            subarr = data.astype(dtype, copy=copy)
+        elif copy:
+            subarr = data.copy()
+        else:
+            subarr = data
+    elif isinstance(dtype, ExtensionDtype):
+        _sanitize_non_ordered(data)
+        cls = dtype.construct_array_type()
+        subarr = cls._from_sequence(data, dtype=dtype, copy=copy)
+    elif isinstance(data, np.ndarray):
+        if isinstance(data, np.matrix):
+            data = data.A
+        if dtype is None:
+            subarr = data
+            if data.dtype == object and infer_object:
+                subarr = maybe_infer_to_datetimelike(data)
+            elif data.dtype.kind == 'U' and using_string_dtype():
+                from pandas.core.arrays.string_ import StringDtype
+                dtype = StringDtype(na_value=np.nan)
+                subarr = dtype.construct_array_type()._from_sequence(data, dtype=dtype)
+            if (subarr is data or (subarr.dtype == 'str' and subarr.dtype.storage == 'python')) and copy:
+                subarr = subarr.copy()
+        else:
+            subarr = _try_cast(data, dtype, copy)
+    elif hasattr(data, '__array__'):
+        if not copy:
+            data = np.asarray(data)
+        else:
+            data = np.array(data, copy=copy)
+        return sanitize_array(data, index=index, dtype=dtype, copy=False, allow_2d=allow_2d)
+    else:
+        _sanitize_non_ordered(data)
+        data = list(data)
+        if len(data) == 0 and dtype is None:
+            subarr = np.array([], dtype=np.float64)
+        elif dtype is not None:
+            subarr = _try_cast(data, dtype, copy)
+        else:
+            subarr = maybe_convert_platform(data)
+            if subarr.dtype == object:
+                subarr = cast(np.ndarray, subarr)
+                subarr = maybe_infer_to_datetimelike(subarr)
+    subarr = _sanitize_ndim(subarr, data, dtype, index, allow_2d=allow_2d)
+    if isinstance(subarr, np.ndarray):
+        dtype = cast(np.dtype, dtype)
+        subarr = _sanitize_str_dtypes(subarr, data, dtype, copy)
+    return subarr
+
+def range_to_ndarray(rng: range) -> np.ndarray:
+    try:
+        arr = np.arange(rng.start, rng.stop, rng.step, dtype='int64')
+    except OverflowError:
+        if rng.start >= 0 and rng.step > 0 or rng.step < 0 <= rng.stop:
+            try:
+                arr = np.arange(rng.start, rng.stop, rng.step, dtype='uint64')
+            except OverflowError:
+                arr = construct_1d_object_array_from_listlike(list(rng))
+        else:
+            arr = construct_1d_object_array_from_listlike(list(rng))
+    return arr
+
+def _sanitize_non_ordered(data) -> None:
+    if isinstance(data, (set, frozenset)):
+        raise TypeError(f"'{type(data).__name__}' type is unordered")
+
+def _sanitize_ndim(result: ArrayLike, data, dtype: DtypeObj | None, index: Index | None, *, allow_2d: bool=False) -> ArrayLike:
+    if getattr(result, 'ndim', 0) == 0:
+        raise ValueError('result should be arraylike with ndim > 0')
+    if result.ndim == 1:
+        result = _maybe_repeat(result, index)
+    elif result.ndim > 1:
+        if isinstance(data, np.ndarray):
+            if allow_2d:
+                return result
+            raise ValueError(f'Data must be 1-dimensional, got ndarray of shape {data.shape} instead')
+        if is_object_dtype(dtype) and isinstance(dtype, ExtensionDtype):
+            result = com.asarray_tuplesafe(data, dtype=np.dtype('object'))
+            cls = dtype.construct_array_type()
+            result = cls._from_sequence(result, dtype=dtype)
+        else:
+            result = com.asarray_tuplesafe(data, dtype=dtype)
+    return result
+
+def _sanitize_str_dtypes(result: np.ndarray, data, dtype: np.dtype | None, copy: bool) -> np.ndarray:
+    if issubclass(result.dtype.type, str):
+        if not lib.is_scalar(data):
+            if not np.all(isna(data)):
+                data = np.asarray(data, dtype=dtype)
+            if not copy:
+                result = np.asarray(data, dtype=object)
+            else:
+                result = np.array(data, dtype=object, copy=copy)
+    return result
+
+def _maybe_repeat(arr: ArrayLike, index: Index | None) -> ArrayLike:
+    if index is not None:
+        if 1 == len(arr) != len(index):
+            arr = arr.repeat(len(index))
+    return arr
+
+def _try_cast(arr: list | np.ndarray, dtype: np.dtype, copy: bool) -> ArrayLike:
+    is_ndarray = isinstance(arr, np.ndarray)
+    if dtype == object:
+        if not is_ndarray:
+            subarr = construct_1d_object_array_from_listlike(arr)
+            return subarr
+        return ensure_wrapped_if_datetimelike(arr).astype(dtype, copy=copy)
+    elif dtype.kind == 'U':
+        if is_ndarray:
+            arr = cast(np.ndarray, arr)
+            shape = arr.shape
+            if arr.ndim > 1:
+                arr = arr.ravel()
+        else:
+            shape = (len(arr),)
+        return lib.ensure_string_array(arr, convert_na_value=False, copy=copy).reshape(shape)
+    elif dtype.kind in 'mM':
+        return maybe_cast_to_datetime(arr, dtype)
+    elif dtype.kind in 'iu':
+        subarr = maybe_cast_to_integer_array(arr, dtype)
+    elif not copy:
+        subarr = np.asarray(arr, dtype=dtype)
+    else:
+        subarr = np.array(arr, dtype=dtype, copy=copy)
+    return subarr
+
+# File: pandas-main/pandas/core/dtypes/api.py
+from pandas.core.dtypes.common import is_any_real_numeric_dtype, is_array_like, is_bool, is_bool_dtype, is_categorical_dtype, is_complex, is_complex_dtype, is_datetime64_any_dtype, is_datetime64_dtype, is_datetime64_ns_dtype, is_datetime64tz_dtype, is_dict_like, is_dtype_equal, is_extension_array_dtype, is_file_like, is_float, is_float_dtype, is_hashable, is_int64_dtype, is_integer, is_integer_dtype, is_interval_dtype, is_iterator, is_list_like, is_named_tuple, is_number, is_numeric_dtype, is_object_dtype, is_period_dtype, is_re, is_re_compilable, is_scalar, is_signed_integer_dtype, is_sparse, is_string_dtype, is_timedelta64_dtype, is_timedelta64_ns_dtype, is_unsigned_integer_dtype, pandas_dtype
+__all__ = ['is_any_real_numeric_dtype', 'is_array_like', 'is_bool', 'is_bool_dtype', 'is_categorical_dtype', 'is_complex', 'is_complex_dtype', 'is_datetime64_any_dtype', 'is_datetime64_dtype', 'is_datetime64_ns_dtype', 'is_datetime64tz_dtype', 'is_dict_like', 'is_dtype_equal', 'is_extension_array_dtype', 'is_file_like', 'is_float', 'is_float_dtype', 'is_hashable', 'is_int64_dtype', 'is_integer', 'is_integer_dtype', 'is_interval_dtype', 'is_iterator', 'is_list_like', 'is_named_tuple', 'is_number', 'is_numeric_dtype', 'is_object_dtype', 'is_period_dtype', 'is_re', 'is_re_compilable', 'is_scalar', 'is_signed_integer_dtype', 'is_sparse', 'is_string_dtype', 'is_timedelta64_dtype', 'is_timedelta64_ns_dtype', 'is_unsigned_integer_dtype', 'pandas_dtype']
+
+# File: pandas-main/pandas/core/dtypes/astype.py
+""""""
+from __future__ import annotations
+import inspect
+from typing import TYPE_CHECKING, overload
+import warnings
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.tslibs.timedeltas import array_to_timedelta64
+from pandas.errors import IntCastingNaNError
+from pandas.core.dtypes.common import is_object_dtype, is_string_dtype, pandas_dtype
+from pandas.core.dtypes.dtypes import ExtensionDtype, NumpyEADtype
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike, DtypeObj, IgnoreRaise
+    from pandas.core.arrays import ExtensionArray
+
+@overload
+def _astype_nansafe(arr: np.ndarray, dtype: np.dtype, copy: bool=..., skipna: bool=...) -> np.ndarray:
+    ...
+
+@overload
+def _astype_nansafe(arr: np.ndarray, dtype: ExtensionDtype, copy: bool=..., skipna: bool=...) -> ExtensionArray:
+    ...
+
+def _astype_nansafe(arr: np.ndarray, dtype: DtypeObj, copy: bool=True, skipna: bool=False) -> ArrayLike:
+    if isinstance(dtype, ExtensionDtype):
+        return dtype.construct_array_type()._from_sequence(arr, dtype=dtype, copy=copy)
+    elif not isinstance(dtype, np.dtype):
+        raise ValueError('dtype must be np.dtype or ExtensionDtype')
+    if arr.dtype.kind in 'mM':
+        from pandas.core.construction import ensure_wrapped_if_datetimelike
+        arr = ensure_wrapped_if_datetimelike(arr)
+        res = arr.astype(dtype, copy=copy)
+        return np.asarray(res)
+    if issubclass(dtype.type, str):
+        shape = arr.shape
+        if arr.ndim > 1:
+            arr = arr.ravel()
+        return lib.ensure_string_array(arr, skipna=skipna, convert_na_value=False).reshape(shape)
+    elif np.issubdtype(arr.dtype, np.floating) and dtype.kind in 'iu':
+        return _astype_float_to_int_nansafe(arr, dtype, copy)
+    elif arr.dtype == object:
+        if lib.is_np_dtype(dtype, 'M'):
+            from pandas.core.arrays import DatetimeArray
+            dta = DatetimeArray._from_sequence(arr, dtype=dtype)
+            return dta._ndarray
+        elif lib.is_np_dtype(dtype, 'm'):
+            from pandas.core.construction import ensure_wrapped_if_datetimelike
+            tdvals = array_to_timedelta64(arr).view('m8[ns]')
+            tda = ensure_wrapped_if_datetimelike(tdvals)
+            return tda.astype(dtype, copy=False)._ndarray
+    if dtype.name in ('datetime64', 'timedelta64'):
+        msg = f"The '{dtype.name}' dtype has no unit. Please pass in '{dtype.name}[ns]' instead."
+        raise ValueError(msg)
+    if copy or arr.dtype == object or dtype == object:
+        return arr.astype(dtype, copy=True)
+    return arr.astype(dtype, copy=copy)
+
+def _astype_float_to_int_nansafe(values: np.ndarray, dtype: np.dtype, copy: bool) -> np.ndarray:
+    if not np.isfinite(values).all():
+        raise IntCastingNaNError('Cannot convert non-finite values (NA or inf) to integer')
+    if dtype.kind == 'u':
+        if not (values >= 0).all():
+            raise ValueError(f'Cannot losslessly cast from {values.dtype} to {dtype}')
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', category=RuntimeWarning)
+        return values.astype(dtype, copy=copy)
+
+def astype_array(values: ArrayLike, dtype: DtypeObj, copy: bool=False) -> ArrayLike:
+    if values.dtype == dtype:
+        if copy:
+            return values.copy()
+        return values
+    if not isinstance(values, np.ndarray):
+        values = values.astype(dtype, copy=copy)
+    else:
+        values = _astype_nansafe(values, dtype, copy=copy)
+    if isinstance(dtype, np.dtype) and issubclass(values.dtype.type, str):
+        values = np.array(values, dtype=object)
+    return values
+
+def astype_array_safe(values: ArrayLike, dtype, copy: bool=False, errors: IgnoreRaise='raise') -> ArrayLike:
+    errors_legal_values = ('raise', 'ignore')
+    if errors not in errors_legal_values:
+        invalid_arg = f"Expected value of kwarg 'errors' to be one of {list(errors_legal_values)}. Supplied value is '{errors}'"
+        raise ValueError(invalid_arg)
+    if inspect.isclass(dtype) and issubclass(dtype, ExtensionDtype):
+        msg = f"Expected an instance of {dtype.__name__}, but got the class instead. Try instantiating 'dtype'."
+        raise TypeError(msg)
+    dtype = pandas_dtype(dtype)
+    if isinstance(dtype, NumpyEADtype):
+        dtype = dtype.numpy_dtype
+    try:
+        new_values = astype_array(values, dtype, copy=copy)
+    except (ValueError, TypeError):
+        if errors == 'ignore':
+            new_values = values
+        else:
+            raise
+    return new_values
+
+def astype_is_view(dtype: DtypeObj, new_dtype: DtypeObj) -> bool:
+    if dtype.kind in 'iufb' and dtype.kind == new_dtype.kind:
+        if hasattr(dtype, 'itemsize') and hasattr(new_dtype, 'itemsize'):
+            return dtype.itemsize == new_dtype.itemsize
+    if isinstance(dtype, np.dtype) and (not isinstance(new_dtype, np.dtype)):
+        (new_dtype, dtype) = (dtype, new_dtype)
+    if dtype == new_dtype:
+        return True
+    elif isinstance(dtype, np.dtype) and isinstance(new_dtype, np.dtype):
+        return False
+    elif is_string_dtype(dtype) and is_string_dtype(new_dtype):
+        return True
+    elif is_object_dtype(dtype) and new_dtype.kind == 'O':
+        return True
+    elif dtype.kind in 'mM' and new_dtype.kind in 'mM':
+        dtype = getattr(dtype, 'numpy_dtype', dtype)
+        new_dtype = getattr(new_dtype, 'numpy_dtype', new_dtype)
+        return getattr(dtype, 'unit', None) == getattr(new_dtype, 'unit', None)
+    numpy_dtype = getattr(dtype, 'numpy_dtype', None)
+    new_numpy_dtype = getattr(new_dtype, 'numpy_dtype', None)
+    if numpy_dtype is None and isinstance(dtype, np.dtype):
+        numpy_dtype = dtype
+    if new_numpy_dtype is None and isinstance(new_dtype, np.dtype):
+        new_numpy_dtype = new_dtype
+    if numpy_dtype is not None and new_numpy_dtype is not None:
+        return numpy_dtype == new_numpy_dtype
+    return True
+
+# File: pandas-main/pandas/core/dtypes/base.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, TypeVar, cast, overload
+import numpy as np
+from pandas._libs import missing as libmissing
+from pandas._libs.hashtable import object_hash
+from pandas._libs.properties import cache_readonly
+from pandas.errors import AbstractMethodError
+from pandas.core.dtypes.generic import ABCDataFrame, ABCIndex, ABCSeries
+if TYPE_CHECKING:
+    from pandas._typing import DtypeObj, Self, Shape, npt, type_t
+    from pandas import Index
+    from pandas.core.arrays import ExtensionArray
+    ExtensionDtypeT = TypeVar('ExtensionDtypeT', bound='ExtensionDtype')
+
+class ExtensionDtype:
+    _metadata: tuple[str, ...] = ()
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, str):
+            try:
+                other = self.construct_from_string(other)
+            except TypeError:
+                return False
+        if isinstance(other, type(self)):
+            return all((getattr(self, attr) == getattr(other, attr) for attr in self._metadata))
+        return False
+
+    def __hash__(self) -> int:
+        return object_hash(tuple((getattr(self, attr) for attr in self._metadata)))
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    @property
+    def na_value(self) -> object:
+        return np.nan
+
+    @property
+    def type(self) -> type_t[Any]:
+        raise AbstractMethodError(self)
+
+    @property
+    def kind(self) -> str:
+        return 'O'
+
+    @property
+    def name(self) -> str:
+        raise AbstractMethodError(self)
+
+    @property
+    def names(self) -> list[str] | None:
+        return None
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[ExtensionArray]:
+        raise AbstractMethodError(cls)
+
+    def empty(self, shape: Shape) -> ExtensionArray:
+        cls = self.construct_array_type()
+        return cls._empty(shape, dtype=self)
+
+    @classmethod
+    def construct_from_string(cls, string: str) -> Self:
+        if not isinstance(string, str):
+            raise TypeError(f"'construct_from_string' expects a string, got {type(string)}")
+        assert isinstance(cls.name, str), (cls, type(cls.name))
+        if string != cls.name:
+            raise TypeError(f"Cannot construct a '{cls.__name__}' from '{string}'")
+        return cls()
+
+    @classmethod
+    def is_dtype(cls, dtype: object) -> bool:
+        dtype = getattr(dtype, 'dtype', dtype)
+        if isinstance(dtype, (ABCSeries, ABCIndex, ABCDataFrame, np.dtype)):
+            return False
+        elif dtype is None:
+            return False
+        elif isinstance(dtype, cls):
+            return True
+        if isinstance(dtype, str):
+            try:
+                return cls.construct_from_string(dtype) is not None
+            except TypeError:
+                return False
+        return False
+
+    @property
+    def _is_numeric(self) -> bool:
+        return False
+
+    @property
+    def _is_boolean(self) -> bool:
+        return False
+
+    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
+        if len(set(dtypes)) == 1:
+            return self
+        else:
+            return None
+
+    @property
+    def _can_hold_na(self) -> bool:
+        return True
+
+    @property
+    def _is_immutable(self) -> bool:
+        return False
+
+    @cache_readonly
+    def index_class(self) -> type_t[Index]:
+        from pandas import Index
+        return Index
+
+    @property
+    def _supports_2d(self) -> bool:
+        return False
+
+    @property
+    def _can_fast_transpose(self) -> bool:
+        return False
+
+class StorageExtensionDtype(ExtensionDtype):
+    name: str
+    _metadata = ('storage',)
+
+    def __init__(self, storage: str | None=None) -> None:
+        self.storage = storage
+
+    def __repr__(self) -> str:
+        return f'{self.name}[{self.storage}]'
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, str) and other == self.name:
+            return True
+        return super().__eq__(other)
+
+    def __hash__(self) -> int:
+        return super().__hash__()
+
+    @property
+    def na_value(self) -> libmissing.NAType:
+        return libmissing.NA
+
+def register_extension_dtype(cls: type_t[ExtensionDtypeT]) -> type_t[ExtensionDtypeT]:
+    _registry.register(cls)
+    return cls
+
+class Registry:
+
+    def __init__(self) -> None:
+        self.dtypes: list[type_t[ExtensionDtype]] = []
+
+    def register(self, dtype: type_t[ExtensionDtype]) -> None:
+        if not issubclass(dtype, ExtensionDtype):
+            raise ValueError('can only register pandas extension dtypes')
+        self.dtypes.append(dtype)
+
+    @overload
+    def find(self, dtype: type_t[ExtensionDtypeT]) -> type_t[ExtensionDtypeT]:
+        ...
+
+    @overload
+    def find(self, dtype: ExtensionDtypeT) -> ExtensionDtypeT:
+        ...
+
+    @overload
+    def find(self, dtype: str) -> ExtensionDtype | None:
+        ...
+
+    @overload
+    def find(self, dtype: npt.DTypeLike) -> type_t[ExtensionDtype] | ExtensionDtype | None:
+        ...
+
+    def find(self, dtype: type_t[ExtensionDtype] | ExtensionDtype | npt.DTypeLike) -> type_t[ExtensionDtype] | ExtensionDtype | None:
+        if not isinstance(dtype, str):
+            dtype_type: type_t
+            if not isinstance(dtype, type):
+                dtype_type = type(dtype)
+            else:
+                dtype_type = dtype
+            if issubclass(dtype_type, ExtensionDtype):
+                return cast('ExtensionDtype | type_t[ExtensionDtype]', dtype)
+            return None
+        for dtype_type in self.dtypes:
+            try:
+                return dtype_type.construct_from_string(dtype)
+            except TypeError:
+                pass
+        return None
+_registry = Registry()
+
+# File: pandas-main/pandas/core/dtypes/cast.py
+""""""
+from __future__ import annotations
+import datetime as dt
+import functools
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast, overload
+import warnings
+import numpy as np
+from pandas._config import using_string_dtype
+from pandas._libs import Interval, Period, lib
+from pandas._libs.missing import NA, NAType, checknull
+from pandas._libs.tslibs import NaT, OutOfBoundsDatetime, OutOfBoundsTimedelta, Timedelta, Timestamp, is_supported_dtype
+from pandas._libs.tslibs.timedeltas import array_to_timedelta64
+from pandas.errors import IntCastingNaNError, LossySetitemError
+from pandas.core.dtypes.common import ensure_int8, ensure_int16, ensure_int32, ensure_int64, ensure_object, ensure_str, is_bool, is_complex, is_float, is_integer, is_object_dtype, is_scalar, is_string_dtype, pandas_dtype as pandas_dtype_func
+from pandas.core.dtypes.dtypes import ArrowDtype, BaseMaskedDtype, CategoricalDtype, DatetimeTZDtype, ExtensionDtype, IntervalDtype, PandasExtensionDtype, PeriodDtype
+from pandas.core.dtypes.generic import ABCExtensionArray, ABCIndex, ABCSeries
+from pandas.core.dtypes.inference import is_list_like
+from pandas.core.dtypes.missing import is_valid_na_for_dtype, isna, na_value_for_dtype, notna
+from pandas.io._util import _arrow_dtype_mapping
+if TYPE_CHECKING:
+    from collections.abc import Sequence, Sized
+    from pandas._typing import ArrayLike, Dtype, DtypeObj, NumpyIndexT, Scalar, npt
+    from pandas import Index
+    from pandas.core.arrays import Categorical, DatetimeArray, ExtensionArray, IntervalArray, PeriodArray, TimedeltaArray
+_int8_max = np.iinfo(np.int8).max
+_int16_max = np.iinfo(np.int16).max
+_int32_max = np.iinfo(np.int32).max
+_dtype_obj = np.dtype(object)
+NumpyArrayT = TypeVar('NumpyArrayT', bound=np.ndarray)
+
+def maybe_convert_platform(values: list | tuple | range | np.ndarray | ExtensionArray) -> ArrayLike:
+    arr: ArrayLike
+    if isinstance(values, (list, tuple, range)):
+        arr = construct_1d_object_array_from_listlike(values)
+    else:
+        arr = values
+    if arr.dtype == _dtype_obj:
+        arr = cast(np.ndarray, arr)
+        arr = lib.maybe_convert_objects(arr)
+    return arr
+
+def is_nested_object(obj) -> bool:
+    return bool(isinstance(obj, ABCSeries) and is_object_dtype(obj.dtype) and any((isinstance(v, ABCSeries) for v in obj._values)))
+
+def maybe_box_datetimelike(value: Scalar, dtype: Dtype | None=None) -> Scalar:
+    if dtype == _dtype_obj:
+        pass
+    elif isinstance(value, (np.datetime64, dt.datetime)):
+        value = Timestamp(value)
+    elif isinstance(value, (np.timedelta64, dt.timedelta)):
+        value = Timedelta(value)
+    return value
+
+def maybe_box_native(value: Scalar | None | NAType) -> Scalar | None | NAType:
+    if is_float(value):
+        value = float(value)
+    elif is_integer(value):
+        value = int(value)
+    elif is_bool(value):
+        value = bool(value)
+    elif isinstance(value, (np.datetime64, np.timedelta64)):
+        value = maybe_box_datetimelike(value)
+    elif value is NA:
+        value = None
+    return value
+
+def _maybe_unbox_datetimelike(value: Scalar, dtype: DtypeObj) -> Scalar:
+    if is_valid_na_for_dtype(value, dtype):
+        value = dtype.type('NaT', 'ns')
+    elif isinstance(value, Timestamp):
+        if value.tz is None:
+            value = value.to_datetime64()
+        elif not isinstance(dtype, DatetimeTZDtype):
+            raise TypeError('Cannot unbox tzaware Timestamp to tznaive dtype')
+    elif isinstance(value, Timedelta):
+        value = value.to_timedelta64()
+    _disallow_mismatched_datetimelike(value, dtype)
+    return value
+
+def _disallow_mismatched_datetimelike(value, dtype: DtypeObj) -> None:
+    vdtype = getattr(value, 'dtype', None)
+    if vdtype is None:
+        return
+    elif vdtype.kind == 'm' and dtype.kind == 'M' or (vdtype.kind == 'M' and dtype.kind == 'm'):
+        raise TypeError(f'Cannot cast {value!r} to {dtype}')
+
+@overload
+def maybe_downcast_to_dtype(result: np.ndarray, dtype: str | np.dtype) -> np.ndarray:
+    ...
+
+@overload
+def maybe_downcast_to_dtype(result: ExtensionArray, dtype: str | np.dtype) -> ArrayLike:
+    ...
+
+def maybe_downcast_to_dtype(result: ArrayLike, dtype: str | np.dtype) -> ArrayLike:
+    if isinstance(result, ABCSeries):
+        result = result._values
+    do_round = False
+    if isinstance(dtype, str):
+        if dtype == 'infer':
+            inferred_type = lib.infer_dtype(result, skipna=False)
+            if inferred_type == 'boolean':
+                dtype = 'bool'
+            elif inferred_type == 'integer':
+                dtype = 'int64'
+            elif inferred_type == 'datetime64':
+                dtype = 'datetime64[ns]'
+            elif inferred_type in ['timedelta', 'timedelta64']:
+                dtype = 'timedelta64[ns]'
+            elif inferred_type == 'floating':
+                dtype = 'int64'
+                if issubclass(result.dtype.type, np.number):
+                    do_round = True
+            else:
+                dtype = 'object'
+        dtype = np.dtype(dtype)
+    if not isinstance(dtype, np.dtype):
+        raise TypeError(dtype)
+    converted = maybe_downcast_numeric(result, dtype, do_round)
+    if converted is not result:
+        return converted
+    if dtype.kind in 'mM' and result.dtype.kind in 'if':
+        result = result.astype(dtype)
+    elif dtype.kind == 'm' and result.dtype == _dtype_obj:
+        result = cast(np.ndarray, result)
+        result = array_to_timedelta64(result)
+    elif dtype == np.dtype('M8[ns]') and result.dtype == _dtype_obj:
+        result = cast(np.ndarray, result)
+        return np.asarray(maybe_cast_to_datetime(result, dtype=dtype))
+    return result
+
+@overload
+def maybe_downcast_numeric(result: np.ndarray, dtype: np.dtype, do_round: bool=False) -> np.ndarray:
+    ...
+
+@overload
+def maybe_downcast_numeric(result: ExtensionArray, dtype: DtypeObj, do_round: bool=False) -> ArrayLike:
+    ...
+
+def maybe_downcast_numeric(result: ArrayLike, dtype: DtypeObj, do_round: bool=False) -> ArrayLike:
+    if not isinstance(dtype, np.dtype) or not isinstance(result.dtype, np.dtype):
+        return result
+
+    def trans(x):
+        if do_round:
+            return x.round()
+        return x
+    if dtype.kind == result.dtype.kind:
+        if result.dtype.itemsize <= dtype.itemsize and result.size:
+            return result
+    if dtype.kind in 'biu':
+        if not result.size:
+            return trans(result).astype(dtype)
+        if isinstance(result, np.ndarray):
+            element = result.item(0)
+        else:
+            element = result.iloc[0]
+        if not isinstance(element, (np.integer, np.floating, int, float, bool)):
+            return result
+        if issubclass(result.dtype.type, (np.object_, np.number)) and notna(result).all():
+            new_result = trans(result).astype(dtype)
+            if new_result.dtype.kind == 'O' or result.dtype.kind == 'O':
+                if (new_result == result).all():
+                    return new_result
+            elif np.allclose(new_result, result, rtol=0):
+                return new_result
+    elif issubclass(dtype.type, np.floating) and result.dtype.kind != 'b' and (not is_string_dtype(result.dtype)):
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', 'overflow encountered in cast', RuntimeWarning)
+            new_result = result.astype(dtype)
+        size_tols = {4: 0.0005, 8: 5e-08, 16: 5e-16}
+        atol = size_tols.get(new_result.dtype.itemsize, 0.0)
+        if np.allclose(new_result, result, equal_nan=True, rtol=0.0, atol=atol):
+            return new_result
+    elif dtype.kind == result.dtype.kind == 'c':
+        new_result = result.astype(dtype)
+        if np.array_equal(new_result, result, equal_nan=True):
+            return new_result
+    return result
+
+def maybe_upcast_numeric_to_64bit(arr: NumpyIndexT) -> NumpyIndexT:
+    dtype = arr.dtype
+    if dtype.kind == 'i' and dtype != np.int64:
+        return arr.astype(np.int64)
+    elif dtype.kind == 'u' and dtype != np.uint64:
+        return arr.astype(np.uint64)
+    elif dtype.kind == 'f' and dtype != np.float64:
+        return arr.astype(np.float64)
+    else:
+        return arr
+
+def maybe_cast_pointwise_result(result: ArrayLike, dtype: DtypeObj, numeric_only: bool=False, same_dtype: bool=True) -> ArrayLike:
+    if isinstance(dtype, ExtensionDtype):
+        cls = dtype.construct_array_type()
+        if same_dtype:
+            result = _maybe_cast_to_extension_array(cls, result, dtype=dtype)
+        else:
+            result = _maybe_cast_to_extension_array(cls, result)
+    elif numeric_only and dtype.kind in 'iufcb' or not numeric_only:
+        result = maybe_downcast_to_dtype(result, dtype)
+    return result
+
+def _maybe_cast_to_extension_array(cls: type[ExtensionArray], obj: ArrayLike, dtype: ExtensionDtype | None=None) -> ArrayLike:
+    result: ArrayLike
+    if dtype is not None:
+        try:
+            result = cls._from_scalars(obj, dtype=dtype)
+        except (TypeError, ValueError):
+            return obj
+        return result
+    try:
+        result = cls._from_sequence(obj, dtype=dtype)
+    except Exception:
+        result = obj
+    return result
+
+@overload
+def ensure_dtype_can_hold_na(dtype: np.dtype) -> np.dtype:
+    ...
+
+@overload
+def ensure_dtype_can_hold_na(dtype: ExtensionDtype) -> ExtensionDtype:
+    ...
+
+def ensure_dtype_can_hold_na(dtype: DtypeObj) -> DtypeObj:
+    if isinstance(dtype, ExtensionDtype):
+        if dtype._can_hold_na:
+            return dtype
+        elif isinstance(dtype, IntervalDtype):
+            return IntervalDtype(np.float64, closed=dtype.closed)
+        return _dtype_obj
+    elif dtype.kind == 'b':
+        return _dtype_obj
+    elif dtype.kind in 'iu':
+        return np.dtype(np.float64)
+    return dtype
+_canonical_nans = {np.datetime64: np.datetime64('NaT', 'ns'), np.timedelta64: np.timedelta64('NaT', 'ns'), type(np.nan): np.nan}
+
+def maybe_promote(dtype: np.dtype, fill_value=np.nan):
+    orig = fill_value
+    orig_is_nat = False
+    if checknull(fill_value):
+        if fill_value is not NA:
+            try:
+                orig_is_nat = np.isnat(fill_value)
+            except TypeError:
+                pass
+        fill_value = _canonical_nans.get(type(fill_value), fill_value)
+    try:
+        (dtype, fill_value) = _maybe_promote_cached(dtype, fill_value, type(fill_value))
+    except TypeError:
+        (dtype, fill_value) = _maybe_promote(dtype, fill_value)
+    if dtype == _dtype_obj and orig is not None or (orig_is_nat and np.datetime_data(orig)[0] != 'ns'):
+        fill_value = orig
+    return (dtype, fill_value)
+
+@functools.lru_cache
+def _maybe_promote_cached(dtype, fill_value, fill_value_type):
+    return _maybe_promote(dtype, fill_value)
+
+def _maybe_promote(dtype: np.dtype, fill_value=np.nan):
+    if not is_scalar(fill_value):
+        if dtype != object:
+            raise ValueError('fill_value must be a scalar')
+        dtype = _dtype_obj
+        return (dtype, fill_value)
+    if is_valid_na_for_dtype(fill_value, dtype) and dtype.kind in 'iufcmM':
+        dtype = ensure_dtype_can_hold_na(dtype)
+        fv = na_value_for_dtype(dtype)
+        return (dtype, fv)
+    elif isinstance(dtype, CategoricalDtype):
+        if fill_value in dtype.categories or isna(fill_value):
+            return (dtype, fill_value)
+        else:
+            return (object, ensure_object(fill_value))
+    elif isna(fill_value):
+        dtype = _dtype_obj
+        if fill_value is None:
+            fill_value = np.nan
+        return (dtype, fill_value)
+    if issubclass(dtype.type, np.datetime64):
+        (inferred, fv) = infer_dtype_from_scalar(fill_value)
+        if inferred == dtype:
+            return (dtype, fv)
+        from pandas.core.arrays import DatetimeArray
+        dta = DatetimeArray._from_sequence([], dtype='M8[ns]')
+        try:
+            fv = dta._validate_setitem_value(fill_value)
+            return (dta.dtype, fv)
+        except (ValueError, TypeError):
+            return (_dtype_obj, fill_value)
+    elif issubclass(dtype.type, np.timedelta64):
+        (inferred, fv) = infer_dtype_from_scalar(fill_value)
+        if inferred == dtype:
+            return (dtype, fv)
+        elif inferred.kind == 'm':
+            unit = np.datetime_data(dtype)[0]
+            try:
+                td = Timedelta(fill_value).as_unit(unit, round_ok=False)
+            except OutOfBoundsTimedelta:
+                return (_dtype_obj, fill_value)
+            else:
+                return (dtype, td.asm8)
+        return (_dtype_obj, fill_value)
+    elif is_float(fill_value):
+        if issubclass(dtype.type, np.bool_):
+            dtype = np.dtype(np.object_)
+        elif issubclass(dtype.type, np.integer):
+            dtype = np.dtype(np.float64)
+        elif dtype.kind == 'f':
+            mst = np.min_scalar_type(fill_value)
+            if mst > dtype:
+                dtype = mst
+        elif dtype.kind == 'c':
+            mst = np.min_scalar_type(fill_value)
+            dtype = np.promote_types(dtype, mst)
+    elif is_bool(fill_value):
+        if not issubclass(dtype.type, np.bool_):
+            dtype = np.dtype(np.object_)
+    elif is_integer(fill_value):
+        if issubclass(dtype.type, np.bool_):
+            dtype = np.dtype(np.object_)
+        elif issubclass(dtype.type, np.integer):
+            if not np_can_cast_scalar(fill_value, dtype):
+                mst = np.min_scalar_type(fill_value)
+                dtype = np.promote_types(dtype, mst)
+                if dtype.kind == 'f':
+                    dtype = np.dtype(np.object_)
+    elif is_complex(fill_value):
+        if issubclass(dtype.type, np.bool_):
+            dtype = np.dtype(np.object_)
+        elif issubclass(dtype.type, (np.integer, np.floating)):
+            mst = np.min_scalar_type(fill_value)
+            dtype = np.promote_types(dtype, mst)
+        elif dtype.kind == 'c':
+            mst = np.min_scalar_type(fill_value)
+            if mst > dtype:
+                dtype = mst
+    else:
+        dtype = np.dtype(np.object_)
+    if issubclass(dtype.type, (bytes, str)):
+        dtype = np.dtype(np.object_)
+    fill_value = _ensure_dtype_type(fill_value, dtype)
+    return (dtype, fill_value)
+
+def _ensure_dtype_type(value, dtype: np.dtype):
+    if dtype == _dtype_obj:
+        return value
+    return dtype.type(value)
+
+def infer_dtype_from(val) -> tuple[DtypeObj, Any]:
+    if not is_list_like(val):
+        return infer_dtype_from_scalar(val)
+    return infer_dtype_from_array(val)
+
+def infer_dtype_from_scalar(val) -> tuple[DtypeObj, Any]:
+    dtype: DtypeObj = _dtype_obj
+    if isinstance(val, np.ndarray):
+        if val.ndim != 0:
+            msg = 'invalid ndarray passed to infer_dtype_from_scalar'
+            raise ValueError(msg)
+        dtype = val.dtype
+        val = lib.item_from_zerodim(val)
+    elif isinstance(val, str):
+        dtype = _dtype_obj
+        if using_string_dtype():
+            from pandas.core.arrays.string_ import StringDtype
+            dtype = StringDtype(na_value=np.nan)
+    elif isinstance(val, (np.datetime64, dt.datetime)):
+        try:
+            val = Timestamp(val)
+        except OutOfBoundsDatetime:
+            return (_dtype_obj, val)
+        if val is NaT or val.tz is None:
+            val = val.to_datetime64()
+            dtype = val.dtype
+        else:
+            dtype = DatetimeTZDtype(unit=val.unit, tz=val.tz)
+    elif isinstance(val, (np.timedelta64, dt.timedelta)):
+        try:
+            val = Timedelta(val)
+        except (OutOfBoundsTimedelta, OverflowError):
+            dtype = _dtype_obj
+        else:
+            if val is NaT:
+                val = np.timedelta64('NaT', 'ns')
+            else:
+                val = val.asm8
+            dtype = val.dtype
+    elif is_bool(val):
+        dtype = np.dtype(np.bool_)
+    elif is_integer(val):
+        if isinstance(val, np.integer):
+            dtype = np.dtype(type(val))
+        else:
+            dtype = np.dtype(np.int64)
+        try:
+            np.array(val, dtype=dtype)
+        except OverflowError:
+            dtype = np.array(val).dtype
+    elif is_float(val):
+        if isinstance(val, np.floating):
+            dtype = np.dtype(type(val))
+        else:
+            dtype = np.dtype(np.float64)
+    elif is_complex(val):
+        dtype = np.dtype(np.complex128)
+    if isinstance(val, Period):
+        dtype = PeriodDtype(freq=val.freq)
+    elif isinstance(val, Interval):
+        subtype = infer_dtype_from_scalar(val.left)[0]
+        dtype = IntervalDtype(subtype=subtype, closed=val.closed)
+    return (dtype, val)
+
+def dict_compat(d: dict[Scalar, Scalar]) -> dict[Scalar, Scalar]:
+    return {maybe_box_datetimelike(key): value for (key, value) in d.items()}
+
+def infer_dtype_from_array(arr) -> tuple[DtypeObj, ArrayLike]:
+    if isinstance(arr, np.ndarray):
+        return (arr.dtype, arr)
+    if not is_list_like(arr):
+        raise TypeError("'arr' must be list-like")
+    arr_dtype = getattr(arr, 'dtype', None)
+    if isinstance(arr_dtype, ExtensionDtype):
+        return (arr.dtype, arr)
+    elif isinstance(arr, ABCSeries):
+        return (arr.dtype, np.asarray(arr))
+    inferred = lib.infer_dtype(arr, skipna=False)
+    if inferred in ['string', 'bytes', 'mixed', 'mixed-integer']:
+        return (np.dtype(np.object_), arr)
+    arr = np.asarray(arr)
+    return (arr.dtype, arr)
+
+def _maybe_infer_dtype_type(element):
+    tipo = None
+    if hasattr(element, 'dtype'):
+        tipo = element.dtype
+    elif is_list_like(element):
+        element = np.asarray(element)
+        tipo = element.dtype
+    return tipo
+
+def invalidate_string_dtypes(dtype_set: set[DtypeObj]) -> None:
+    non_string_dtypes = dtype_set - {np.dtype('S').type, np.dtype('<U').type}
+    if non_string_dtypes != dtype_set:
+        raise TypeError("string dtypes are not allowed, use 'object' instead")
+
+def coerce_indexer_dtype(indexer, categories) -> np.ndarray:
+    length = len(categories)
+    if length < _int8_max:
+        return ensure_int8(indexer)
+    elif length < _int16_max:
+        return ensure_int16(indexer)
+    elif length < _int32_max:
+        return ensure_int32(indexer)
+    return ensure_int64(indexer)
+
+def convert_dtypes(input_array: ArrayLike, convert_string: bool=True, convert_integer: bool=True, convert_boolean: bool=True, convert_floating: bool=True, infer_objects: bool=False, dtype_backend: Literal['numpy_nullable', 'pyarrow']='numpy_nullable') -> DtypeObj:
+    from pandas.core.arrays.string_ import StringDtype
+    inferred_dtype: str | DtypeObj
+    if (convert_string or convert_integer or convert_boolean or convert_floating) and isinstance(input_array, np.ndarray):
+        if input_array.dtype == object:
+            inferred_dtype = lib.infer_dtype(input_array)
+        else:
+            inferred_dtype = input_array.dtype
+        if is_string_dtype(inferred_dtype):
+            if not convert_string or inferred_dtype == 'bytes':
+                inferred_dtype = input_array.dtype
+            else:
+                inferred_dtype = pandas_dtype_func('string')
+        if convert_integer:
+            target_int_dtype = pandas_dtype_func('Int64')
+            if input_array.dtype.kind in 'iu':
+                from pandas.core.arrays.integer import NUMPY_INT_TO_DTYPE
+                inferred_dtype = NUMPY_INT_TO_DTYPE.get(input_array.dtype, target_int_dtype)
+            elif input_array.dtype.kind in 'fcb':
+                arr = input_array[notna(input_array)]
+                if (arr.astype(int) == arr).all():
+                    inferred_dtype = target_int_dtype
+                else:
+                    inferred_dtype = input_array.dtype
+            elif infer_objects and input_array.dtype == object and (isinstance(inferred_dtype, str) and inferred_dtype == 'integer'):
+                inferred_dtype = target_int_dtype
+        if convert_floating:
+            if input_array.dtype.kind in 'fcb':
+                from pandas.core.arrays.floating import NUMPY_FLOAT_TO_DTYPE
+                inferred_float_dtype: DtypeObj = NUMPY_FLOAT_TO_DTYPE.get(input_array.dtype, pandas_dtype_func('Float64'))
+                if convert_integer:
+                    arr = input_array[notna(input_array)]
+                    if (arr.astype(int) == arr).all():
+                        inferred_dtype = pandas_dtype_func('Int64')
+                    else:
+                        inferred_dtype = inferred_float_dtype
+                else:
+                    inferred_dtype = inferred_float_dtype
+            elif infer_objects and input_array.dtype == object and (isinstance(inferred_dtype, str) and inferred_dtype == 'mixed-integer-float'):
+                inferred_dtype = pandas_dtype_func('Float64')
+        if convert_boolean:
+            if input_array.dtype.kind == 'b':
+                inferred_dtype = pandas_dtype_func('boolean')
+            elif isinstance(inferred_dtype, str) and inferred_dtype == 'boolean':
+                inferred_dtype = pandas_dtype_func('boolean')
+        if isinstance(inferred_dtype, str):
+            inferred_dtype = input_array.dtype
+    elif convert_string and isinstance(input_array.dtype, StringDtype) and (input_array.dtype.na_value is np.nan):
+        inferred_dtype = pandas_dtype_func('string')
+    else:
+        inferred_dtype = input_array.dtype
+    if dtype_backend == 'pyarrow':
+        from pandas.core.arrays.arrow.array import to_pyarrow_type
+        from pandas.core.arrays.string_ import StringDtype
+        assert not isinstance(inferred_dtype, str)
+        if convert_integer and inferred_dtype.kind in 'iu' or (convert_floating and inferred_dtype.kind in 'fc') or (convert_boolean and inferred_dtype.kind == 'b') or (convert_string and isinstance(inferred_dtype, StringDtype)) or (inferred_dtype.kind not in 'iufcb' and (not isinstance(inferred_dtype, StringDtype))):
+            if isinstance(inferred_dtype, PandasExtensionDtype) and (not isinstance(inferred_dtype, DatetimeTZDtype)):
+                base_dtype = inferred_dtype.base
+            elif isinstance(inferred_dtype, (BaseMaskedDtype, ArrowDtype)):
+                base_dtype = inferred_dtype.numpy_dtype
+            elif isinstance(inferred_dtype, StringDtype):
+                base_dtype = np.dtype(str)
+            else:
+                base_dtype = inferred_dtype
+            if base_dtype.kind == 'O' and input_array.size > 0 and isna(input_array).all():
+                import pyarrow as pa
+                pa_type = pa.null()
+            else:
+                pa_type = to_pyarrow_type(base_dtype)
+            if pa_type is not None:
+                inferred_dtype = ArrowDtype(pa_type)
+    elif dtype_backend == 'numpy_nullable' and isinstance(inferred_dtype, ArrowDtype):
+        inferred_dtype = _arrow_dtype_mapping()[inferred_dtype.pyarrow_dtype]
+    return inferred_dtype
+
+def maybe_infer_to_datetimelike(value: npt.NDArray[np.object_]) -> np.ndarray | DatetimeArray | TimedeltaArray | PeriodArray | IntervalArray:
+    if not isinstance(value, np.ndarray) or value.dtype != object:
+        raise TypeError(type(value))
+    if value.ndim != 1:
+        raise ValueError(value.ndim)
+    if not len(value):
+        return value
+    return lib.maybe_convert_objects(value, convert_numeric=False, convert_non_numeric=True, dtype_if_all_nat=np.dtype('M8[s]'))
+
+def maybe_cast_to_datetime(value: np.ndarray | list, dtype: np.dtype) -> ExtensionArray | np.ndarray:
+    from pandas.core.arrays.datetimes import DatetimeArray
+    from pandas.core.arrays.timedeltas import TimedeltaArray
+    assert dtype.kind in 'mM'
+    if not is_list_like(value):
+        raise TypeError('value must be listlike')
+    _ensure_nanosecond_dtype(dtype)
+    if lib.is_np_dtype(dtype, 'm'):
+        res = TimedeltaArray._from_sequence(value, dtype=dtype)
+        return res
+    else:
+        try:
+            dta = DatetimeArray._from_sequence(value, dtype=dtype)
+        except ValueError as err:
+            if 'cannot supply both a tz and a timezone-naive dtype' in str(err):
+                raise ValueError('Cannot convert timezone-aware data to timezone-naive dtype. Use pd.Series(values).dt.tz_localize(None) instead.') from err
+            raise
+        return dta
+
+def _ensure_nanosecond_dtype(dtype: DtypeObj) -> None:
+    msg = f"The '{dtype.name}' dtype has no unit. Please pass in '{dtype.name}[ns]' instead."
+    dtype = getattr(dtype, 'subtype', dtype)
+    if not isinstance(dtype, np.dtype):
+        pass
+    elif dtype.kind in 'mM':
+        if not is_supported_dtype(dtype):
+            if dtype.name in ['datetime64', 'timedelta64']:
+                raise ValueError(msg)
+            raise TypeError(f"dtype={dtype} is not supported. Supported resolutions are 's', 'ms', 'us', and 'ns'")
+
+def find_result_type(left_dtype: DtypeObj, right: Any) -> DtypeObj:
+    new_dtype: DtypeObj
+    if isinstance(left_dtype, np.dtype) and left_dtype.kind in 'iuc' and (lib.is_integer(right) or lib.is_float(right)):
+        if lib.is_float(right) and right.is_integer() and (left_dtype.kind != 'f'):
+            right = int(right)
+        if isinstance(right, int) and (not isinstance(right, np.integer)):
+            right_dtype = np.min_scalar_type(right)
+            if right == 0:
+                right = left_dtype
+            elif not np.issubdtype(left_dtype, np.unsignedinteger) and 0 < right <= np.iinfo(right_dtype).max:
+                right = np.dtype(f'i{right_dtype.itemsize}')
+            else:
+                right = right_dtype
+        new_dtype = np.result_type(left_dtype, right)
+    elif is_valid_na_for_dtype(right, left_dtype):
+        new_dtype = ensure_dtype_can_hold_na(left_dtype)
+    else:
+        (dtype, _) = infer_dtype_from(right)
+        new_dtype = find_common_type([left_dtype, dtype])
+    return new_dtype
+
+def common_dtype_categorical_compat(objs: Sequence[Index | ArrayLike], dtype: DtypeObj) -> DtypeObj:
+    if lib.is_np_dtype(dtype, 'iu'):
+        for obj in objs:
+            obj_dtype = getattr(obj, 'dtype', None)
+            if isinstance(obj_dtype, CategoricalDtype):
+                if isinstance(obj, ABCIndex):
+                    hasnas = obj.hasnans
+                else:
+                    hasnas = cast('Categorical', obj)._hasna
+                if hasnas:
+                    dtype = np.dtype(np.float64)
+                    break
+    return dtype
+
+def np_find_common_type(*dtypes: np.dtype) -> np.dtype:
+    try:
+        common_dtype = np.result_type(*dtypes)
+        if common_dtype.kind in 'mMSU':
+            common_dtype = np.dtype('O')
+    except TypeError:
+        common_dtype = np.dtype('O')
+    return common_dtype
+
+@overload
+def find_common_type(types: list[np.dtype]) -> np.dtype:
+    ...
+
+@overload
+def find_common_type(types: list[ExtensionDtype]) -> DtypeObj:
+    ...
+
+@overload
+def find_common_type(types: list[DtypeObj]) -> DtypeObj:
+    ...
+
+def find_common_type(types):
+    if not types:
+        raise ValueError('no types given')
+    first = types[0]
+    if lib.dtypes_all_equal(list(types)):
+        return first
+    types = list(dict.fromkeys(types).keys())
+    if any((isinstance(t, ExtensionDtype) for t in types)):
+        for t in types:
+            if isinstance(t, ExtensionDtype):
+                res = t._get_common_dtype(types)
+                if res is not None:
+                    return res
+        return np.dtype('object')
+    if all((lib.is_np_dtype(t, 'M') for t in types)):
+        return np.dtype(max(types))
+    if all((lib.is_np_dtype(t, 'm') for t in types)):
+        return np.dtype(max(types))
+    has_bools = any((t.kind == 'b' for t in types))
+    if has_bools:
+        for t in types:
+            if t.kind in 'iufc':
+                return np.dtype('object')
+    return np_find_common_type(*types)
+
+def construct_2d_arraylike_from_scalar(value: Scalar, length: int, width: int, dtype: np.dtype, copy: bool) -> np.ndarray:
+    shape = (length, width)
+    if dtype.kind in 'mM':
+        value = _maybe_box_and_unbox_datetimelike(value, dtype)
+    elif dtype == _dtype_obj:
+        if isinstance(value, (np.timedelta64, np.datetime64)):
+            out = np.empty(shape, dtype=object)
+            out.fill(value)
+            return out
+    try:
+        if not copy:
+            arr = np.asarray(value, dtype=dtype)
+        else:
+            arr = np.array(value, dtype=dtype, copy=copy)
+    except (ValueError, TypeError) as err:
+        raise TypeError(f'DataFrame constructor called with incompatible data and dtype: {err}') from err
+    if arr.ndim != 0:
+        raise ValueError('DataFrame constructor not properly called!')
+    return np.full(shape, arr)
+
+def construct_1d_arraylike_from_scalar(value: Scalar, length: int, dtype: DtypeObj | None) -> ArrayLike:
+    if dtype is None:
+        try:
+            (dtype, value) = infer_dtype_from_scalar(value)
+        except OutOfBoundsDatetime:
+            dtype = _dtype_obj
+    if isinstance(dtype, ExtensionDtype):
+        cls = dtype.construct_array_type()
+        seq = [] if length == 0 else [value]
+        return cls._from_sequence(seq, dtype=dtype).repeat(length)
+    if length and dtype.kind in 'iu' and isna(value):
+        dtype = np.dtype('float64')
+    elif lib.is_np_dtype(dtype, 'US'):
+        dtype = np.dtype('object')
+        if not isna(value):
+            value = ensure_str(value)
+    elif dtype.kind in 'mM':
+        value = _maybe_box_and_unbox_datetimelike(value, dtype)
+    subarr = np.empty(length, dtype=dtype)
+    if length:
+        subarr.fill(value)
+    return subarr
+
+def _maybe_box_and_unbox_datetimelike(value: Scalar, dtype: DtypeObj):
+    if isinstance(value, dt.datetime):
+        value = maybe_box_datetimelike(value, dtype)
+    return _maybe_unbox_datetimelike(value, dtype)
+
+def construct_1d_object_array_from_listlike(values: Sized) -> np.ndarray:
+    result = np.empty(len(values), dtype='object')
+    result[:] = values
+    return result
+
+def maybe_cast_to_integer_array(arr: list | np.ndarray, dtype: np.dtype) -> np.ndarray:
+    assert dtype.kind in 'iu'
+    try:
+        if not isinstance(arr, np.ndarray):
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore', 'NumPy will stop allowing conversion of out-of-bound Python int', DeprecationWarning)
+                casted = np.asarray(arr, dtype=dtype)
+        else:
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore', category=RuntimeWarning)
+                casted = arr.astype(dtype, copy=False)
+    except OverflowError as err:
+        raise OverflowError(f'The elements provided in the data cannot all be casted to the dtype {dtype}') from err
+    if isinstance(arr, np.ndarray) and arr.dtype == dtype:
+        return casted
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', category=RuntimeWarning)
+        warnings.filterwarnings('ignore', 'elementwise comparison failed', FutureWarning)
+        if np.array_equal(arr, casted):
+            return casted
+    arr = np.asarray(arr)
+    if np.issubdtype(arr.dtype, str):
+        if (casted.astype(str) == arr).all():
+            return casted
+        raise ValueError(f'string values cannot be losslessly cast to {dtype}')
+    if dtype.kind == 'u' and (arr < 0).any():
+        raise OverflowError('Trying to coerce negative values to unsigned integers')
+    if arr.dtype.kind == 'f':
+        if not np.isfinite(arr).all():
+            raise IntCastingNaNError('Cannot convert non-finite values (NA or inf) to integer')
+        raise ValueError('Trying to coerce float values to integers')
+    if arr.dtype == object:
+        raise ValueError('Trying to coerce object values to integers')
+    if casted.dtype < arr.dtype:
+        raise ValueError(f'Values are too large to be losslessly converted to {dtype}. To cast anyway, use pd.Series(values).astype({dtype})')
+    if arr.dtype.kind in 'mM':
+        raise TypeError(f'Constructing a Series or DataFrame from {arr.dtype} values and dtype={dtype} is not supported. Use values.view({dtype}) instead.')
+    raise ValueError(f'values cannot be losslessly cast to {dtype}')
+
+def can_hold_element(arr: ArrayLike, element: Any) -> bool:
+    dtype = arr.dtype
+    if not isinstance(dtype, np.dtype) or dtype.kind in 'mM':
+        if isinstance(dtype, (PeriodDtype, IntervalDtype, DatetimeTZDtype, np.dtype)):
+            arr = cast('PeriodArray | DatetimeArray | TimedeltaArray | IntervalArray', arr)
+            try:
+                arr._validate_setitem_value(element)
+                return True
+            except (ValueError, TypeError):
+                return False
+        return True
+    try:
+        np_can_hold_element(dtype, element)
+        return True
+    except (TypeError, LossySetitemError):
+        return False
+
+def np_can_hold_element(dtype: np.dtype, element: Any) -> Any:
+    if dtype == _dtype_obj:
+        return element
+    tipo = _maybe_infer_dtype_type(element)
+    if dtype.kind in 'iu':
+        if isinstance(element, range):
+            if _dtype_can_hold_range(element, dtype):
+                return element
+            raise LossySetitemError
+        if is_integer(element) or (is_float(element) and element.is_integer()):
+            info = np.iinfo(dtype)
+            if info.min <= element <= info.max:
+                return dtype.type(element)
+            raise LossySetitemError
+        if tipo is not None:
+            if tipo.kind not in 'iu':
+                if isinstance(element, np.ndarray) and element.dtype.kind == 'f':
+                    with np.errstate(invalid='ignore'):
+                        casted = element.astype(dtype)
+                    comp = casted == element
+                    if comp.all():
+                        return casted
+                    raise LossySetitemError
+                elif isinstance(element, ABCExtensionArray) and isinstance(element.dtype, CategoricalDtype):
+                    try:
+                        casted = element.astype(dtype)
+                    except (ValueError, TypeError) as err:
+                        raise LossySetitemError from err
+                    comp = casted == element
+                    if not comp.all():
+                        raise LossySetitemError
+                    return casted
+                raise LossySetitemError
+            if dtype.kind == 'u' and isinstance(element, np.ndarray) and (element.dtype.kind == 'i'):
+                casted = element.astype(dtype)
+                if (casted == element).all():
+                    return casted
+                raise LossySetitemError
+            if dtype.itemsize < tipo.itemsize:
+                raise LossySetitemError
+            if not isinstance(tipo, np.dtype):
+                arr = element._values if isinstance(element, ABCSeries) else element
+                if arr._hasna:
+                    raise LossySetitemError
+                return element
+            return element
+        raise LossySetitemError
+    if dtype.kind == 'f':
+        if lib.is_integer(element) or lib.is_float(element):
+            casted = dtype.type(element)
+            if np.isnan(casted) or casted == element:
+                return casted
+            raise LossySetitemError
+        if tipo is not None:
+            if tipo.kind not in 'iuf':
+                raise LossySetitemError
+            if not isinstance(tipo, np.dtype):
+                if element._hasna:
+                    raise LossySetitemError
+                return element
+            elif tipo.itemsize > dtype.itemsize or tipo.kind != dtype.kind:
+                if isinstance(element, np.ndarray):
+                    casted = element.astype(dtype)
+                    if np.array_equal(casted, element, equal_nan=True):
+                        return casted
+                    raise LossySetitemError
+            return element
+        raise LossySetitemError
+    if dtype.kind == 'c':
+        if lib.is_integer(element) or lib.is_complex(element) or lib.is_float(element):
+            if np.isnan(element):
+                return dtype.type(element)
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore')
+                casted = dtype.type(element)
+            if casted == element:
+                return casted
+            raise LossySetitemError
+        if tipo is not None:
+            if tipo.kind in 'iufc':
+                return element
+            raise LossySetitemError
+        raise LossySetitemError
+    if dtype.kind == 'b':
+        if tipo is not None:
+            if tipo.kind == 'b':
+                if not isinstance(tipo, np.dtype):
+                    if element._hasna:
+                        raise LossySetitemError
+                return element
+            raise LossySetitemError
+        if lib.is_bool(element):
+            return element
+        raise LossySetitemError
+    if dtype.kind == 'S':
+        if tipo is not None:
+            if tipo.kind == 'S' and tipo.itemsize <= dtype.itemsize:
+                return element
+            raise LossySetitemError
+        if isinstance(element, bytes) and len(element) <= dtype.itemsize:
+            return element
+        raise LossySetitemError
+    if dtype.kind == 'V':
+        raise LossySetitemError
+    raise NotImplementedError(dtype)
+
+def _dtype_can_hold_range(rng: range, dtype: np.dtype) -> bool:
+    if not len(rng):
+        return True
+    return np_can_cast_scalar(rng.start, dtype) and np_can_cast_scalar(rng.stop, dtype)
+
+def np_can_cast_scalar(element: Scalar, dtype: np.dtype) -> bool:
+    try:
+        np_can_hold_element(dtype, element)
+        return True
+    except (LossySetitemError, NotImplementedError):
+        return False
+
+# File: pandas-main/pandas/core/dtypes/common.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+import warnings
+import numpy as np
+from pandas._libs import Interval, Period, algos, lib
+from pandas._libs.tslibs import conversion
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.base import _registry as registry
+from pandas.core.dtypes.dtypes import CategoricalDtype, DatetimeTZDtype, ExtensionDtype, IntervalDtype, PeriodDtype, SparseDtype
+from pandas.core.dtypes.generic import ABCIndex
+from pandas.core.dtypes.inference import is_array_like, is_bool, is_complex, is_dataclass, is_decimal, is_dict_like, is_file_like, is_float, is_hashable, is_integer, is_iterator, is_list_like, is_named_tuple, is_nested_list_like, is_number, is_re, is_re_compilable, is_scalar, is_sequence
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import ArrayLike, DtypeObj
+DT64NS_DTYPE = conversion.DT64NS_DTYPE
+TD64NS_DTYPE = conversion.TD64NS_DTYPE
+INT64_DTYPE = np.dtype(np.int64)
+_is_scipy_sparse = None
+ensure_float64 = algos.ensure_float64
+ensure_int64 = algos.ensure_int64
+ensure_int32 = algos.ensure_int32
+ensure_int16 = algos.ensure_int16
+ensure_int8 = algos.ensure_int8
+ensure_platform_int = algos.ensure_platform_int
+ensure_object = algos.ensure_object
+ensure_uint64 = algos.ensure_uint64
+
+def ensure_str(value: bytes | Any) -> str:
+    if isinstance(value, bytes):
+        value = value.decode('utf-8')
+    elif not isinstance(value, str):
+        value = str(value)
+    return value
+
+def ensure_python_int(value: int | np.integer) -> int:
+    if not (is_integer(value) or is_float(value)):
+        if not is_scalar(value):
+            raise TypeError(f'Value needs to be a scalar value, was type {type(value).__name__}')
+        raise TypeError(f'Wrong type {type(value)} for value {value}')
+    try:
+        new_value = int(value)
+        assert new_value == value
+    except (TypeError, ValueError, AssertionError) as err:
+        raise TypeError(f'Wrong type {type(value)} for value {value}') from err
+    return new_value
+
+def classes(*klasses) -> Callable:
+    return lambda tipo: issubclass(tipo, klasses)
+
+def _classes_and_not_datetimelike(*klasses) -> Callable:
+    return lambda tipo: issubclass(tipo, klasses) and (not issubclass(tipo, (np.datetime64, np.timedelta64)))
+
+def is_object_dtype(arr_or_dtype) -> bool:
+    return _is_dtype_type(arr_or_dtype, classes(np.object_))
+
+def is_sparse(arr) -> bool:
+    warnings.warn('is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.', DeprecationWarning, stacklevel=2)
+    dtype = getattr(arr, 'dtype', arr)
+    return isinstance(dtype, SparseDtype)
+
+def is_scipy_sparse(arr) -> bool:
+    global _is_scipy_sparse
+    if _is_scipy_sparse is None:
+        try:
+            from scipy.sparse import issparse as _is_scipy_sparse
+        except ImportError:
+            _is_scipy_sparse = lambda _: False
+    assert _is_scipy_sparse is not None
+    return _is_scipy_sparse(arr)
+
+def is_datetime64_dtype(arr_or_dtype) -> bool:
+    if isinstance(arr_or_dtype, np.dtype):
+        return arr_or_dtype.kind == 'M'
+    return _is_dtype_type(arr_or_dtype, classes(np.datetime64))
+
+def is_datetime64tz_dtype(arr_or_dtype) -> bool:
+    warnings.warn('is_datetime64tz_dtype is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.DatetimeTZDtype)` instead.', DeprecationWarning, stacklevel=2)
+    if isinstance(arr_or_dtype, DatetimeTZDtype):
+        return True
+    if arr_or_dtype is None:
+        return False
+    return DatetimeTZDtype.is_dtype(arr_or_dtype)
+
+def is_timedelta64_dtype(arr_or_dtype) -> bool:
+    if isinstance(arr_or_dtype, np.dtype):
+        return arr_or_dtype.kind == 'm'
+    return _is_dtype_type(arr_or_dtype, classes(np.timedelta64))
+
+def is_period_dtype(arr_or_dtype) -> bool:
+    warnings.warn('is_period_dtype is deprecated and will be removed in a future version. Use `isinstance(dtype, pd.PeriodDtype)` instead', DeprecationWarning, stacklevel=2)
+    if isinstance(arr_or_dtype, ExtensionDtype):
+        return arr_or_dtype.type is Period
+    if arr_or_dtype is None:
+        return False
+    return PeriodDtype.is_dtype(arr_or_dtype)
+
+def is_interval_dtype(arr_or_dtype) -> bool:
+    warnings.warn('is_interval_dtype is deprecated and will be removed in a future version. Use `isinstance(dtype, pd.IntervalDtype)` instead', DeprecationWarning, stacklevel=2)
+    if isinstance(arr_or_dtype, ExtensionDtype):
+        return arr_or_dtype.type is Interval
+    if arr_or_dtype is None:
+        return False
+    return IntervalDtype.is_dtype(arr_or_dtype)
+
+def is_categorical_dtype(arr_or_dtype) -> bool:
+    warnings.warn('is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, pd.CategoricalDtype) instead', DeprecationWarning, stacklevel=2)
+    if isinstance(arr_or_dtype, ExtensionDtype):
+        return arr_or_dtype.name == 'category'
+    if arr_or_dtype is None:
+        return False
+    return CategoricalDtype.is_dtype(arr_or_dtype)
+
+def is_string_or_object_np_dtype(dtype: np.dtype) -> bool:
+    return dtype == object or dtype.kind in 'SU'
+
+def is_string_dtype(arr_or_dtype) -> bool:
+    if hasattr(arr_or_dtype, 'dtype') and _get_dtype(arr_or_dtype).kind == 'O':
+        return is_all_strings(arr_or_dtype)
+
+    def condition(dtype) -> bool:
+        if is_string_or_object_np_dtype(dtype):
+            return True
+        try:
+            return dtype == 'string'
+        except TypeError:
+            return False
+    return _is_dtype(arr_or_dtype, condition)
+
+def is_dtype_equal(source, target) -> bool:
+    if isinstance(target, str):
+        if not isinstance(source, str):
+            try:
+                src = _get_dtype(source)
+                if isinstance(src, ExtensionDtype):
+                    return src == target
+            except (TypeError, AttributeError, ImportError):
+                return False
+    elif isinstance(source, str):
+        return is_dtype_equal(target, source)
+    try:
+        source = _get_dtype(source)
+        target = _get_dtype(target)
+        return source == target
+    except (TypeError, AttributeError, ImportError):
+        return False
+
+def is_integer_dtype(arr_or_dtype) -> bool:
+    return _is_dtype_type(arr_or_dtype, _classes_and_not_datetimelike(np.integer)) or _is_dtype(arr_or_dtype, lambda typ: isinstance(typ, ExtensionDtype) and typ.kind in 'iu')
+
+def is_signed_integer_dtype(arr_or_dtype) -> bool:
+    return _is_dtype_type(arr_or_dtype, _classes_and_not_datetimelike(np.signedinteger)) or _is_dtype(arr_or_dtype, lambda typ: isinstance(typ, ExtensionDtype) and typ.kind == 'i')
+
+def is_unsigned_integer_dtype(arr_or_dtype) -> bool:
+    return _is_dtype_type(arr_or_dtype, _classes_and_not_datetimelike(np.unsignedinteger)) or _is_dtype(arr_or_dtype, lambda typ: isinstance(typ, ExtensionDtype) and typ.kind == 'u')
+
+def is_int64_dtype(arr_or_dtype) -> bool:
+    warnings.warn('is_int64_dtype is deprecated and will be removed in a future version. Use dtype == np.int64 instead.', DeprecationWarning, stacklevel=2)
+    return _is_dtype_type(arr_or_dtype, classes(np.int64))
+
+def is_datetime64_any_dtype(arr_or_dtype) -> bool:
+    if isinstance(arr_or_dtype, (np.dtype, ExtensionDtype)):
+        return arr_or_dtype.kind == 'M'
+    if arr_or_dtype is None:
+        return False
+    try:
+        tipo = _get_dtype(arr_or_dtype)
+    except TypeError:
+        return False
+    return lib.is_np_dtype(tipo, 'M') or isinstance(tipo, DatetimeTZDtype) or (isinstance(tipo, ExtensionDtype) and tipo.kind == 'M')
+
+def is_datetime64_ns_dtype(arr_or_dtype) -> bool:
+    if arr_or_dtype is None:
+        return False
+    try:
+        tipo = _get_dtype(arr_or_dtype)
+    except TypeError:
+        return False
+    return tipo == DT64NS_DTYPE or (isinstance(tipo, DatetimeTZDtype) and tipo.unit == 'ns')
+
+def is_timedelta64_ns_dtype(arr_or_dtype) -> bool:
+    return _is_dtype(arr_or_dtype, lambda dtype: dtype == TD64NS_DTYPE)
+
+def is_numeric_v_string_like(a: ArrayLike, b) -> bool:
+    is_a_array = isinstance(a, np.ndarray)
+    is_b_array = isinstance(b, np.ndarray)
+    is_a_numeric_array = is_a_array and a.dtype.kind in ('u', 'i', 'f', 'c', 'b')
+    is_b_numeric_array = is_b_array and b.dtype.kind in ('u', 'i', 'f', 'c', 'b')
+    is_a_string_array = is_a_array and a.dtype.kind in ('S', 'U')
+    is_b_string_array = is_b_array and b.dtype.kind in ('S', 'U')
+    is_b_scalar_string_like = not is_b_array and isinstance(b, str)
+    return is_a_numeric_array and is_b_scalar_string_like or (is_a_numeric_array and is_b_string_array) or (is_b_numeric_array and is_a_string_array)
+
+def needs_i8_conversion(dtype: DtypeObj | None) -> bool:
+    if isinstance(dtype, np.dtype):
+        return dtype.kind in 'mM'
+    return isinstance(dtype, (PeriodDtype, DatetimeTZDtype))
+
+def is_numeric_dtype(arr_or_dtype) -> bool:
+    return _is_dtype_type(arr_or_dtype, _classes_and_not_datetimelike(np.number, np.bool_)) or _is_dtype(arr_or_dtype, lambda typ: isinstance(typ, ExtensionDtype) and typ._is_numeric)
+
+def is_any_real_numeric_dtype(arr_or_dtype) -> bool:
+    return is_numeric_dtype(arr_or_dtype) and (not is_complex_dtype(arr_or_dtype)) and (not is_bool_dtype(arr_or_dtype))
+
+def is_float_dtype(arr_or_dtype) -> bool:
+    return _is_dtype_type(arr_or_dtype, classes(np.floating)) or _is_dtype(arr_or_dtype, lambda typ: isinstance(typ, ExtensionDtype) and typ.kind in 'f')
+
+def is_bool_dtype(arr_or_dtype) -> bool:
+    if arr_or_dtype is None:
+        return False
+    try:
+        dtype = _get_dtype(arr_or_dtype)
+    except (TypeError, ValueError):
+        return False
+    if isinstance(dtype, CategoricalDtype):
+        arr_or_dtype = dtype.categories
+    if isinstance(arr_or_dtype, ABCIndex):
+        if arr_or_dtype.inferred_type == 'boolean':
+            if not is_bool_dtype(arr_or_dtype.dtype):
+                warnings.warn('The behavior of is_bool_dtype with an object-dtype Index of bool objects is deprecated. In a future version, this will return False. Cast the Index to a bool dtype instead.', DeprecationWarning, stacklevel=2)
+            return True
+        return False
+    elif isinstance(dtype, ExtensionDtype):
+        return getattr(dtype, '_is_boolean', False)
+    return issubclass(dtype.type, np.bool_)
+
+def is_1d_only_ea_dtype(dtype: DtypeObj | None) -> bool:
+    return isinstance(dtype, ExtensionDtype) and (not dtype._supports_2d)
+
+def is_extension_array_dtype(arr_or_dtype) -> bool:
+    dtype = getattr(arr_or_dtype, 'dtype', arr_or_dtype)
+    if isinstance(dtype, ExtensionDtype):
+        return True
+    elif isinstance(dtype, np.dtype):
+        return False
+    else:
+        return registry.find(dtype) is not None
+
+def is_ea_or_datetimelike_dtype(dtype: DtypeObj | None) -> bool:
+    return isinstance(dtype, ExtensionDtype) or lib.is_np_dtype(dtype, 'mM')
+
+def is_complex_dtype(arr_or_dtype) -> bool:
+    return _is_dtype_type(arr_or_dtype, classes(np.complexfloating))
+
+def _is_dtype(arr_or_dtype, condition) -> bool:
+    if arr_or_dtype is None:
+        return False
+    try:
+        dtype = _get_dtype(arr_or_dtype)
+    except (TypeError, ValueError):
+        return False
+    return condition(dtype)
+
+def _get_dtype(arr_or_dtype) -> DtypeObj:
+    if arr_or_dtype is None:
+        raise TypeError('Cannot deduce dtype from null object')
+    if isinstance(arr_or_dtype, np.dtype):
+        return arr_or_dtype
+    elif isinstance(arr_or_dtype, type):
+        return np.dtype(arr_or_dtype)
+    elif hasattr(arr_or_dtype, 'dtype'):
+        arr_or_dtype = arr_or_dtype.dtype
+    return pandas_dtype(arr_or_dtype)
+
+def _is_dtype_type(arr_or_dtype, condition) -> bool:
+    if arr_or_dtype is None:
+        return condition(type(None))
+    if isinstance(arr_or_dtype, np.dtype):
+        return condition(arr_or_dtype.type)
+    elif isinstance(arr_or_dtype, type):
+        if issubclass(arr_or_dtype, ExtensionDtype):
+            arr_or_dtype = arr_or_dtype.type
+        return condition(np.dtype(arr_or_dtype).type)
+    if hasattr(arr_or_dtype, 'dtype'):
+        arr_or_dtype = arr_or_dtype.dtype
+    elif is_list_like(arr_or_dtype):
+        return condition(type(None))
+    try:
+        tipo = pandas_dtype(arr_or_dtype).type
+    except (TypeError, ValueError):
+        if is_scalar(arr_or_dtype):
+            return condition(type(None))
+        return False
+    return condition(tipo)
+
+def infer_dtype_from_object(dtype) -> type:
+    if isinstance(dtype, type) and issubclass(dtype, np.generic):
+        return dtype
+    elif isinstance(dtype, (np.dtype, ExtensionDtype)):
+        try:
+            _validate_date_like_dtype(dtype)
+        except TypeError:
+            pass
+        if hasattr(dtype, 'numpy_dtype'):
+            return dtype.numpy_dtype.type
+        return dtype.type
+    try:
+        dtype = pandas_dtype(dtype)
+    except TypeError:
+        pass
+    if isinstance(dtype, ExtensionDtype):
+        return dtype.type
+    elif isinstance(dtype, str):
+        if dtype in ['datetimetz', 'datetime64tz']:
+            return DatetimeTZDtype.type
+        elif dtype in ['period']:
+            raise NotImplementedError
+        if dtype in ['datetime', 'timedelta']:
+            dtype += '64'
+        try:
+            return infer_dtype_from_object(getattr(np, dtype))
+        except (AttributeError, TypeError):
+            pass
+    return infer_dtype_from_object(np.dtype(dtype))
+
+def _validate_date_like_dtype(dtype) -> None:
+    try:
+        typ = np.datetime_data(dtype)[0]
+    except ValueError as e:
+        raise TypeError(e) from e
+    if typ not in ['generic', 'ns']:
+        raise ValueError(f'{dtype.name!r} is too specific of a frequency, try passing {dtype.type.__name__!r}')
+
+def validate_all_hashable(*args, error_name: str | None=None) -> None:
+    if not all((is_hashable(arg) for arg in args)):
+        if error_name:
+            raise TypeError(f'{error_name} must be a hashable type')
+        raise TypeError('All elements must be hashable')
+
+def pandas_dtype(dtype) -> DtypeObj:
+    if isinstance(dtype, np.ndarray):
+        return dtype.dtype
+    elif isinstance(dtype, (np.dtype, ExtensionDtype)):
+        return dtype
+    result = registry.find(dtype)
+    if result is not None:
+        if isinstance(result, type):
+            warnings.warn(f'Instantiating {result.__name__} without any arguments.Pass a {result.__name__} instance to silence this warning.', UserWarning, stacklevel=find_stack_level())
+            result = result()
+        return result
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter('always', DeprecationWarning)
+            npdtype = np.dtype(dtype)
+    except SyntaxError as err:
+        raise TypeError(f"data type '{dtype}' not understood") from err
+    if is_hashable(dtype) and dtype in [object, np.object_, 'object', 'O', 'object_']:
+        return npdtype
+    elif npdtype.kind == 'O':
+        raise TypeError(f"dtype '{dtype}' not understood")
+    return npdtype
+
+def is_all_strings(value: ArrayLike) -> bool:
+    dtype = value.dtype
+    if isinstance(dtype, np.dtype):
+        if len(value) == 0:
+            return dtype == np.dtype('object')
+        else:
+            return dtype == np.dtype('object') and lib.is_string_array(np.asarray(value), skipna=False)
+    elif isinstance(dtype, CategoricalDtype):
+        return dtype.categories.inferred_type == 'string'
+    return dtype == 'string'
+__all__ = ['classes', 'DT64NS_DTYPE', 'ensure_float64', 'ensure_python_int', 'ensure_str', 'infer_dtype_from_object', 'INT64_DTYPE', 'is_1d_only_ea_dtype', 'is_all_strings', 'is_any_real_numeric_dtype', 'is_array_like', 'is_bool', 'is_bool_dtype', 'is_categorical_dtype', 'is_complex', 'is_complex_dtype', 'is_dataclass', 'is_datetime64_any_dtype', 'is_datetime64_dtype', 'is_datetime64_ns_dtype', 'is_datetime64tz_dtype', 'is_decimal', 'is_dict_like', 'is_dtype_equal', 'is_ea_or_datetimelike_dtype', 'is_extension_array_dtype', 'is_file_like', 'is_float_dtype', 'is_int64_dtype', 'is_integer_dtype', 'is_interval_dtype', 'is_iterator', 'is_named_tuple', 'is_nested_list_like', 'is_number', 'is_numeric_dtype', 'is_object_dtype', 'is_period_dtype', 'is_re', 'is_re_compilable', 'is_scipy_sparse', 'is_sequence', 'is_signed_integer_dtype', 'is_sparse', 'is_string_dtype', 'is_string_or_object_np_dtype', 'is_timedelta64_dtype', 'is_timedelta64_ns_dtype', 'is_unsigned_integer_dtype', 'needs_i8_conversion', 'pandas_dtype', 'TD64NS_DTYPE', 'validate_all_hashable']
+
+# File: pandas-main/pandas/core/dtypes/concat.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, cast
+import numpy as np
+from pandas._libs import lib
+from pandas.core.dtypes.astype import astype_array
+from pandas.core.dtypes.cast import common_dtype_categorical_compat, find_common_type, np_find_common_type
+from pandas.core.dtypes.dtypes import CategoricalDtype
+from pandas.core.dtypes.generic import ABCCategoricalIndex, ABCSeries
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pandas._typing import ArrayLike, AxisInt, DtypeObj
+    from pandas.core.arrays import Categorical, ExtensionArray
+
+def _is_nonempty(x: ArrayLike, axis: AxisInt) -> bool:
+    if x.ndim <= axis:
+        return True
+    return x.shape[axis] > 0
+
+def concat_compat(to_concat: Sequence[ArrayLike], axis: AxisInt=0, ea_compat_axis: bool=False) -> ArrayLike:
+    if len(to_concat) and lib.dtypes_all_equal([obj.dtype for obj in to_concat]):
+        obj = to_concat[0]
+        if isinstance(obj, np.ndarray):
+            to_concat_arrs = cast('Sequence[np.ndarray]', to_concat)
+            return np.concatenate(to_concat_arrs, axis=axis)
+        to_concat_eas = cast('Sequence[ExtensionArray]', to_concat)
+        if ea_compat_axis:
+            return obj._concat_same_type(to_concat_eas)
+        elif axis == 0:
+            return obj._concat_same_type(to_concat_eas)
+        else:
+            return obj._concat_same_type(to_concat_eas, axis=axis)
+    non_empties = [x for x in to_concat if _is_nonempty(x, axis)]
+    (any_ea, kinds, target_dtype) = _get_result_dtype(to_concat, non_empties)
+    if target_dtype is not None:
+        to_concat = [astype_array(arr, target_dtype, copy=False) for arr in to_concat]
+    if not isinstance(to_concat[0], np.ndarray):
+        to_concat_eas = cast('Sequence[ExtensionArray]', to_concat)
+        cls = type(to_concat[0])
+        if ea_compat_axis or axis == 0:
+            return cls._concat_same_type(to_concat_eas)
+        else:
+            return cls._concat_same_type(to_concat_eas, axis=axis)
+    else:
+        to_concat_arrs = cast('Sequence[np.ndarray]', to_concat)
+        result = np.concatenate(to_concat_arrs, axis=axis)
+        if not any_ea and 'b' in kinds and (result.dtype.kind in 'iuf'):
+            result = result.astype(object, copy=False)
+    return result
+
+def _get_result_dtype(to_concat: Sequence[ArrayLike], non_empties: Sequence[ArrayLike]) -> tuple[bool, set[str], DtypeObj | None]:
+    target_dtype = None
+    dtypes = {obj.dtype for obj in to_concat}
+    kinds = {obj.dtype.kind for obj in to_concat}
+    any_ea = any((not isinstance(x, np.ndarray) for x in to_concat))
+    if any_ea:
+        if len(dtypes) != 1:
+            target_dtype = find_common_type([x.dtype for x in to_concat])
+            target_dtype = common_dtype_categorical_compat(to_concat, target_dtype)
+    elif not len(non_empties):
+        if len(kinds) != 1:
+            if not len(kinds - {'i', 'u', 'f'}) or not len(kinds - {'b', 'i', 'u'}):
+                pass
+            else:
+                target_dtype = np.dtype(object)
+                kinds = {'o'}
+    else:
+        target_dtype = np_find_common_type(*dtypes)
+    return (any_ea, kinds, target_dtype)
+
+def union_categoricals(to_union, sort_categories: bool=False, ignore_order: bool=False) -> Categorical:
+    from pandas import Categorical
+    from pandas.core.arrays.categorical import recode_for_categories
+    if len(to_union) == 0:
+        raise ValueError('No Categoricals to union')
+
+    def _maybe_unwrap(x):
+        if isinstance(x, (ABCCategoricalIndex, ABCSeries)):
+            return x._values
+        elif isinstance(x, Categorical):
+            return x
+        else:
+            raise TypeError('all components to combine must be Categorical')
+    to_union = [_maybe_unwrap(x) for x in to_union]
+    first = to_union[0]
+    if not lib.dtypes_all_equal([obj.categories.dtype for obj in to_union]):
+        raise TypeError('dtype of categories must be the same')
+    ordered = False
+    if all((first._categories_match_up_to_permutation(other) for other in to_union[1:])):
+        categories = first.categories
+        ordered = first.ordered
+        all_codes = [first._encode_with_my_categories(x)._codes for x in to_union]
+        new_codes = np.concatenate(all_codes)
+        if sort_categories and (not ignore_order) and ordered:
+            raise TypeError('Cannot use sort_categories=True with ordered Categoricals')
+        if sort_categories and (not categories.is_monotonic_increasing):
+            categories = categories.sort_values()
+            indexer = categories.get_indexer(first.categories)
+            from pandas.core.algorithms import take_nd
+            new_codes = take_nd(indexer, new_codes, fill_value=-1)
+    elif ignore_order or all((not c.ordered for c in to_union)):
+        cats = first.categories.append([c.categories for c in to_union[1:]])
+        categories = cats.unique()
+        if sort_categories:
+            categories = categories.sort_values()
+        new_codes = [recode_for_categories(c.codes, c.categories, categories) for c in to_union]
+        new_codes = np.concatenate(new_codes)
+    else:
+        if all((c.ordered for c in to_union)):
+            msg = 'to union ordered Categoricals, all categories must be the same'
+            raise TypeError(msg)
+        raise TypeError('Categorical.ordered must be the same')
+    if ignore_order:
+        ordered = False
+    dtype = CategoricalDtype(categories=categories, ordered=ordered)
+    return Categorical._simple_new(new_codes, dtype=dtype)
+
+# File: pandas-main/pandas/core/dtypes/dtypes.py
+""""""
+from __future__ import annotations
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+import re
+from typing import TYPE_CHECKING, Any, cast
+import warnings
+import zoneinfo
+import numpy as np
+from pandas._config.config import get_option
+from pandas._libs import lib, missing as libmissing
+from pandas._libs.interval import Interval
+from pandas._libs.properties import cache_readonly
+from pandas._libs.tslibs import BaseOffset, NaT, NaTType, Period, Timedelta, Timestamp, timezones, to_offset, tz_compare
+from pandas._libs.tslibs.dtypes import PeriodDtypeBase, abbrev_to_npy_unit
+from pandas._libs.tslibs.offsets import BDay
+from pandas.compat import pa_version_under10p1
+from pandas.errors import PerformanceWarning
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.base import ExtensionDtype, StorageExtensionDtype, register_extension_dtype
+from pandas.core.dtypes.generic import ABCCategoricalIndex, ABCIndex, ABCRangeIndex
+from pandas.core.dtypes.inference import is_bool, is_list_like
+if not pa_version_under10p1:
+    import pyarrow as pa
+if TYPE_CHECKING:
+    from collections.abc import MutableMapping
+    from datetime import tzinfo
+    import pyarrow as pa
+    from pandas._typing import Dtype, DtypeObj, IntervalClosedType, Ordered, Scalar, Self, npt, type_t
+    from pandas import Categorical, CategoricalIndex, DatetimeIndex, Index, IntervalIndex, PeriodIndex
+    from pandas.core.arrays import BaseMaskedArray, DatetimeArray, IntervalArray, NumpyExtensionArray, PeriodArray, SparseArray
+    from pandas.core.arrays.arrow import ArrowExtensionArray
+str_type = str
+
+class PandasExtensionDtype(ExtensionDtype):
+    type: Any
+    kind: Any
+    subdtype = None
+    str: str_type
+    num = 100
+    shape: tuple[int, ...] = ()
+    itemsize = 8
+    base: DtypeObj | None = None
+    isbuiltin = 0
+    isnative = 0
+    _cache_dtypes: dict[str_type, PandasExtensionDtype] = {}
+
+    def __repr__(self) -> str_type:
+        return str(self)
+
+    def __hash__(self) -> int:
+        raise NotImplementedError('sub-classes should implement an __hash__ method')
+
+    def __getstate__(self) -> dict[str_type, Any]:
+        return {k: getattr(self, k, None) for k in self._metadata}
+
+    @classmethod
+    def reset_cache(cls) -> None:
+        cls._cache_dtypes = {}
+
+class CategoricalDtypeType(type):
+
+@register_extension_dtype
+class CategoricalDtype(PandasExtensionDtype, ExtensionDtype):
+    name = 'category'
+    type: type[CategoricalDtypeType] = CategoricalDtypeType
+    kind: str_type = 'O'
+    str = '|O08'
+    base = np.dtype('O')
+    _metadata = ('categories', 'ordered')
+    _cache_dtypes: dict[str_type, PandasExtensionDtype] = {}
+    _supports_2d = False
+    _can_fast_transpose = False
+
+    def __init__(self, categories=None, ordered: Ordered=False) -> None:
+        self._finalize(categories, ordered, fastpath=False)
+
+    @classmethod
+    def _from_fastpath(cls, categories=None, ordered: bool | None=None) -> CategoricalDtype:
+        self = cls.__new__(cls)
+        self._finalize(categories, ordered, fastpath=True)
+        return self
+
+    @classmethod
+    def _from_categorical_dtype(cls, dtype: CategoricalDtype, categories=None, ordered: Ordered | None=None) -> CategoricalDtype:
+        if categories is ordered is None:
+            return dtype
+        if categories is None:
+            categories = dtype.categories
+        if ordered is None:
+            ordered = dtype.ordered
+        return cls(categories, ordered)
+
+    @classmethod
+    def _from_values_or_dtype(cls, values=None, categories=None, ordered: bool | None=None, dtype: Dtype | None=None) -> CategoricalDtype:
+        if dtype is not None:
+            if isinstance(dtype, str):
+                if dtype == 'category':
+                    if ordered is None and cls.is_dtype(values):
+                        ordered = values.dtype.ordered
+                    dtype = CategoricalDtype(categories, ordered)
+                else:
+                    raise ValueError(f'Unknown dtype {dtype!r}')
+            elif categories is not None or ordered is not None:
+                raise ValueError('Cannot specify `categories` or `ordered` together with `dtype`.')
+            elif not isinstance(dtype, CategoricalDtype):
+                raise ValueError(f'Cannot not construct CategoricalDtype from {dtype}')
+        elif cls.is_dtype(values):
+            dtype = values.dtype._from_categorical_dtype(values.dtype, categories, ordered)
+        else:
+            dtype = CategoricalDtype(categories, ordered)
+        return cast(CategoricalDtype, dtype)
+
+    @classmethod
+    def construct_from_string(cls, string: str_type) -> CategoricalDtype:
+        if not isinstance(string, str):
+            raise TypeError(f"'construct_from_string' expects a string, got {type(string)}")
+        if string != cls.name:
+            raise TypeError(f"Cannot construct a 'CategoricalDtype' from '{string}'")
+        return cls(ordered=None)
+
+    def _finalize(self, categories, ordered: Ordered, fastpath: bool=False) -> None:
+        if ordered is not None:
+            self.validate_ordered(ordered)
+        if categories is not None:
+            categories = self.validate_categories(categories, fastpath=fastpath)
+        self._categories = categories
+        self._ordered = ordered
+
+    def __setstate__(self, state: MutableMapping[str_type, Any]) -> None:
+        self._categories = state.pop('categories', None)
+        self._ordered = state.pop('ordered', False)
+
+    def __hash__(self) -> int:
+        if self.categories is None:
+            if self.ordered:
+                return -1
+            else:
+                return -2
+        return int(self._hash_categories)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, str):
+            return other == self.name
+        elif other is self:
+            return True
+        elif not (hasattr(other, 'ordered') and hasattr(other, 'categories')):
+            return False
+        elif self.categories is None or other.categories is None:
+            return self.categories is other.categories
+        elif self.ordered or other.ordered:
+            return self.ordered == other.ordered and self.categories.equals(other.categories)
+        else:
+            left = self.categories
+            right = other.categories
+            if not left.dtype == right.dtype:
+                return False
+            if len(left) != len(right):
+                return False
+            if self.categories.equals(other.categories):
+                return True
+            if left.dtype != object:
+                indexer = left.get_indexer(right)
+                return bool((indexer != -1).all())
+            return set(left) == set(right)
+
+    def __repr__(self) -> str_type:
+        if self.categories is None:
+            data = 'None'
+            dtype = 'None'
+        else:
+            data = self.categories._format_data(name=type(self).__name__)
+            if isinstance(self.categories, ABCRangeIndex):
+                data = str(self.categories._range)
+            data = data.rstrip(', ')
+            dtype = self.categories.dtype
+        return f'CategoricalDtype(categories={data}, ordered={self.ordered}, categories_dtype={dtype})'
+
+    @cache_readonly
+    def _hash_categories(self) -> int:
+        from pandas.core.util.hashing import combine_hash_arrays, hash_array, hash_tuples
+        categories = self.categories
+        ordered = self.ordered
+        if len(categories) and isinstance(categories[0], tuple):
+            cat_list = list(categories)
+            cat_array = hash_tuples(cat_list)
+        else:
+            if categories.dtype == 'O' and len({type(x) for x in categories}) != 1:
+                hashed = hash((tuple(categories), ordered))
+                return hashed
+            if DatetimeTZDtype.is_dtype(categories.dtype):
+                categories = categories.view('datetime64[ns]')
+            cat_array = hash_array(np.asarray(categories), categorize=False)
+        if ordered:
+            cat_array = np.vstack([cat_array, np.arange(len(cat_array), dtype=cat_array.dtype)])
+        else:
+            cat_array = cat_array.reshape(1, len(cat_array))
+        combined_hashed = combine_hash_arrays(iter(cat_array), num_items=len(cat_array))
+        return np.bitwise_xor.reduce(combined_hashed)
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[Categorical]:
+        from pandas import Categorical
+        return Categorical
+
+    @staticmethod
+    def validate_ordered(ordered: Ordered) -> None:
+        if not is_bool(ordered):
+            raise TypeError("'ordered' must either be 'True' or 'False'")
+
+    @staticmethod
+    def validate_categories(categories, fastpath: bool=False) -> Index:
+        from pandas.core.indexes.base import Index
+        if not fastpath and (not is_list_like(categories)):
+            raise TypeError(f"Parameter 'categories' must be list-like, was {categories!r}")
+        if not isinstance(categories, ABCIndex):
+            categories = Index._with_infer(categories, tupleize_cols=False)
+        if not fastpath:
+            if categories.hasnans:
+                raise ValueError('Categorical categories cannot be null')
+            if not categories.is_unique:
+                raise ValueError('Categorical categories must be unique')
+        if isinstance(categories, ABCCategoricalIndex):
+            categories = categories.categories
+        return categories
+
+    def update_dtype(self, dtype: str_type | CategoricalDtype) -> CategoricalDtype:
+        if isinstance(dtype, str) and dtype == 'category':
+            return self
+        elif not self.is_dtype(dtype):
+            raise ValueError(f'a CategoricalDtype must be passed to perform an update, got {dtype!r}')
+        else:
+            dtype = cast(CategoricalDtype, dtype)
+        if isinstance(dtype, CategoricalDtype) and dtype.categories is not None and (dtype.ordered is not None):
+            return dtype
+        new_categories = dtype.categories if dtype.categories is not None else self.categories
+        new_ordered = dtype.ordered if dtype.ordered is not None else self.ordered
+        return CategoricalDtype(new_categories, new_ordered)
+
+    @property
+    def categories(self) -> Index:
+        return self._categories
+
+    @property
+    def ordered(self) -> Ordered:
+        return self._ordered
+
+    @property
+    def _is_boolean(self) -> bool:
+        from pandas.core.dtypes.common import is_bool_dtype
+        return is_bool_dtype(self.categories)
+
+    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
+        if all((isinstance(x, CategoricalDtype) for x in dtypes)):
+            first = dtypes[0]
+            if all((first == other for other in dtypes[1:])):
+                return first
+        non_init_cats = [isinstance(x, CategoricalDtype) and x.categories is None for x in dtypes]
+        if all(non_init_cats):
+            return self
+        elif any(non_init_cats):
+            return None
+        subtypes = (x.subtype if isinstance(x, SparseDtype) else x for x in dtypes)
+        non_cat_dtypes = [x.categories.dtype if isinstance(x, CategoricalDtype) else x for x in subtypes]
+        from pandas.core.dtypes.cast import find_common_type
+        return find_common_type(non_cat_dtypes)
+
+    @cache_readonly
+    def index_class(self) -> type_t[CategoricalIndex]:
+        from pandas import CategoricalIndex
+        return CategoricalIndex
+
+@register_extension_dtype
+class DatetimeTZDtype(PandasExtensionDtype):
+    type: type[Timestamp] = Timestamp
+    kind: str_type = 'M'
+    num = 101
+    _metadata = ('unit', 'tz')
+    _match = re.compile('(datetime64|M8)\\[(?P<unit>.+), (?P<tz>.+)\\]')
+    _cache_dtypes: dict[str_type, PandasExtensionDtype] = {}
+    _supports_2d = True
+    _can_fast_transpose = True
+
+    @property
+    def na_value(self) -> NaTType:
+        return NaT
+
+    @cache_readonly
+    def base(self) -> DtypeObj:
+        return np.dtype(f'M8[{self.unit}]')
+
+    @cache_readonly
+    def str(self) -> str:
+        return f'|M8[{self.unit}]'
+
+    def __init__(self, unit: str_type | DatetimeTZDtype='ns', tz=None) -> None:
+        if isinstance(unit, DatetimeTZDtype):
+            (unit, tz) = (unit.unit, unit.tz)
+        if unit != 'ns':
+            if isinstance(unit, str) and tz is None:
+                result = type(self).construct_from_string(unit)
+                unit = result.unit
+                tz = result.tz
+                msg = f"Passing a dtype alias like 'datetime64[ns, {tz}]' to DatetimeTZDtype is no longer supported. Use 'DatetimeTZDtype.construct_from_string()' instead."
+                raise ValueError(msg)
+            if unit not in ['s', 'ms', 'us', 'ns']:
+                raise ValueError('DatetimeTZDtype only supports s, ms, us, ns units')
+        if tz:
+            tz = timezones.maybe_get_tz(tz)
+            tz = timezones.tz_standardize(tz)
+        elif tz is not None:
+            raise zoneinfo.ZoneInfoNotFoundError(tz)
+        if tz is None:
+            raise TypeError("A 'tz' is required.")
+        self._unit = unit
+        self._tz = tz
+
+    @cache_readonly
+    def _creso(self) -> int:
+        return abbrev_to_npy_unit(self.unit)
+
+    @property
+    def unit(self) -> str_type:
+        return self._unit
+
+    @property
+    def tz(self) -> tzinfo:
+        return self._tz
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[DatetimeArray]:
+        from pandas.core.arrays import DatetimeArray
+        return DatetimeArray
+
+    @classmethod
+    def construct_from_string(cls, string: str_type) -> DatetimeTZDtype:
+        if not isinstance(string, str):
+            raise TypeError(f"'construct_from_string' expects a string, got {type(string)}")
+        msg = f"Cannot construct a 'DatetimeTZDtype' from '{string}'"
+        match = cls._match.match(string)
+        if match:
+            d = match.groupdict()
+            try:
+                return cls(unit=d['unit'], tz=d['tz'])
+            except (KeyError, TypeError, ValueError) as err:
+                raise TypeError(msg) from err
+        raise TypeError(msg)
+
+    def __str__(self) -> str_type:
+        return f'datetime64[{self.unit}, {self.tz}]'
+
+    @property
+    def name(self) -> str_type:
+        return str(self)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, str):
+            if other.startswith('M8['):
+                other = f'datetime64[{other[3:]}'
+            return other == self.name
+        return isinstance(other, DatetimeTZDtype) and self.unit == other.unit and tz_compare(self.tz, other.tz)
+
+    def __from_arrow__(self, array: pa.Array | pa.ChunkedArray) -> DatetimeArray:
+        import pyarrow
+        from pandas.core.arrays import DatetimeArray
+        array = array.cast(pyarrow.timestamp(unit=self._unit), safe=True)
+        if isinstance(array, pyarrow.Array):
+            np_arr = array.to_numpy(zero_copy_only=False)
+        else:
+            np_arr = array.to_numpy()
+        return DatetimeArray._simple_new(np_arr, dtype=self)
+
+    def __setstate__(self, state) -> None:
+        self._tz = state['tz']
+        self._unit = state['unit']
+
+    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
+        if all((isinstance(t, DatetimeTZDtype) and t.tz == self.tz for t in dtypes)):
+            np_dtype = np.max([cast(DatetimeTZDtype, t).base for t in [self, *dtypes]])
+            unit = np.datetime_data(np_dtype)[0]
+            return type(self)(unit=unit, tz=self.tz)
+        return super()._get_common_dtype(dtypes)
+
+    @cache_readonly
+    def index_class(self) -> type_t[DatetimeIndex]:
+        from pandas import DatetimeIndex
+        return DatetimeIndex
+
+@register_extension_dtype
+class PeriodDtype(PeriodDtypeBase, PandasExtensionDtype):
+    type: type[Period] = Period
+    kind: str_type = 'O'
+    str = '|O08'
+    base = np.dtype('O')
+    num = 102
+    _metadata = ('freq',)
+    _match = re.compile('(P|p)eriod\\[(?P<freq>.+)\\]')
+    _cache_dtypes: dict[BaseOffset, int] = {}
+    __hash__ = PeriodDtypeBase.__hash__
+    _freq: BaseOffset
+    _supports_2d = True
+    _can_fast_transpose = True
+
+    def __new__(cls, freq) -> PeriodDtype:
+        if isinstance(freq, PeriodDtype):
+            return freq
+        if not isinstance(freq, BaseOffset):
+            freq = cls._parse_dtype_strict(freq)
+        if isinstance(freq, BDay):
+            warnings.warn("PeriodDtype[B] is deprecated and will be removed in a future version. Use a DatetimeIndex with freq='B' instead", FutureWarning, stacklevel=find_stack_level())
+        try:
+            dtype_code = cls._cache_dtypes[freq]
+        except KeyError:
+            dtype_code = freq._period_dtype_code
+            cls._cache_dtypes[freq] = dtype_code
+        u = PeriodDtypeBase.__new__(cls, dtype_code, freq.n)
+        u._freq = freq
+        return u
+
+    def __reduce__(self) -> tuple[type_t[Self], tuple[str_type]]:
+        return (type(self), (self.name,))
+
+    @property
+    def freq(self) -> BaseOffset:
+        return self._freq
+
+    @classmethod
+    def _parse_dtype_strict(cls, freq: str_type) -> BaseOffset:
+        if isinstance(freq, str):
+            if freq.startswith(('Period[', 'period[')):
+                m = cls._match.search(freq)
+                if m is not None:
+                    freq = m.group('freq')
+            freq_offset = to_offset(freq, is_period=True)
+            if freq_offset is not None:
+                return freq_offset
+        raise TypeError(f'PeriodDtype argument should be string or BaseOffset, got {type(freq).__name__}')
+
+    @classmethod
+    def construct_from_string(cls, string: str_type) -> PeriodDtype:
+        if isinstance(string, str) and string.startswith(('period[', 'Period[')) or isinstance(string, BaseOffset):
+            try:
+                return cls(freq=string)
+            except ValueError:
+                pass
+        if isinstance(string, str):
+            msg = f"Cannot construct a 'PeriodDtype' from '{string}'"
+        else:
+            msg = f"'construct_from_string' expects a string, got {type(string)}"
+        raise TypeError(msg)
+
+    def __str__(self) -> str_type:
+        return self.name
+
+    @property
+    def name(self) -> str_type:
+        return f'period[{self._freqstr}]'
+
+    @property
+    def na_value(self) -> NaTType:
+        return NaT
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, str):
+            return other[:1].lower() + other[1:] == self.name
+        return super().__eq__(other)
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    @classmethod
+    def is_dtype(cls, dtype: object) -> bool:
+        if isinstance(dtype, str):
+            if dtype.startswith(('period[', 'Period[')):
+                try:
+                    return cls._parse_dtype_strict(dtype) is not None
+                except ValueError:
+                    return False
+            else:
+                return False
+        return super().is_dtype(dtype)
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[PeriodArray]:
+        from pandas.core.arrays import PeriodArray
+        return PeriodArray
+
+    def __from_arrow__(self, array: pa.Array | pa.ChunkedArray) -> PeriodArray:
+        import pyarrow
+        from pandas.core.arrays import PeriodArray
+        from pandas.core.arrays.arrow._arrow_utils import pyarrow_array_to_numpy_and_mask
+        if isinstance(array, pyarrow.Array):
+            chunks = [array]
+        else:
+            chunks = array.chunks
+        results = []
+        for arr in chunks:
+            (data, mask) = pyarrow_array_to_numpy_and_mask(arr, dtype=np.dtype(np.int64))
+            parr = PeriodArray(data.copy(), dtype=self, copy=False)
+            parr[~mask] = NaT
+            results.append(parr)
+        if not results:
+            return PeriodArray(np.array([], dtype='int64'), dtype=self, copy=False)
+        return PeriodArray._concat_same_type(results)
+
+    @cache_readonly
+    def index_class(self) -> type_t[PeriodIndex]:
+        from pandas import PeriodIndex
+        return PeriodIndex
+
+@register_extension_dtype
+class IntervalDtype(PandasExtensionDtype):
+    name = 'interval'
+    kind: str_type = 'O'
+    str = '|O08'
+    base = np.dtype('O')
+    num = 103
+    _metadata = ('subtype', 'closed')
+    _match = re.compile('(I|i)nterval\\[(?P<subtype>[^,]+(\\[.+\\])?)(, (?P<closed>(right|left|both|neither)))?\\]')
+    _cache_dtypes: dict[str_type, PandasExtensionDtype] = {}
+    _subtype: None | np.dtype
+    _closed: IntervalClosedType | None
+
+    def __init__(self, subtype=None, closed: IntervalClosedType | None=None) -> None:
+        from pandas.core.dtypes.common import is_string_dtype, pandas_dtype
+        if closed is not None and closed not in {'right', 'left', 'both', 'neither'}:
+            raise ValueError("closed must be one of 'right', 'left', 'both', 'neither'")
+        if isinstance(subtype, IntervalDtype):
+            if closed is not None and closed != subtype.closed:
+                raise ValueError("dtype.closed and 'closed' do not match. Try IntervalDtype(dtype.subtype, closed) instead.")
+            self._subtype = subtype._subtype
+            self._closed = subtype._closed
+        elif subtype is None:
+            self._subtype = None
+            self._closed = closed
+        elif isinstance(subtype, str) and subtype.lower() == 'interval':
+            self._subtype = None
+            self._closed = closed
+        else:
+            if isinstance(subtype, str):
+                m = IntervalDtype._match.search(subtype)
+                if m is not None:
+                    gd = m.groupdict()
+                    subtype = gd['subtype']
+                    if gd.get('closed', None) is not None:
+                        if closed is not None:
+                            if closed != gd['closed']:
+                                raise ValueError("'closed' keyword does not match value specified in dtype string")
+                        closed = gd['closed']
+            try:
+                subtype = pandas_dtype(subtype)
+            except TypeError as err:
+                raise TypeError('could not construct IntervalDtype') from err
+            if CategoricalDtype.is_dtype(subtype) or is_string_dtype(subtype):
+                msg = 'category, object, and string subtypes are not supported for IntervalDtype'
+                raise TypeError(msg)
+            self._subtype = subtype
+            self._closed = closed
+
+    @cache_readonly
+    def _can_hold_na(self) -> bool:
+        subtype = self._subtype
+        if subtype is None:
+            raise NotImplementedError('_can_hold_na is not defined for partially-initialized IntervalDtype')
+        if subtype.kind in 'iu':
+            return False
+        return True
+
+    @property
+    def closed(self) -> IntervalClosedType:
+        return self._closed
+
+    @property
+    def subtype(self):
+        return self._subtype
+
+    @classmethod
+    def construct_array_type(cls) -> type[IntervalArray]:
+        from pandas.core.arrays import IntervalArray
+        return IntervalArray
+
+    @classmethod
+    def construct_from_string(cls, string: str_type) -> IntervalDtype:
+        if not isinstance(string, str):
+            raise TypeError(f"'construct_from_string' expects a string, got {type(string)}")
+        if string.lower() == 'interval' or cls._match.search(string) is not None:
+            return cls(string)
+        msg = f"Cannot construct a 'IntervalDtype' from '{string}'.\n\nIncorrectly formatted string passed to constructor. Valid formats include Interval or Interval[dtype] where dtype is numeric, datetime, or timedelta"
+        raise TypeError(msg)
+
+    @property
+    def type(self) -> type[Interval]:
+        return Interval
+
+    def __str__(self) -> str_type:
+        if self.subtype is None:
+            return 'interval'
+        if self.closed is None:
+            return f'interval[{self.subtype}]'
+        return f'interval[{self.subtype}, {self.closed}]'
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, str):
+            return other.lower() in (self.name.lower(), str(self).lower())
+        elif not isinstance(other, IntervalDtype):
+            return False
+        elif self.subtype is None or other.subtype is None:
+            return True
+        elif self.closed != other.closed:
+            return False
+        else:
+            return self.subtype == other.subtype
+
+    def __setstate__(self, state) -> None:
+        self._subtype = state['subtype']
+        self._closed = state.pop('closed', None)
+
+    @classmethod
+    def is_dtype(cls, dtype: object) -> bool:
+        if isinstance(dtype, str):
+            if dtype.lower().startswith('interval'):
+                try:
+                    return cls.construct_from_string(dtype) is not None
+                except (ValueError, TypeError):
+                    return False
+            else:
+                return False
+        return super().is_dtype(dtype)
+
+    def __from_arrow__(self, array: pa.Array | pa.ChunkedArray) -> IntervalArray:
+        import pyarrow
+        from pandas.core.arrays import IntervalArray
+        if isinstance(array, pyarrow.Array):
+            chunks = [array]
+        else:
+            chunks = array.chunks
+        results = []
+        for arr in chunks:
+            if isinstance(arr, pyarrow.ExtensionArray):
+                arr = arr.storage
+            left = np.asarray(arr.field('left'), dtype=self.subtype)
+            right = np.asarray(arr.field('right'), dtype=self.subtype)
+            iarr = IntervalArray.from_arrays(left, right, closed=self.closed)
+            results.append(iarr)
+        if not results:
+            return IntervalArray.from_arrays(np.array([], dtype=self.subtype), np.array([], dtype=self.subtype), closed=self.closed)
+        return IntervalArray._concat_same_type(results)
+
+    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
+        if not all((isinstance(x, IntervalDtype) for x in dtypes)):
+            return None
+        closed = cast('IntervalDtype', dtypes[0]).closed
+        if not all((cast('IntervalDtype', x).closed == closed for x in dtypes)):
+            return np.dtype(object)
+        from pandas.core.dtypes.cast import find_common_type
+        common = find_common_type([cast('IntervalDtype', x).subtype for x in dtypes])
+        if common == object:
+            return np.dtype(object)
+        return IntervalDtype(common, closed=closed)
+
+    @cache_readonly
+    def index_class(self) -> type_t[IntervalIndex]:
+        from pandas import IntervalIndex
+        return IntervalIndex
+
+class NumpyEADtype(ExtensionDtype):
+    _metadata = ('_dtype',)
+    _supports_2d = False
+    _can_fast_transpose = False
+
+    def __init__(self, dtype: npt.DTypeLike | NumpyEADtype | None) -> None:
+        if isinstance(dtype, NumpyEADtype):
+            dtype = dtype.numpy_dtype
+        self._dtype = np.dtype(dtype)
+
+    def __repr__(self) -> str:
+        return f'NumpyEADtype({self.name!r})'
+
+    @property
+    def numpy_dtype(self) -> np.dtype:
+        return self._dtype
+
+    @property
+    def name(self) -> str:
+        return self._dtype.name
+
+    @property
+    def type(self) -> type[np.generic]:
+        return self._dtype.type
+
+    @property
+    def _is_numeric(self) -> bool:
+        return self.kind in set('biufc')
+
+    @property
+    def _is_boolean(self) -> bool:
+        return self.kind == 'b'
+
+    @classmethod
+    def construct_from_string(cls, string: str) -> NumpyEADtype:
+        try:
+            dtype = np.dtype(string)
+        except TypeError as err:
+            if not isinstance(string, str):
+                msg = f"'construct_from_string' expects a string, got {type(string)}"
+            else:
+                msg = f"Cannot construct a 'NumpyEADtype' from '{string}'"
+            raise TypeError(msg) from err
+        return cls(dtype)
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[NumpyExtensionArray]:
+        from pandas.core.arrays import NumpyExtensionArray
+        return NumpyExtensionArray
+
+    @property
+    def kind(self) -> str:
+        return self._dtype.kind
+
+    @property
+    def itemsize(self) -> int:
+        return self._dtype.itemsize
+
+class BaseMaskedDtype(ExtensionDtype):
+    base = None
+    type: type
+    _internal_fill_value: Scalar
+
+    @property
+    def _truthy_value(self):
+        if self.kind == 'f':
+            return 1.0
+        if self.kind in 'iu':
+            return 1
+        return True
+
+    @property
+    def _falsey_value(self):
+        if self.kind == 'f':
+            return 0.0
+        if self.kind in 'iu':
+            return 0
+        return False
+
+    @property
+    def na_value(self) -> libmissing.NAType:
+        return libmissing.NA
+
+    @cache_readonly
+    def numpy_dtype(self) -> np.dtype:
+        return np.dtype(self.type)
+
+    @cache_readonly
+    def kind(self) -> str:
+        return self.numpy_dtype.kind
+
+    @cache_readonly
+    def itemsize(self) -> int:
+        return self.numpy_dtype.itemsize
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[BaseMaskedArray]:
+        raise NotImplementedError
+
+    @classmethod
+    def from_numpy_dtype(cls, dtype: np.dtype) -> BaseMaskedDtype:
+        if dtype.kind == 'b':
+            from pandas.core.arrays.boolean import BooleanDtype
+            return BooleanDtype()
+        elif dtype.kind in 'iu':
+            from pandas.core.arrays.integer import NUMPY_INT_TO_DTYPE
+            return NUMPY_INT_TO_DTYPE[dtype]
+        elif dtype.kind == 'f':
+            from pandas.core.arrays.floating import NUMPY_FLOAT_TO_DTYPE
+            return NUMPY_FLOAT_TO_DTYPE[dtype]
+        else:
+            raise NotImplementedError(dtype)
+
+    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
+        from pandas.core.dtypes.cast import find_common_type
+        new_dtype = find_common_type([dtype.numpy_dtype if isinstance(dtype, BaseMaskedDtype) else dtype for dtype in dtypes])
+        if not isinstance(new_dtype, np.dtype):
+            return None
+        try:
+            return type(self).from_numpy_dtype(new_dtype)
+        except (KeyError, NotImplementedError):
+            return None
+
+@register_extension_dtype
+class SparseDtype(ExtensionDtype):
+    _is_immutable = True
+    _metadata = ('_dtype', '_fill_value', '_is_na_fill_value')
+
+    def __init__(self, dtype: Dtype=np.float64, fill_value: Any=None) -> None:
+        if isinstance(dtype, type(self)):
+            if fill_value is None:
+                fill_value = dtype.fill_value
+            dtype = dtype.subtype
+        from pandas.core.dtypes.common import is_string_dtype, pandas_dtype
+        from pandas.core.dtypes.missing import na_value_for_dtype
+        dtype = pandas_dtype(dtype)
+        if is_string_dtype(dtype):
+            dtype = np.dtype('object')
+        if not isinstance(dtype, np.dtype):
+            raise TypeError('SparseDtype subtype must be a numpy dtype')
+        if fill_value is None:
+            fill_value = na_value_for_dtype(dtype)
+        self._dtype = dtype
+        self._fill_value = fill_value
+        self._check_fill_value()
+
+    def __hash__(self) -> int:
+        return super().__hash__()
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, str):
+            try:
+                other = self.construct_from_string(other)
+            except TypeError:
+                return False
+        if isinstance(other, type(self)):
+            subtype = self.subtype == other.subtype
+            if self._is_na_fill_value or other._is_na_fill_value:
+                fill_value = isinstance(self.fill_value, type(other.fill_value)) or isinstance(other.fill_value, type(self.fill_value))
+            else:
+                with warnings.catch_warnings():
+                    warnings.filterwarnings('ignore', 'elementwise comparison failed', category=DeprecationWarning)
+                    fill_value = self.fill_value == other.fill_value
+            return subtype and fill_value
+        return False
+
+    @property
+    def fill_value(self):
+        return self._fill_value
+
+    def _check_fill_value(self) -> None:
+        if not lib.is_scalar(self._fill_value):
+            raise ValueError(f'fill_value must be a scalar. Got {self._fill_value} instead')
+        from pandas.core.dtypes.cast import can_hold_element
+        from pandas.core.dtypes.missing import is_valid_na_for_dtype, isna
+        from pandas.core.construction import ensure_wrapped_if_datetimelike
+        val = self._fill_value
+        if isna(val):
+            if not is_valid_na_for_dtype(val, self.subtype):
+                raise ValueError('fill_value must be a valid value for the SparseDtype.subtype')
+        else:
+            dummy = np.empty(0, dtype=self.subtype)
+            dummy = ensure_wrapped_if_datetimelike(dummy)
+            if not can_hold_element(dummy, val):
+                raise ValueError('fill_value must be a valid value for the SparseDtype.subtype')
+
+    @property
+    def _is_na_fill_value(self) -> bool:
+        from pandas import isna
+        return isna(self.fill_value)
+
+    @property
+    def _is_numeric(self) -> bool:
+        return not self.subtype == object
+
+    @property
+    def _is_boolean(self) -> bool:
+        return self.subtype.kind == 'b'
+
+    @property
+    def kind(self) -> str:
+        return self.subtype.kind
+
+    @property
+    def type(self):
+        return self.subtype.type
+
+    @property
+    def subtype(self):
+        return self._dtype
+
+    @property
+    def name(self) -> str:
+        return f'Sparse[{self.subtype.name}, {self.fill_value!r}]'
+
+    def __repr__(self) -> str:
+        return self.name
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[SparseArray]:
+        from pandas.core.arrays.sparse.array import SparseArray
+        return SparseArray
+
+    @classmethod
+    def construct_from_string(cls, string: str) -> SparseDtype:
+        if not isinstance(string, str):
+            raise TypeError(f"'construct_from_string' expects a string, got {type(string)}")
+        msg = f"Cannot construct a 'SparseDtype' from '{string}'"
+        if string.startswith('Sparse'):
+            try:
+                (sub_type, has_fill_value) = cls._parse_subtype(string)
+            except ValueError as err:
+                raise TypeError(msg) from err
+            else:
+                result = SparseDtype(sub_type)
+                msg = f"Cannot construct a 'SparseDtype' from '{string}'.\n\nIt looks like the fill_value in the string is not the default for the dtype. Non-default fill_values are not supported. Use the 'SparseDtype()' constructor instead."
+                if has_fill_value and str(result) != string:
+                    raise TypeError(msg)
+                return result
+        else:
+            raise TypeError(msg)
+
+    @staticmethod
+    def _parse_subtype(dtype: str) -> tuple[str, bool]:
+        xpr = re.compile('Sparse\\[(?P<subtype>[^,]*)(, )?(?P<fill_value>.*?)?\\]$')
+        m = xpr.match(dtype)
+        has_fill_value = False
+        if m:
+            subtype = m.groupdict()['subtype']
+            has_fill_value = bool(m.groupdict()['fill_value'])
+        elif dtype == 'Sparse':
+            subtype = 'float64'
+        else:
+            raise ValueError(f'Cannot parse {dtype}')
+        return (subtype, has_fill_value)
+
+    @classmethod
+    def is_dtype(cls, dtype: object) -> bool:
+        dtype = getattr(dtype, 'dtype', dtype)
+        if isinstance(dtype, str) and dtype.startswith('Sparse'):
+            (sub_type, _) = cls._parse_subtype(dtype)
+            dtype = np.dtype(sub_type)
+        elif isinstance(dtype, cls):
+            return True
+        return isinstance(dtype, np.dtype) or dtype == 'Sparse'
+
+    def update_dtype(self, dtype) -> SparseDtype:
+        from pandas.core.dtypes.astype import astype_array
+        from pandas.core.dtypes.common import pandas_dtype
+        cls = type(self)
+        dtype = pandas_dtype(dtype)
+        if not isinstance(dtype, cls):
+            if not isinstance(dtype, np.dtype):
+                raise TypeError('sparse arrays of extension dtypes not supported')
+            fv_asarray = np.atleast_1d(np.array(self.fill_value))
+            fvarr = astype_array(fv_asarray, dtype)
+            fill_value = fvarr[0]
+            dtype = cls(dtype, fill_value=fill_value)
+        return dtype
+
+    @property
+    def _subtype_with_str(self):
+        if isinstance(self.fill_value, str):
+            return type(self.fill_value)
+        return self.subtype
+
+    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
+        from pandas.core.dtypes.cast import np_find_common_type
+        if any((isinstance(x, ExtensionDtype) and (not isinstance(x, SparseDtype)) for x in dtypes)):
+            return None
+        fill_values = [x.fill_value for x in dtypes if isinstance(x, SparseDtype)]
+        fill_value = fill_values[0]
+        from pandas import isna
+        if get_option('performance_warnings') and (not (len(set(fill_values)) == 1 or isna(fill_values).all())):
+            warnings.warn(f"Concatenating sparse arrays with multiple fill values: '{fill_values}'. Picking the first and converting the rest.", PerformanceWarning, stacklevel=find_stack_level())
+        np_dtypes = (x.subtype if isinstance(x, SparseDtype) else x for x in dtypes)
+        return SparseDtype(np_find_common_type(*np_dtypes), fill_value=fill_value)
+
+@register_extension_dtype
+class ArrowDtype(StorageExtensionDtype):
+    _metadata = ('storage', 'pyarrow_dtype')
+
+    def __init__(self, pyarrow_dtype: pa.DataType) -> None:
+        super().__init__('pyarrow')
+        if pa_version_under10p1:
+            raise ImportError('pyarrow>=10.0.1 is required for ArrowDtype')
+        if not isinstance(pyarrow_dtype, pa.DataType):
+            raise ValueError(f'pyarrow_dtype ({pyarrow_dtype}) must be an instance of a pyarrow.DataType. Got {type(pyarrow_dtype)} instead.')
+        self.pyarrow_dtype = pyarrow_dtype
+
+    def __repr__(self) -> str:
+        return self.name
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, type(self)):
+            return super().__eq__(other)
+        return self.pyarrow_dtype == other.pyarrow_dtype
+
+    @property
+    def type(self):
+        pa_type = self.pyarrow_dtype
+        if pa.types.is_integer(pa_type):
+            return int
+        elif pa.types.is_floating(pa_type):
+            return float
+        elif pa.types.is_string(pa_type) or pa.types.is_large_string(pa_type):
+            return str
+        elif pa.types.is_binary(pa_type) or pa.types.is_fixed_size_binary(pa_type) or pa.types.is_large_binary(pa_type):
+            return bytes
+        elif pa.types.is_boolean(pa_type):
+            return bool
+        elif pa.types.is_duration(pa_type):
+            if pa_type.unit == 'ns':
+                return Timedelta
+            else:
+                return timedelta
+        elif pa.types.is_timestamp(pa_type):
+            if pa_type.unit == 'ns':
+                return Timestamp
+            else:
+                return datetime
+        elif pa.types.is_date(pa_type):
+            return date
+        elif pa.types.is_time(pa_type):
+            return time
+        elif pa.types.is_decimal(pa_type):
+            return Decimal
+        elif pa.types.is_dictionary(pa_type):
+            return CategoricalDtypeType
+        elif pa.types.is_list(pa_type) or pa.types.is_large_list(pa_type):
+            return list
+        elif pa.types.is_fixed_size_list(pa_type):
+            return list
+        elif pa.types.is_map(pa_type):
+            return list
+        elif pa.types.is_struct(pa_type):
+            return dict
+        elif pa.types.is_null(pa_type):
+            return type(pa_type)
+        elif isinstance(pa_type, pa.ExtensionType):
+            return type(self)(pa_type.storage_type).type
+        raise NotImplementedError(pa_type)
+
+    @property
+    def name(self) -> str:
+        return f'{self.pyarrow_dtype!s}[{self.storage}]'
+
+    @cache_readonly
+    def numpy_dtype(self) -> np.dtype:
+        if pa.types.is_timestamp(self.pyarrow_dtype):
+            return np.dtype(f'datetime64[{self.pyarrow_dtype.unit}]')
+        if pa.types.is_duration(self.pyarrow_dtype):
+            return np.dtype(f'timedelta64[{self.pyarrow_dtype.unit}]')
+        if pa.types.is_string(self.pyarrow_dtype) or pa.types.is_large_string(self.pyarrow_dtype):
+            return np.dtype(str)
+        try:
+            return np.dtype(self.pyarrow_dtype.to_pandas_dtype())
+        except (NotImplementedError, TypeError):
+            return np.dtype(object)
+
+    @cache_readonly
+    def kind(self) -> str:
+        if pa.types.is_timestamp(self.pyarrow_dtype):
+            return 'M'
+        return self.numpy_dtype.kind
+
+    @cache_readonly
+    def itemsize(self) -> int:
+        return self.numpy_dtype.itemsize
+
+    @classmethod
+    def construct_array_type(cls) -> type_t[ArrowExtensionArray]:
+        from pandas.core.arrays.arrow import ArrowExtensionArray
+        return ArrowExtensionArray
+
+    @classmethod
+    def construct_from_string(cls, string: str) -> ArrowDtype:
+        if not isinstance(string, str):
+            raise TypeError(f"'construct_from_string' expects a string, got {type(string)}")
+        if not string.endswith('[pyarrow]'):
+            raise TypeError(f"'{string}' must end with '[pyarrow]'")
+        if string == 'string[pyarrow]':
+            raise TypeError('string[pyarrow] should be constructed by StringDtype')
+        base_type = string[:-9]
+        try:
+            pa_dtype = pa.type_for_alias(base_type)
+        except ValueError as err:
+            has_parameters = re.search('[\\[\\(].*[\\]\\)]', base_type)
+            if has_parameters:
+                try:
+                    return cls._parse_temporal_dtype_string(base_type)
+                except (NotImplementedError, ValueError):
+                    pass
+                raise NotImplementedError(f'Passing pyarrow type specific parameters ({has_parameters.group()}) in the string is not supported. Please construct an ArrowDtype object with a pyarrow_dtype instance with specific parameters.') from err
+            raise TypeError(f"'{base_type}' is not a valid pyarrow data type.") from err
+        return cls(pa_dtype)
+
+    @classmethod
+    def _parse_temporal_dtype_string(cls, string: str) -> ArrowDtype:
+        (head, tail) = string.split('[', 1)
+        if not tail.endswith(']'):
+            raise ValueError
+        tail = tail[:-1]
+        if head == 'timestamp':
+            assert ',' in tail
+            (unit, tz) = tail.split(',', 1)
+            unit = unit.strip()
+            tz = tz.strip()
+            if tz.startswith('tz='):
+                tz = tz[3:]
+            pa_type = pa.timestamp(unit, tz=tz)
+            dtype = cls(pa_type)
+            return dtype
+        raise NotImplementedError(string)
+
+    @property
+    def _is_numeric(self) -> bool:
+        return pa.types.is_integer(self.pyarrow_dtype) or pa.types.is_floating(self.pyarrow_dtype) or pa.types.is_decimal(self.pyarrow_dtype)
+
+    @property
+    def _is_boolean(self) -> bool:
+        return pa.types.is_boolean(self.pyarrow_dtype)
+
+    def _get_common_dtype(self, dtypes: list[DtypeObj]) -> DtypeObj | None:
+        from pandas.core.dtypes.cast import find_common_type
+        null_dtype = type(self)(pa.null())
+        new_dtype = find_common_type([dtype.numpy_dtype if isinstance(dtype, ArrowDtype) else dtype for dtype in dtypes if dtype != null_dtype])
+        if not isinstance(new_dtype, np.dtype):
+            return None
+        try:
+            pa_dtype = pa.from_numpy_dtype(new_dtype)
+            return type(self)(pa_dtype)
+        except NotImplementedError:
+            return None
+
+    def __from_arrow__(self, array: pa.Array | pa.ChunkedArray) -> ArrowExtensionArray:
+        array_class = self.construct_array_type()
+        arr = array.cast(self.pyarrow_dtype, safe=True)
+        return array_class(arr)
+
+# File: pandas-main/pandas/core/dtypes/generic.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Type, cast
+if TYPE_CHECKING:
+    from pandas import Categorical, CategoricalIndex, DataFrame, DatetimeIndex, Index, IntervalIndex, MultiIndex, PeriodIndex, RangeIndex, Series, TimedeltaIndex
+    from pandas.core.arrays import DatetimeArray, ExtensionArray, NumpyExtensionArray, PeriodArray, TimedeltaArray
+    from pandas.core.generic import NDFrame
+
+def create_pandas_abc_type(name, attr, comp) -> type:
+
+    def _check(inst) -> bool:
+        return getattr(inst, attr, '_typ') in comp
+
+    @classmethod
+    def _instancecheck(cls, inst) -> bool:
+        return _check(inst) and (not isinstance(inst, type))
+
+    @classmethod
+    def _subclasscheck(cls, inst) -> bool:
+        if not isinstance(inst, type):
+            raise TypeError('issubclass() arg 1 must be a class')
+        return _check(inst)
+    dct = {'__instancecheck__': _instancecheck, '__subclasscheck__': _subclasscheck}
+    meta = type('ABCBase', (type,), dct)
+    return meta(name, (), dct)
+ABCRangeIndex = cast('Type[RangeIndex]', create_pandas_abc_type('ABCRangeIndex', '_typ', ('rangeindex',)))
+ABCMultiIndex = cast('Type[MultiIndex]', create_pandas_abc_type('ABCMultiIndex', '_typ', ('multiindex',)))
+ABCDatetimeIndex = cast('Type[DatetimeIndex]', create_pandas_abc_type('ABCDatetimeIndex', '_typ', ('datetimeindex',)))
+ABCTimedeltaIndex = cast('Type[TimedeltaIndex]', create_pandas_abc_type('ABCTimedeltaIndex', '_typ', ('timedeltaindex',)))
+ABCPeriodIndex = cast('Type[PeriodIndex]', create_pandas_abc_type('ABCPeriodIndex', '_typ', ('periodindex',)))
+ABCCategoricalIndex = cast('Type[CategoricalIndex]', create_pandas_abc_type('ABCCategoricalIndex', '_typ', ('categoricalindex',)))
+ABCIntervalIndex = cast('Type[IntervalIndex]', create_pandas_abc_type('ABCIntervalIndex', '_typ', ('intervalindex',)))
+ABCIndex = cast('Type[Index]', create_pandas_abc_type('ABCIndex', '_typ', {'index', 'rangeindex', 'multiindex', 'datetimeindex', 'timedeltaindex', 'periodindex', 'categoricalindex', 'intervalindex'}))
+ABCNDFrame = cast('Type[NDFrame]', create_pandas_abc_type('ABCNDFrame', '_typ', ('series', 'dataframe')))
+ABCSeries = cast('Type[Series]', create_pandas_abc_type('ABCSeries', '_typ', ('series',)))
+ABCDataFrame = cast('Type[DataFrame]', create_pandas_abc_type('ABCDataFrame', '_typ', ('dataframe',)))
+ABCCategorical = cast('Type[Categorical]', create_pandas_abc_type('ABCCategorical', '_typ', 'categorical'))
+ABCDatetimeArray = cast('Type[DatetimeArray]', create_pandas_abc_type('ABCDatetimeArray', '_typ', 'datetimearray'))
+ABCTimedeltaArray = cast('Type[TimedeltaArray]', create_pandas_abc_type('ABCTimedeltaArray', '_typ', 'timedeltaarray'))
+ABCPeriodArray = cast('Type[PeriodArray]', create_pandas_abc_type('ABCPeriodArray', '_typ', ('periodarray',)))
+ABCExtensionArray = cast('Type[ExtensionArray]', create_pandas_abc_type('ABCExtensionArray', '_typ', {'extension', 'categorical', 'periodarray', 'datetimearray', 'timedeltaarray'}))
+ABCNumpyExtensionArray = cast('Type[NumpyExtensionArray]', create_pandas_abc_type('ABCNumpyExtensionArray', '_typ', ('npy_extension',)))
+
+# File: pandas-main/pandas/core/dtypes/inference.py
+""""""
+from __future__ import annotations
+from collections import abc
+from numbers import Number
+import re
+from re import Pattern
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs import lib
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+    from pandas._typing import TypeGuard
+is_bool = lib.is_bool
+is_integer = lib.is_integer
+is_float = lib.is_float
+is_complex = lib.is_complex
+is_scalar = lib.is_scalar
+is_decimal = lib.is_decimal
+is_list_like = lib.is_list_like
+is_iterator = lib.is_iterator
+
+def is_number(obj: object) -> TypeGuard[Number | np.number]:
+    return isinstance(obj, (Number, np.number))
+
+def iterable_not_string(obj: object) -> bool:
+    return isinstance(obj, abc.Iterable) and (not isinstance(obj, str))
+
+def is_file_like(obj: object) -> bool:
+    if not (hasattr(obj, 'read') or hasattr(obj, 'write')):
+        return False
+    return bool(hasattr(obj, '__iter__'))
+
+def is_re(obj: object) -> TypeGuard[Pattern]:
+    return isinstance(obj, Pattern)
+
+def is_re_compilable(obj: object) -> bool:
+    try:
+        re.compile(obj)
+    except TypeError:
+        return False
+    else:
+        return True
+
+def is_array_like(obj: object) -> bool:
+    return is_list_like(obj) and hasattr(obj, 'dtype')
+
+def is_nested_list_like(obj: object) -> bool:
+    return is_list_like(obj) and hasattr(obj, '__len__') and (len(obj) > 0) and all((is_list_like(item) for item in obj))
+
+def is_dict_like(obj: object) -> bool:
+    dict_like_attrs = ('__getitem__', 'keys', '__contains__')
+    return all((hasattr(obj, attr) for attr in dict_like_attrs)) and (not isinstance(obj, type))
+
+def is_named_tuple(obj: object) -> bool:
+    return isinstance(obj, abc.Sequence) and hasattr(obj, '_fields')
+
+def is_hashable(obj: object) -> TypeGuard[Hashable]:
+    try:
+        hash(obj)
+    except TypeError:
+        return False
+    else:
+        return True
+
+def is_sequence(obj: object) -> bool:
+    try:
+        iter(obj)
+        len(obj)
+        return not isinstance(obj, (str, bytes))
+    except (TypeError, AttributeError):
+        return False
+
+def is_dataclass(item: object) -> bool:
+    try:
+        import dataclasses
+        return dataclasses.is_dataclass(item) and (not isinstance(item, type))
+    except ImportError:
+        return False
+
+# File: pandas-main/pandas/core/dtypes/missing.py
+""""""
+from __future__ import annotations
+from decimal import Decimal
+from typing import TYPE_CHECKING, overload
+import warnings
+import numpy as np
+from pandas._libs import lib
+import pandas._libs.missing as libmissing
+from pandas._libs.tslibs import NaT, iNaT
+from pandas.core.dtypes.common import DT64NS_DTYPE, TD64NS_DTYPE, ensure_object, is_scalar, is_string_or_object_np_dtype
+from pandas.core.dtypes.dtypes import CategoricalDtype, DatetimeTZDtype, ExtensionDtype, IntervalDtype, PeriodDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCExtensionArray, ABCIndex, ABCMultiIndex, ABCSeries
+from pandas.core.dtypes.inference import is_list_like
+if TYPE_CHECKING:
+    from re import Pattern
+    from pandas._libs.missing import NAType
+    from pandas._libs.tslibs import NaTType
+    from pandas._typing import ArrayLike, DtypeObj, NDFrame, NDFrameT, Scalar, npt
+    from pandas import Series
+    from pandas.core.indexes.base import Index
+isposinf_scalar = libmissing.isposinf_scalar
+isneginf_scalar = libmissing.isneginf_scalar
+_dtype_object = np.dtype('object')
+_dtype_str = np.dtype(str)
+
+@overload
+def isna(obj: Scalar | Pattern | NAType | NaTType) -> bool:
+    ...
+
+@overload
+def isna(obj: ArrayLike | Index | list) -> npt.NDArray[np.bool_]:
+    ...
+
+@overload
+def isna(obj: NDFrameT) -> NDFrameT:
+    ...
+
+@overload
+def isna(obj: NDFrameT | ArrayLike | Index | list) -> NDFrameT | npt.NDArray[np.bool_]:
+    ...
+
+@overload
+def isna(obj: object) -> bool | npt.NDArray[np.bool_] | NDFrame:
+    ...
+
+def isna(obj: object) -> bool | npt.NDArray[np.bool_] | NDFrame:
+    return _isna(obj)
+isnull = isna
+
+def _isna(obj):
+    if is_scalar(obj):
+        return libmissing.checknull(obj)
+    elif isinstance(obj, ABCMultiIndex):
+        raise NotImplementedError('isna is not defined for MultiIndex')
+    elif isinstance(obj, type):
+        return False
+    elif isinstance(obj, (np.ndarray, ABCExtensionArray)):
+        return _isna_array(obj)
+    elif isinstance(obj, ABCIndex):
+        if not obj._can_hold_na:
+            return obj.isna()
+        return _isna_array(obj._values)
+    elif isinstance(obj, ABCSeries):
+        result = _isna_array(obj._values)
+        result = obj._constructor(result, index=obj.index, name=obj.name, copy=False)
+        return result
+    elif isinstance(obj, ABCDataFrame):
+        return obj.isna()
+    elif isinstance(obj, list):
+        return _isna_array(np.asarray(obj, dtype=object))
+    elif hasattr(obj, '__array__'):
+        return _isna_array(np.asarray(obj))
+    else:
+        return False
+
+def _isna_array(values: ArrayLike) -> npt.NDArray[np.bool_] | NDFrame:
+    dtype = values.dtype
+    result: npt.NDArray[np.bool_] | NDFrame
+    if not isinstance(values, np.ndarray):
+        result = values.isna()
+    elif isinstance(values, np.rec.recarray):
+        result = _isna_recarray_dtype(values)
+    elif is_string_or_object_np_dtype(values.dtype):
+        result = _isna_string_dtype(values)
+    elif dtype.kind in 'mM':
+        result = values.view('i8') == iNaT
+    else:
+        result = np.isnan(values)
+    return result
+
+def _isna_string_dtype(values: np.ndarray) -> npt.NDArray[np.bool_]:
+    dtype = values.dtype
+    if dtype.kind in ('S', 'U'):
+        result = np.zeros(values.shape, dtype=bool)
+    elif values.ndim in {1, 2}:
+        result = libmissing.isnaobj(values)
+    else:
+        result = libmissing.isnaobj(values.ravel())
+        result = result.reshape(values.shape)
+    return result
+
+def _isna_recarray_dtype(values: np.rec.recarray) -> npt.NDArray[np.bool_]:
+    result = np.zeros(values.shape, dtype=bool)
+    for (i, record) in enumerate(values):
+        record_as_array = np.array(record.tolist())
+        does_record_contain_nan = isna_all(record_as_array)
+        result[i] = np.any(does_record_contain_nan)
+    return result
+
+@overload
+def notna(obj: Scalar | Pattern | NAType | NaTType) -> bool:
+    ...
+
+@overload
+def notna(obj: ArrayLike | Index | list) -> npt.NDArray[np.bool_]:
+    ...
+
+@overload
+def notna(obj: NDFrameT) -> NDFrameT:
+    ...
+
+@overload
+def notna(obj: NDFrameT | ArrayLike | Index | list) -> NDFrameT | npt.NDArray[np.bool_]:
+    ...
+
+@overload
+def notna(obj: object) -> bool | npt.NDArray[np.bool_] | NDFrame:
+    ...
+
+def notna(obj: object) -> bool | npt.NDArray[np.bool_] | NDFrame:
+    res = isna(obj)
+    if isinstance(res, bool):
+        return not res
+    return ~res
+notnull = notna
+
+def array_equivalent(left, right, strict_nan: bool=False, dtype_equal: bool=False) -> bool:
+    (left, right) = (np.asarray(left), np.asarray(right))
+    if left.shape != right.shape:
+        return False
+    if dtype_equal:
+        if left.dtype.kind in 'fc':
+            return _array_equivalent_float(left, right)
+        elif left.dtype.kind in 'mM':
+            return _array_equivalent_datetimelike(left, right)
+        elif is_string_or_object_np_dtype(left.dtype):
+            return _array_equivalent_object(left, right, strict_nan)
+        else:
+            return np.array_equal(left, right)
+    if left.dtype.kind in 'OSU' or right.dtype.kind in 'OSU':
+        return _array_equivalent_object(left, right, strict_nan)
+    if left.dtype.kind in 'fc':
+        if not (left.size and right.size):
+            return True
+        return ((left == right) | isna(left) & isna(right)).all()
+    elif left.dtype.kind in 'mM' or right.dtype.kind in 'mM':
+        if left.dtype != right.dtype:
+            return False
+        left = left.view('i8')
+        right = right.view('i8')
+    if (left.dtype.type is np.void or right.dtype.type is np.void) and left.dtype != right.dtype:
+        return False
+    return np.array_equal(left, right)
+
+def _array_equivalent_float(left: np.ndarray, right: np.ndarray) -> bool:
+    return bool(((left == right) | np.isnan(left) & np.isnan(right)).all())
+
+def _array_equivalent_datetimelike(left: np.ndarray, right: np.ndarray) -> bool:
+    return np.array_equal(left.view('i8'), right.view('i8'))
+
+def _array_equivalent_object(left: np.ndarray, right: np.ndarray, strict_nan: bool) -> bool:
+    left = ensure_object(left)
+    right = ensure_object(right)
+    mask: npt.NDArray[np.bool_] | None = None
+    if strict_nan:
+        mask = isna(left) & isna(right)
+        if not mask.any():
+            mask = None
+    try:
+        if mask is None:
+            return lib.array_equivalent_object(left, right)
+        if not lib.array_equivalent_object(left[~mask], right[~mask]):
+            return False
+        left_remaining = left[mask]
+        right_remaining = right[mask]
+    except ValueError:
+        left_remaining = left
+        right_remaining = right
+    for (left_value, right_value) in zip(left_remaining, right_remaining):
+        if left_value is NaT and right_value is not NaT:
+            return False
+        elif left_value is libmissing.NA and right_value is not libmissing.NA:
+            return False
+        elif isinstance(left_value, float) and np.isnan(left_value):
+            if not isinstance(right_value, float) or not np.isnan(right_value):
+                return False
+        else:
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', DeprecationWarning)
+                try:
+                    if np.any(np.asarray(left_value != right_value)):
+                        return False
+                except TypeError as err:
+                    if 'boolean value of NA is ambiguous' in str(err):
+                        return False
+                    raise
+                except ValueError:
+                    return False
+    return True
+
+def array_equals(left: ArrayLike, right: ArrayLike) -> bool:
+    if left.dtype != right.dtype:
+        return False
+    elif isinstance(left, ABCExtensionArray):
+        return left.equals(right)
+    else:
+        return array_equivalent(left, right, dtype_equal=True)
+
+def infer_fill_value(val):
+    if not is_list_like(val):
+        val = [val]
+    val = np.asarray(val)
+    if val.dtype.kind in 'mM':
+        return np.array('NaT', dtype=val.dtype)
+    elif val.dtype == object:
+        dtype = lib.infer_dtype(ensure_object(val), skipna=False)
+        if dtype in ['datetime', 'datetime64']:
+            return np.array('NaT', dtype=DT64NS_DTYPE)
+        elif dtype in ['timedelta', 'timedelta64']:
+            return np.array('NaT', dtype=TD64NS_DTYPE)
+        return np.array(np.nan, dtype=object)
+    elif val.dtype.kind == 'U':
+        return np.array(np.nan, dtype=val.dtype)
+    return np.nan
+
+def construct_1d_array_from_inferred_fill_value(value: object, length: int) -> ArrayLike:
+    from pandas.core.algorithms import take_nd
+    from pandas.core.construction import sanitize_array
+    from pandas.core.indexes.base import Index
+    arr = sanitize_array(value, Index(range(1)), copy=False)
+    taker = -1 * np.ones(length, dtype=np.intp)
+    return take_nd(arr, taker)
+
+def maybe_fill(arr: np.ndarray) -> np.ndarray:
+    if arr.dtype.kind not in 'iub':
+        arr.fill(np.nan)
+    return arr
+
+def na_value_for_dtype(dtype: DtypeObj, compat: bool=True):
+    if isinstance(dtype, ExtensionDtype):
+        return dtype.na_value
+    elif dtype.kind in 'mM':
+        unit = np.datetime_data(dtype)[0]
+        return dtype.type('NaT', unit)
+    elif dtype.kind in 'fc':
+        return np.nan
+    elif dtype.kind in 'iu':
+        if compat:
+            return 0
+        return np.nan
+    elif dtype.kind == 'b':
+        if compat:
+            return False
+        return np.nan
+    return np.nan
+
+def remove_na_arraylike(arr: Series | Index | np.ndarray):
+    if isinstance(arr.dtype, ExtensionDtype):
+        return arr[notna(arr)]
+    else:
+        return arr[notna(np.asarray(arr))]
+
+def is_valid_na_for_dtype(obj, dtype: DtypeObj) -> bool:
+    if not lib.is_scalar(obj) or not isna(obj):
+        return False
+    elif dtype.kind == 'M':
+        if isinstance(dtype, np.dtype):
+            return not isinstance(obj, (np.timedelta64, Decimal))
+        return not isinstance(obj, (np.timedelta64, np.datetime64, Decimal))
+    elif dtype.kind == 'm':
+        return not isinstance(obj, (np.datetime64, Decimal))
+    elif dtype.kind in 'iufc':
+        return obj is not NaT and (not isinstance(obj, (np.datetime64, np.timedelta64)))
+    elif dtype.kind == 'b':
+        return lib.is_float(obj) or obj is None or obj is libmissing.NA
+    elif dtype == _dtype_str:
+        return not isinstance(obj, (np.datetime64, np.timedelta64, Decimal, float))
+    elif dtype == _dtype_object:
+        return True
+    elif isinstance(dtype, PeriodDtype):
+        return not isinstance(obj, (np.datetime64, np.timedelta64, Decimal))
+    elif isinstance(dtype, IntervalDtype):
+        return lib.is_float(obj) or obj is None or obj is libmissing.NA
+    elif isinstance(dtype, CategoricalDtype):
+        return is_valid_na_for_dtype(obj, dtype.categories.dtype)
+    return not isinstance(obj, (np.datetime64, np.timedelta64, Decimal))
+
+def isna_all(arr: ArrayLike) -> bool:
+    total_len = len(arr)
+    chunk_len = max(total_len // 40, 1000)
+    dtype = arr.dtype
+    if lib.is_np_dtype(dtype, 'f'):
+        checker = np.isnan
+    elif lib.is_np_dtype(dtype, 'mM') or isinstance(dtype, (DatetimeTZDtype, PeriodDtype)):
+        checker = lambda x: np.asarray(x.view('i8')) == iNaT
+    else:
+        checker = _isna_array
+    return all((checker(arr[i:i + chunk_len]).all() for i in range(0, total_len, chunk_len)))
+
+# File: pandas-main/pandas/core/flags.py
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import weakref
+if TYPE_CHECKING:
+    from pandas.core.generic import NDFrame
+
+class Flags:
+    _keys: set[str] = {'allows_duplicate_labels'}
+
+    def __init__(self, obj: NDFrame, *, allows_duplicate_labels: bool) -> None:
+        self._allows_duplicate_labels = allows_duplicate_labels
+        self._obj = weakref.ref(obj)
+
+    @property
+    def allows_duplicate_labels(self) -> bool:
+        return self._allows_duplicate_labels
+
+    @allows_duplicate_labels.setter
+    def allows_duplicate_labels(self, value: bool) -> None:
+        value = bool(value)
+        obj = self._obj()
+        if obj is None:
+            raise ValueError("This flag's object has been deleted.")
+        if not value:
+            for ax in obj.axes:
+                ax._maybe_check_unique()
+        self._allows_duplicate_labels = value
+
+    def __getitem__(self, key: str):
+        if key not in self._keys:
+            raise KeyError(key)
+        return getattr(self, key)
+
+    def __setitem__(self, key: str, value) -> None:
+        if key not in self._keys:
+            raise ValueError(f'Unknown flag {key}. Must be one of {self._keys}')
+        setattr(self, key, value)
+
+    def __repr__(self) -> str:
+        return f'<Flags(allows_duplicate_labels={self.allows_duplicate_labels})>'
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, type(self)):
+            return self.allows_duplicate_labels == other.allows_duplicate_labels
+        return False
+
+# File: pandas-main/pandas/core/frame.py
+""""""
+from __future__ import annotations
+import collections
+from collections import abc
+from collections.abc import Callable, Hashable, Iterable, Iterator, Mapping, Sequence
+import functools
+from io import StringIO
+import itertools
+import operator
+import sys
+from textwrap import dedent
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
+import warnings
+import numpy as np
+from numpy import ma
+from pandas._config import get_option
+from pandas._libs import algos as libalgos, lib, properties
+from pandas._libs.hashtable import duplicated
+from pandas._libs.lib import is_range_indexer
+from pandas.compat import PYPY
+from pandas.compat._constants import REF_COUNT
+from pandas.compat._optional import import_optional_dependency
+from pandas.compat.numpy import function as nv
+from pandas.errors import ChainedAssignmentError, InvalidIndexError
+from pandas.errors.cow import _chained_assignment_method_msg, _chained_assignment_msg
+from pandas.util._decorators import Appender, Substitution, deprecate_nonkeyword_arguments, doc, set_module
+from pandas.util._exceptions import find_stack_level, rewrite_warning
+from pandas.util._validators import validate_ascending, validate_bool_kwarg, validate_percentile
+from pandas.core.dtypes.cast import LossySetitemError, can_hold_element, construct_1d_arraylike_from_scalar, construct_2d_arraylike_from_scalar, find_common_type, infer_dtype_from_scalar, invalidate_string_dtypes, maybe_downcast_to_dtype
+from pandas.core.dtypes.common import infer_dtype_from_object, is_1d_only_ea_dtype, is_array_like, is_bool_dtype, is_dataclass, is_dict_like, is_float, is_float_dtype, is_hashable, is_integer, is_integer_dtype, is_iterator, is_list_like, is_scalar, is_sequence, needs_i8_conversion, pandas_dtype
+from pandas.core.dtypes.concat import concat_compat
+from pandas.core.dtypes.dtypes import ArrowDtype, BaseMaskedDtype, ExtensionDtype
+from pandas.core.dtypes.missing import isna, notna
+from pandas.core import algorithms, common as com, nanops, ops, roperator
+from pandas.core.accessor import Accessor
+from pandas.core.apply import reconstruct_and_relabel_result
+from pandas.core.array_algos.take import take_2d_multi
+from pandas.core.arraylike import OpsMixin
+from pandas.core.arrays import BaseMaskedArray, DatetimeArray, ExtensionArray, PeriodArray, TimedeltaArray
+from pandas.core.arrays.sparse import SparseFrameAccessor
+from pandas.core.construction import ensure_wrapped_if_datetimelike, sanitize_array, sanitize_masked_array
+from pandas.core.generic import NDFrame, make_doc
+from pandas.core.indexers import check_key_length
+from pandas.core.indexes.api import DatetimeIndex, Index, PeriodIndex, default_index, ensure_index, ensure_index_from_sequences
+from pandas.core.indexes.multi import MultiIndex, maybe_droplevels
+from pandas.core.indexing import check_bool_indexer, check_dict_or_set_indexers
+from pandas.core.internals import BlockManager
+from pandas.core.internals.construction import arrays_to_mgr, dataclasses_to_dicts, dict_to_mgr, ndarray_to_mgr, nested_data_to_arrays, rec_array_to_mgr, reorder_arrays, to_arrays, treat_as_nested
+from pandas.core.methods import selectn
+from pandas.core.reshape.melt import melt
+from pandas.core.series import Series
+from pandas.core.shared_docs import _shared_docs
+from pandas.core.sorting import get_group_index, lexsort_indexer, nargsort
+from pandas.io.common import get_handle
+from pandas.io.formats import console, format as fmt
+from pandas.io.formats.info import INFO_DOCSTRING, DataFrameInfo, frame_sub_kwargs
+import pandas.plotting
+if TYPE_CHECKING:
+    import datetime
+    from pandas._libs.internals import BlockValuesRefs
+    from pandas._typing import AggFuncType, AnyAll, AnyArrayLike, ArrayLike, Axes, Axis, AxisInt, ColspaceArgType, CompressionOptions, CorrelationMethod, DropKeep, Dtype, DtypeObj, FilePath, FloatFormatType, FormattersType, Frequency, FromDictOrient, HashableT, HashableT2, IgnoreRaise, IndexKeyFunc, IndexLabel, JoinValidate, Level, ListLike, MergeHow, MergeValidate, MutableMappingT, NaPosition, NsmallestNlargestKeep, PythonFuncType, QuantileInterpolation, ReadBuffer, ReindexMethod, Renamer, Scalar, Self, SequenceNotStr, SortKind, StorageOptions, Suffixes, T, ToStataByteorder, ToTimestampHow, UpdateJoin, ValueKeyFunc, WriteBuffer, XMLParsers, npt
+    from pandas.core.groupby.generic import DataFrameGroupBy
+    from pandas.core.interchange.dataframe_protocol import DataFrame as DataFrameXchg
+    from pandas.core.internals.managers import SingleBlockManager
+    from pandas.io.formats.style import Styler
+_shared_doc_kwargs = {'axes': 'index, columns', 'klass': 'DataFrame', 'axes_single_arg': "{0 or 'index', 1 or 'columns'}", 'axis': "axis : {0 or 'index', 1 or 'columns'}, default 0\n        If 0 or 'index': apply function to each column.\n        If 1 or 'columns': apply function to each row.", 'inplace': '\n    inplace : bool, default False\n        Whether to modify the DataFrame rather than creating a new one.', 'optional_by': "\nby : str or list of str\n    Name or list of names to sort by.\n\n    - if `axis` is 0 or `'index'` then `by` may contain index\n      levels and/or column labels.\n    - if `axis` is 1 or `'columns'` then `by` may contain column\n      levels and/or index labels.", 'optional_reindex': "\nlabels : array-like, optional\n    New labels / index to conform the axis specified by 'axis' to.\nindex : array-like, optional\n    New labels for the index. Preferably an Index object to avoid\n    duplicating data.\ncolumns : array-like, optional\n    New labels for the columns. Preferably an Index object to avoid\n    duplicating data.\naxis : int or str, optional\n    Axis to target. Can be either the axis name ('index', 'columns')\n    or number (0, 1)."}
+_merge_doc = '\nMerge DataFrame or named Series objects with a database-style join.\n\nA named Series object is treated as a DataFrame with a single named column.\n\nThe join is done on columns or indexes. If joining columns on\ncolumns, the DataFrame indexes *will be ignored*. Otherwise if joining indexes\non indexes or indexes on a column or columns, the index will be passed on.\nWhen performing a cross merge, no column specifications to merge on are\nallowed.\n\n.. warning::\n\n    If both key columns contain rows where the key is a null value, those\n    rows will be matched against each other. This is different from usual SQL\n    join behaviour and can lead to unexpected results.\n\nParameters\n----------%s\nright : DataFrame or named Series\n    Object to merge with.\nhow : {\'left\', \'right\', \'outer\', \'inner\', \'cross\'}, default \'inner\'\n    Type of merge to be performed.\n\n    * left: use only keys from left frame, similar to a SQL left outer join;\n      preserve key order.\n    * right: use only keys from right frame, similar to a SQL right outer join;\n      preserve key order.\n    * outer: use union of keys from both frames, similar to a SQL full outer\n      join; sort keys lexicographically.\n    * inner: use intersection of keys from both frames, similar to a SQL inner\n      join; preserve the order of the left keys.\n    * cross: creates the cartesian product from both frames, preserves the order\n      of the left keys.\non : label or list\n    Column or index level names to join on. These must be found in both\n    DataFrames. If `on` is None and not merging on indexes then this defaults\n    to the intersection of the columns in both DataFrames.\nleft_on : label or list, or array-like\n    Column or index level names to join on in the left DataFrame. Can also\n    be an array or list of arrays of the length of the left DataFrame.\n    These arrays are treated as if they are columns.\nright_on : label or list, or array-like\n    Column or index level names to join on in the right DataFrame. Can also\n    be an array or list of arrays of the length of the right DataFrame.\n    These arrays are treated as if they are columns.\nleft_index : bool, default False\n    Use the index from the left DataFrame as the join key(s). If it is a\n    MultiIndex, the number of keys in the other DataFrame (either the index\n    or a number of columns) must match the number of levels.\nright_index : bool, default False\n    Use the index from the right DataFrame as the join key. Same caveats as\n    left_index.\nsort : bool, default False\n    Sort the join keys lexicographically in the result DataFrame. If False,\n    the order of the join keys depends on the join type (how keyword).\nsuffixes : list-like, default is ("_x", "_y")\n    A length-2 sequence where each element is optionally a string\n    indicating the suffix to add to overlapping column names in\n    `left` and `right` respectively. Pass a value of `None` instead\n    of a string to indicate that the column name from `left` or\n    `right` should be left as-is, with no suffix. At least one of the\n    values must not be None.\ncopy : bool, default False\n    If False, avoid copy if possible.\n\n    .. note::\n        The `copy` keyword will change behavior in pandas 3.0.\n        `Copy-on-Write\n        <https://pandas.pydata.org/docs/dev/user_guide/copy_on_write.html>`__\n        will be enabled by default, which means that all methods with a\n        `copy` keyword will use a lazy copy mechanism to defer the copy and\n        ignore the `copy` keyword. The `copy` keyword will be removed in a\n        future version of pandas.\n\n        You can already get the future behavior and improvements through\n        enabling copy on write ``pd.options.mode.copy_on_write = True``\n\n    .. deprecated:: 3.0.0\nindicator : bool or str, default False\n    If True, adds a column to the output DataFrame called "_merge" with\n    information on the source of each row. The column can be given a different\n    name by providing a string argument. The column will have a Categorical\n    type with the value of "left_only" for observations whose merge key only\n    appears in the left DataFrame, "right_only" for observations\n    whose merge key only appears in the right DataFrame, and "both"\n    if the observation\'s merge key is found in both DataFrames.\n\nvalidate : str, optional\n    If specified, checks if merge is of specified type.\n\n    * "one_to_one" or "1:1": check if merge keys are unique in both\n      left and right datasets.\n    * "one_to_many" or "1:m": check if merge keys are unique in left\n      dataset.\n    * "many_to_one" or "m:1": check if merge keys are unique in right\n      dataset.\n    * "many_to_many" or "m:m": allowed, but does not result in checks.\n\nReturns\n-------\nDataFrame\n    A DataFrame of the two merged objects.\n\nSee Also\n--------\nmerge_ordered : Merge with optional filling/interpolation.\nmerge_asof : Merge on nearest keys.\nDataFrame.join : Similar method using indices.\n\nExamples\n--------\n>>> df1 = pd.DataFrame({\'lkey\': [\'foo\', \'bar\', \'baz\', \'foo\'],\n...                     \'value\': [1, 2, 3, 5]})\n>>> df2 = pd.DataFrame({\'rkey\': [\'foo\', \'bar\', \'baz\', \'foo\'],\n...                     \'value\': [5, 6, 7, 8]})\n>>> df1\n    lkey value\n0   foo      1\n1   bar      2\n2   baz      3\n3   foo      5\n>>> df2\n    rkey value\n0   foo      5\n1   bar      6\n2   baz      7\n3   foo      8\n\nMerge df1 and df2 on the lkey and rkey columns. The value columns have\nthe default suffixes, _x and _y, appended.\n\n>>> df1.merge(df2, left_on=\'lkey\', right_on=\'rkey\')\n  lkey  value_x rkey  value_y\n0  foo        1  foo        5\n1  foo        1  foo        8\n2  bar        2  bar        6\n3  baz        3  baz        7\n4  foo        5  foo        5\n5  foo        5  foo        8\n\nMerge DataFrames df1 and df2 with specified left and right suffixes\nappended to any overlapping columns.\n\n>>> df1.merge(df2, left_on=\'lkey\', right_on=\'rkey\',\n...           suffixes=(\'_left\', \'_right\'))\n  lkey  value_left rkey  value_right\n0  foo           1  foo            5\n1  foo           1  foo            8\n2  bar           2  bar            6\n3  baz           3  baz            7\n4  foo           5  foo            5\n5  foo           5  foo            8\n\nMerge DataFrames df1 and df2, but raise an exception if the DataFrames have\nany overlapping columns.\n\n>>> df1.merge(df2, left_on=\'lkey\', right_on=\'rkey\', suffixes=(False, False))\nTraceback (most recent call last):\n...\nValueError: columns overlap but no suffix specified:\n    Index([\'value\'], dtype=\'object\')\n\n>>> df1 = pd.DataFrame({\'a\': [\'foo\', \'bar\'], \'b\': [1, 2]})\n>>> df2 = pd.DataFrame({\'a\': [\'foo\', \'baz\'], \'c\': [3, 4]})\n>>> df1\n      a  b\n0   foo  1\n1   bar  2\n>>> df2\n      a  c\n0   foo  3\n1   baz  4\n\n>>> df1.merge(df2, how=\'inner\', on=\'a\')\n      a  b  c\n0   foo  1  3\n\n>>> df1.merge(df2, how=\'left\', on=\'a\')\n      a  b  c\n0   foo  1  3.0\n1   bar  2  NaN\n\n>>> df1 = pd.DataFrame({\'left\': [\'foo\', \'bar\']})\n>>> df2 = pd.DataFrame({\'right\': [7, 8]})\n>>> df1\n    left\n0   foo\n1   bar\n>>> df2\n    right\n0   7\n1   8\n\n>>> df1.merge(df2, how=\'cross\')\n   left  right\n0   foo      7\n1   foo      8\n2   bar      7\n3   bar      8\n'
+
+@set_module('pandas')
+class DataFrame(NDFrame, OpsMixin):
+    _internal_names_set = {'columns', 'index'} | NDFrame._internal_names_set
+    _typ = 'dataframe'
+    _HANDLED_TYPES = (Series, Index, ExtensionArray, np.ndarray)
+    _accessors: set[str] = {'sparse'}
+    _hidden_attrs: frozenset[str] = NDFrame._hidden_attrs | frozenset([])
+    _mgr: BlockManager
+    __pandas_priority__ = 4000
+
+    @property
+    def _constructor(self) -> type[DataFrame]:
+        return DataFrame
+
+    def _constructor_from_mgr(self, mgr, axes) -> DataFrame:
+        df = DataFrame._from_mgr(mgr, axes=axes)
+        if type(self) is DataFrame:
+            return df
+        elif type(self).__name__ == 'GeoDataFrame':
+            return self._constructor(mgr)
+        return self._constructor(df)
+    _constructor_sliced: Callable[..., Series] = Series
+
+    def _constructor_sliced_from_mgr(self, mgr, axes) -> Series:
+        ser = Series._from_mgr(mgr, axes)
+        ser._name = None
+        if type(self) is DataFrame:
+            return ser
+        return self._constructor_sliced(ser)
+
+    def __init__(self, data=None, index: Axes | None=None, columns: Axes | None=None, dtype: Dtype | None=None, copy: bool | None=None) -> None:
+        allow_mgr = False
+        if dtype is not None:
+            dtype = self._validate_dtype(dtype)
+        if isinstance(data, DataFrame):
+            data = data._mgr
+            allow_mgr = True
+            if not copy:
+                data = data.copy(deep=False)
+        if isinstance(data, BlockManager):
+            if not allow_mgr:
+                warnings.warn(f'Passing a {type(data).__name__} to {type(self).__name__} is deprecated and will raise in a future version. Use public APIs instead.', DeprecationWarning, stacklevel=1)
+            data = data.copy(deep=False)
+            if index is None and columns is None and (dtype is None) and (not copy):
+                NDFrame.__init__(self, data)
+                return
+        if isinstance(index, set):
+            raise ValueError('index cannot be a set')
+        if isinstance(columns, set):
+            raise ValueError('columns cannot be a set')
+        if copy is None:
+            if isinstance(data, dict):
+                copy = True
+            elif not isinstance(data, (Index, DataFrame, Series)):
+                copy = True
+            else:
+                copy = False
+        if data is None:
+            index = index if index is not None else default_index(0)
+            columns = columns if columns is not None else default_index(0)
+            dtype = dtype if dtype is not None else pandas_dtype(object)
+            data = []
+        if isinstance(data, BlockManager):
+            mgr = self._init_mgr(data, axes={'index': index, 'columns': columns}, dtype=dtype, copy=copy)
+        elif isinstance(data, dict):
+            mgr = dict_to_mgr(data, index, columns, dtype=dtype, copy=copy)
+        elif isinstance(data, ma.MaskedArray):
+            from numpy.ma import mrecords
+            if isinstance(data, mrecords.MaskedRecords):
+                raise TypeError('MaskedRecords are not supported. Pass {name: data[name] for name in data.dtype.names} instead')
+            data = sanitize_masked_array(data)
+            mgr = ndarray_to_mgr(data, index, columns, dtype=dtype, copy=copy)
+        elif isinstance(data, (np.ndarray, Series, Index, ExtensionArray)):
+            if data.dtype.names:
+                data = cast(np.ndarray, data)
+                mgr = rec_array_to_mgr(data, index, columns, dtype, copy)
+            elif getattr(data, 'name', None) is not None:
+                mgr = dict_to_mgr({data.name: data}, index, columns, dtype=dtype, copy=copy)
+            else:
+                mgr = ndarray_to_mgr(data, index, columns, dtype=dtype, copy=copy)
+        elif is_list_like(data):
+            if not isinstance(data, abc.Sequence):
+                if hasattr(data, '__array__'):
+                    data = np.asarray(data)
+                else:
+                    data = list(data)
+            if len(data) > 0:
+                if is_dataclass(data[0]):
+                    data = dataclasses_to_dicts(data)
+                if not isinstance(data, np.ndarray) and treat_as_nested(data):
+                    if columns is not None:
+                        columns = ensure_index(columns)
+                    (arrays, columns, index) = nested_data_to_arrays(data, columns, index, dtype)
+                    mgr = arrays_to_mgr(arrays, columns, index, dtype=dtype)
+                else:
+                    mgr = ndarray_to_mgr(data, index, columns, dtype=dtype, copy=copy)
+            else:
+                mgr = dict_to_mgr({}, index, columns if columns is not None else default_index(0), dtype=dtype)
+        else:
+            if index is None or columns is None:
+                raise ValueError('DataFrame constructor not properly called!')
+            index = ensure_index(index)
+            columns = ensure_index(columns)
+            if not dtype:
+                (dtype, _) = infer_dtype_from_scalar(data)
+            if isinstance(dtype, ExtensionDtype):
+                values = [construct_1d_arraylike_from_scalar(data, len(index), dtype) for _ in range(len(columns))]
+                mgr = arrays_to_mgr(values, columns, index, dtype=None)
+            else:
+                arr2d = construct_2d_arraylike_from_scalar(data, len(index), len(columns), dtype, copy)
+                mgr = ndarray_to_mgr(arr2d, index, columns, dtype=arr2d.dtype, copy=False)
+        NDFrame.__init__(self, mgr)
+
+    def __dataframe__(self, nan_as_null: bool=False, allow_copy: bool=True) -> DataFrameXchg:
+        from pandas.core.interchange.dataframe import PandasDataFrameXchg
+        return PandasDataFrameXchg(self, allow_copy=allow_copy)
+
+    def __arrow_c_stream__(self, requested_schema=None):
+        pa = import_optional_dependency('pyarrow', min_version='14.0.0')
+        if requested_schema is not None:
+            requested_schema = pa.Schema._import_from_c_capsule(requested_schema)
+        table = pa.Table.from_pandas(self, schema=requested_schema)
+        return table.__arrow_c_stream__()
+
+    @property
+    def axes(self) -> list[Index]:
+        return [self.index, self.columns]
+
+    @property
+    def shape(self) -> tuple[int, int]:
+        return (len(self.index), len(self.columns))
+
+    @property
+    def _is_homogeneous_type(self) -> bool:
+        return len({block.values.dtype for block in self._mgr.blocks}) <= 1
+
+    @property
+    def _can_fast_transpose(self) -> bool:
+        blocks = self._mgr.blocks
+        if len(blocks) != 1:
+            return False
+        dtype = blocks[0].dtype
+        return not is_1d_only_ea_dtype(dtype)
+
+    @property
+    def _values(self) -> np.ndarray | DatetimeArray | TimedeltaArray | PeriodArray:
+        mgr = self._mgr
+        blocks = mgr.blocks
+        if len(blocks) != 1:
+            return ensure_wrapped_if_datetimelike(self.values)
+        arr = blocks[0].values
+        if arr.ndim == 1:
+            return self.values
+        arr = cast('np.ndarray | DatetimeArray | TimedeltaArray | PeriodArray', arr)
+        return arr.T
+
+    def _repr_fits_vertical_(self) -> bool:
+        max_rows = get_option('display.max_rows')
+        return len(self) <= max_rows
+
+    def _repr_fits_horizontal_(self) -> bool:
+        (width, height) = console.get_console_size()
+        max_columns = get_option('display.max_columns')
+        nb_columns = len(self.columns)
+        if max_columns and nb_columns > max_columns or (width and nb_columns > width // 2):
+            return False
+        if width is None or not console.in_interactive_session():
+            return True
+        if get_option('display.width') is not None or console.in_ipython_frontend():
+            max_rows = 1
+        else:
+            max_rows = get_option('display.max_rows')
+        buf = StringIO()
+        d = self
+        if max_rows is not None:
+            d = d.iloc[:min(max_rows, len(d))]
+        else:
+            return True
+        d.to_string(buf=buf)
+        value = buf.getvalue()
+        repr_width = max((len(line) for line in value.split('\n')))
+        return repr_width < width
+
+    def _info_repr(self) -> bool:
+        info_repr_option = get_option('display.large_repr') == 'info'
+        return info_repr_option and (not (self._repr_fits_horizontal_() and self._repr_fits_vertical_()))
+
+    def __repr__(self) -> str:
+        if self._info_repr():
+            buf = StringIO()
+            self.info(buf=buf)
+            return buf.getvalue()
+        repr_params = fmt.get_dataframe_repr_params()
+        return self.to_string(**repr_params)
+
+    def _repr_html_(self) -> str | None:
+        if self._info_repr():
+            buf = StringIO()
+            self.info(buf=buf)
+            val = buf.getvalue().replace('<', '&lt;', 1)
+            val = val.replace('>', '&gt;', 1)
+            return f'<pre>{val}</pre>'
+        if get_option('display.notebook_repr_html'):
+            max_rows = get_option('display.max_rows')
+            min_rows = get_option('display.min_rows')
+            max_cols = get_option('display.max_columns')
+            show_dimensions = get_option('display.show_dimensions')
+            formatter = fmt.DataFrameFormatter(self, columns=None, col_space=None, na_rep='NaN', formatters=None, float_format=None, sparsify=None, justify=None, index_names=True, header=True, index=True, bold_rows=True, escape=True, max_rows=max_rows, min_rows=min_rows, max_cols=max_cols, show_dimensions=show_dimensions, decimal='.')
+            return fmt.DataFrameRenderer(formatter).to_html(notebook=True)
+        else:
+            return None
+
+    @overload
+    def to_string(self, buf: None=..., *, columns: Axes | None=..., col_space: int | list[int] | dict[Hashable, int] | None=..., header: bool | SequenceNotStr[str]=..., index: bool=..., na_rep: str=..., formatters: fmt.FormattersType | None=..., float_format: fmt.FloatFormatType | None=..., sparsify: bool | None=..., index_names: bool=..., justify: str | None=..., max_rows: int | None=..., max_cols: int | None=..., show_dimensions: bool=..., decimal: str=..., line_width: int | None=..., min_rows: int | None=..., max_colwidth: int | None=..., encoding: str | None=...) -> str:
+        ...
+
+    @overload
+    def to_string(self, buf: FilePath | WriteBuffer[str], *, columns: Axes | None=..., col_space: int | list[int] | dict[Hashable, int] | None=..., header: bool | SequenceNotStr[str]=..., index: bool=..., na_rep: str=..., formatters: fmt.FormattersType | None=..., float_format: fmt.FloatFormatType | None=..., sparsify: bool | None=..., index_names: bool=..., justify: str | None=..., max_rows: int | None=..., max_cols: int | None=..., show_dimensions: bool=..., decimal: str=..., line_width: int | None=..., min_rows: int | None=..., max_colwidth: int | None=..., encoding: str | None=...) -> None:
+        ...
+
+    @Substitution(header_type='bool or list of str', header='Write out the column names. If a list of columns is given, it is assumed to be aliases for the column names', col_space_type='int, list or dict of int', col_space='The minimum width of each column. If a list of ints is given every integers corresponds with one column. If a dict is given, the key references the column, while the value defines the space to use.')
+    @Substitution(shared_params=fmt.common_docstring, returns=fmt.return_docstring)
+    def to_string(self, buf: FilePath | WriteBuffer[str] | None=None, *, columns: Axes | None=None, col_space: int | list[int] | dict[Hashable, int] | None=None, header: bool | SequenceNotStr[str]=True, index: bool=True, na_rep: str='NaN', formatters: fmt.FormattersType | None=None, float_format: fmt.FloatFormatType | None=None, sparsify: bool | None=None, index_names: bool=True, justify: str | None=None, max_rows: int | None=None, max_cols: int | None=None, show_dimensions: bool=False, decimal: str='.', line_width: int | None=None, min_rows: int | None=None, max_colwidth: int | None=None, encoding: str | None=None) -> str | None:
+        from pandas import option_context
+        with option_context('display.max_colwidth', max_colwidth):
+            formatter = fmt.DataFrameFormatter(self, columns=columns, col_space=col_space, na_rep=na_rep, formatters=formatters, float_format=float_format, sparsify=sparsify, justify=justify, index_names=index_names, header=header, index=index, min_rows=min_rows, max_rows=max_rows, max_cols=max_cols, show_dimensions=show_dimensions, decimal=decimal)
+            return fmt.DataFrameRenderer(formatter).to_string(buf=buf, encoding=encoding, line_width=line_width)
+
+    def _get_values_for_csv(self, *, float_format: FloatFormatType | None, date_format: str | None, decimal: str, na_rep: str, quoting) -> DataFrame:
+        mgr = self._mgr.get_values_for_csv(float_format=float_format, date_format=date_format, decimal=decimal, na_rep=na_rep, quoting=quoting)
+        return self._constructor_from_mgr(mgr, axes=mgr.axes)
+
+    @property
+    def style(self) -> Styler:
+        from pandas.io.formats.style import Styler
+        return Styler(self)
+    _shared_docs['items'] = "\n        Iterate over (column name, Series) pairs.\n\n        Iterates over the DataFrame columns, returning a tuple with\n        the column name and the content as a Series.\n\n        Yields\n        ------\n        label : object\n            The column names for the DataFrame being iterated over.\n        content : Series\n            The column entries belonging to each label, as a Series.\n\n        See Also\n        --------\n        DataFrame.iterrows : Iterate over DataFrame rows as\n            (index, Series) pairs.\n        DataFrame.itertuples : Iterate over DataFrame rows as namedtuples\n            of the values.\n\n        Examples\n        --------\n        >>> df = pd.DataFrame({'species': ['bear', 'bear', 'marsupial'],\n        ...                   'population': [1864, 22000, 80000]},\n        ...                   index=['panda', 'polar', 'koala'])\n        >>> df\n                species   population\n        panda   bear      1864\n        polar   bear      22000\n        koala   marsupial 80000\n        >>> for label, content in df.items():\n        ...     print(f'label: {label}')\n        ...     print(f'content: {content}', sep='\\n')\n        ...\n        label: species\n        content:\n        panda         bear\n        polar         bear\n        koala    marsupial\n        Name: species, dtype: object\n        label: population\n        content:\n        panda     1864\n        polar    22000\n        koala    80000\n        Name: population, dtype: int64\n        "
+
+    @Appender(_shared_docs['items'])
+    def items(self) -> Iterable[tuple[Hashable, Series]]:
+        for (i, k) in enumerate(self.columns):
+            yield (k, self._ixs(i, axis=1))
+
+    def iterrows(self) -> Iterable[tuple[Hashable, Series]]:
+        columns = self.columns
+        klass = self._constructor_sliced
+        for (k, v) in zip(self.index, self.values):
+            s = klass(v, index=columns, name=k).__finalize__(self)
+            if self._mgr.is_single_block:
+                s._mgr.add_references(self._mgr)
+            yield (k, s)
+
+    def itertuples(self, index: bool=True, name: str | None='Pandas') -> Iterable[tuple[Any, ...]]:
+        arrays = []
+        fields = list(self.columns)
+        if index:
+            arrays.append(self.index)
+            fields.insert(0, 'Index')
+        arrays.extend((self.iloc[:, k] for k in range(len(self.columns))))
+        if name is not None:
+            itertuple = collections.namedtuple(name, fields, rename=True)
+            return map(itertuple._make, zip(*arrays))
+        return zip(*arrays)
+
+    def __len__(self) -> int:
+        return len(self.index)
+
+    @overload
+    def dot(self, other: Series) -> Series:
+        ...
+
+    @overload
+    def dot(self, other: DataFrame | Index | ArrayLike) -> DataFrame:
+        ...
+
+    def dot(self, other: AnyArrayLike | DataFrame) -> DataFrame | Series:
+        if isinstance(other, (Series, DataFrame)):
+            common = self.columns.union(other.index)
+            if len(common) > len(self.columns) or len(common) > len(other.index):
+                raise ValueError('matrices are not aligned')
+            left = self.reindex(columns=common)
+            right = other.reindex(index=common)
+            lvals = left.values
+            rvals = right._values
+        else:
+            left = self
+            lvals = self.values
+            rvals = np.asarray(other)
+            if lvals.shape[1] != rvals.shape[0]:
+                raise ValueError(f'Dot product shape mismatch, {lvals.shape} vs {rvals.shape}')
+        if isinstance(other, DataFrame):
+            common_type = find_common_type(list(self.dtypes) + list(other.dtypes))
+            return self._constructor(np.dot(lvals, rvals), index=left.index, columns=other.columns, copy=False, dtype=common_type)
+        elif isinstance(other, Series):
+            common_type = find_common_type(list(self.dtypes) + [other.dtypes])
+            return self._constructor_sliced(np.dot(lvals, rvals), index=left.index, copy=False, dtype=common_type)
+        elif isinstance(rvals, (np.ndarray, Index)):
+            result = np.dot(lvals, rvals)
+            if result.ndim == 2:
+                return self._constructor(result, index=left.index, copy=False)
+            else:
+                return self._constructor_sliced(result, index=left.index, copy=False)
+        else:
+            raise TypeError(f'unsupported type: {type(other)}')
+
+    @overload
+    def __matmul__(self, other: Series) -> Series:
+        ...
+
+    @overload
+    def __matmul__(self, other: AnyArrayLike | DataFrame) -> DataFrame | Series:
+        ...
+
+    def __matmul__(self, other: AnyArrayLike | DataFrame) -> DataFrame | Series:
+        return self.dot(other)
+
+    def __rmatmul__(self, other) -> DataFrame:
+        try:
+            return self.T.dot(np.transpose(other)).T
+        except ValueError as err:
+            if 'shape mismatch' not in str(err):
+                raise
+            msg = f'shapes {np.shape(other)} and {self.shape} not aligned'
+            raise ValueError(msg) from err
+
+    @classmethod
+    def from_dict(cls, data: dict, orient: FromDictOrient='columns', dtype: Dtype | None=None, columns: Axes | None=None) -> DataFrame:
+        index: list | Index | None = None
+        orient = orient.lower()
+        if orient == 'index':
+            if len(data) > 0:
+                if isinstance(next(iter(data.values())), (Series, dict)):
+                    data = _from_nested_dict(data)
+                else:
+                    index = list(data.keys())
+                    data = list(data.values())
+        elif orient in ('columns', 'tight'):
+            if columns is not None:
+                raise ValueError(f"cannot use columns parameter with orient='{orient}'")
+        else:
+            raise ValueError(f"Expected 'index', 'columns' or 'tight' for orient parameter. Got '{orient}' instead")
+        if orient != 'tight':
+            return cls(data, index=index, columns=columns, dtype=dtype)
+        else:
+            realdata = data['data']
+
+            def create_index(indexlist, namelist) -> Index:
+                index: Index
+                if len(namelist) > 1:
+                    index = MultiIndex.from_tuples(indexlist, names=namelist)
+                else:
+                    index = Index(indexlist, name=namelist[0])
+                return index
+            index = create_index(data['index'], data['index_names'])
+            columns = create_index(data['columns'], data['column_names'])
+            return cls(realdata, index=index, columns=columns, dtype=dtype)
+
+    def to_numpy(self, dtype: npt.DTypeLike | None=None, copy: bool=False, na_value: object=lib.no_default) -> np.ndarray:
+        if dtype is not None:
+            dtype = np.dtype(dtype)
+        result = self._mgr.as_array(dtype=dtype, copy=copy, na_value=na_value)
+        if result.dtype is not dtype:
+            result = np.asarray(result, dtype=dtype)
+        return result
+
+    @overload
+    def to_dict(self, orient: Literal['dict', 'list', 'series', 'split', 'tight', 'index']=..., *, into: type[MutableMappingT] | MutableMappingT, index: bool=...) -> MutableMappingT:
+        ...
+
+    @overload
+    def to_dict(self, orient: Literal['records'], *, into: type[MutableMappingT] | MutableMappingT, index: bool=...) -> list[MutableMappingT]:
+        ...
+
+    @overload
+    def to_dict(self, orient: Literal['dict', 'list', 'series', 'split', 'tight', 'index']=..., *, into: type[dict]=..., index: bool=...) -> dict:
+        ...
+
+    @overload
+    def to_dict(self, orient: Literal['records'], *, into: type[dict]=..., index: bool=...) -> list[dict]:
+        ...
+
+    def to_dict(self, orient: Literal['dict', 'list', 'series', 'split', 'tight', 'records', 'index']='dict', *, into: type[MutableMappingT] | MutableMappingT=dict, index: bool=True) -> MutableMappingT | list[MutableMappingT]:
+        from pandas.core.methods.to_dict import to_dict
+        return to_dict(self, orient, into=into, index=index)
+
+    @classmethod
+    def from_records(cls, data, index=None, exclude=None, columns=None, coerce_float: bool=False, nrows: int | None=None) -> DataFrame:
+        if isinstance(data, DataFrame):
+            raise TypeError('Passing a DataFrame to DataFrame.from_records is not supported. Use set_index and/or drop to modify the DataFrame instead.')
+        result_index = None
+        if columns is not None:
+            columns = ensure_index(columns)
+
+        def maybe_reorder(arrays: list[ArrayLike], arr_columns: Index, columns: Index, index) -> tuple[list[ArrayLike], Index, Index | None]:
+            if len(arrays):
+                length = len(arrays[0])
+            else:
+                length = 0
+            result_index = None
+            if len(arrays) == 0 and index is None and (length == 0):
+                result_index = default_index(0)
+            (arrays, arr_columns) = reorder_arrays(arrays, arr_columns, columns, length)
+            return (arrays, arr_columns, result_index)
+        if is_iterator(data):
+            if nrows == 0:
+                return cls()
+            try:
+                first_row = next(data)
+            except StopIteration:
+                return cls(index=index, columns=columns)
+            dtype = None
+            if hasattr(first_row, 'dtype') and first_row.dtype.names:
+                dtype = first_row.dtype
+            values = [first_row]
+            if nrows is None:
+                values += data
+            else:
+                values.extend(itertools.islice(data, nrows - 1))
+            if dtype is not None:
+                data = np.array(values, dtype=dtype)
+            else:
+                data = values
+        if isinstance(data, dict):
+            if columns is None:
+                columns = arr_columns = ensure_index(sorted(data))
+                arrays = [data[k] for k in columns]
+            else:
+                arrays = []
+                arr_columns_list = []
+                for (k, v) in data.items():
+                    if k in columns:
+                        arr_columns_list.append(k)
+                        arrays.append(v)
+                arr_columns = Index(arr_columns_list)
+                (arrays, arr_columns, result_index) = maybe_reorder(arrays, arr_columns, columns, index)
+        elif isinstance(data, np.ndarray):
+            (arrays, columns) = to_arrays(data, columns)
+            arr_columns = columns
+        else:
+            (arrays, arr_columns) = to_arrays(data, columns)
+            if coerce_float:
+                for (i, arr) in enumerate(arrays):
+                    if arr.dtype == object:
+                        arrays[i] = lib.maybe_convert_objects(arr, try_float=True)
+            arr_columns = ensure_index(arr_columns)
+            if columns is None:
+                columns = arr_columns
+            else:
+                (arrays, arr_columns, result_index) = maybe_reorder(arrays, arr_columns, columns, index)
+        if exclude is None:
+            exclude = set()
+        else:
+            exclude = set(exclude)
+        if index is not None:
+            if isinstance(index, str) or not hasattr(index, '__iter__'):
+                i = columns.get_loc(index)
+                exclude.add(index)
+                if len(arrays) > 0:
+                    result_index = Index(arrays[i], name=index)
+                else:
+                    result_index = Index([], name=index)
+            else:
+                try:
+                    index_data = [arrays[arr_columns.get_loc(field)] for field in index]
+                except (KeyError, TypeError):
+                    result_index = index
+                else:
+                    result_index = ensure_index_from_sequences(index_data, names=index)
+                    exclude.update(index)
+        if any(exclude):
+            arr_exclude = (x for x in exclude if x in arr_columns)
+            to_remove = {arr_columns.get_loc(col) for col in arr_exclude}
+            arrays = [v for (i, v) in enumerate(arrays) if i not in to_remove]
+            columns = columns.drop(exclude)
+        mgr = arrays_to_mgr(arrays, columns, result_index)
+        return cls._from_mgr(mgr, axes=mgr.axes)
+
+    def to_records(self, index: bool=True, column_dtypes=None, index_dtypes=None) -> np.rec.recarray:
+        if index:
+            ix_vals = [np.asarray(self.index.get_level_values(i)) for i in range(self.index.nlevels)]
+            arrays = ix_vals + [np.asarray(self.iloc[:, i]) for i in range(len(self.columns))]
+            index_names = list(self.index.names)
+            if isinstance(self.index, MultiIndex):
+                index_names = com.fill_missing_names(index_names)
+            elif index_names[0] is None:
+                index_names = ['index']
+            names = [str(name) for name in itertools.chain(index_names, self.columns)]
+        else:
+            arrays = [np.asarray(self.iloc[:, i]) for i in range(len(self.columns))]
+            names = [str(c) for c in self.columns]
+            index_names = []
+        index_len = len(index_names)
+        formats = []
+        for (i, v) in enumerate(arrays):
+            index_int = i
+            if index_int < index_len:
+                dtype_mapping = index_dtypes
+                name = index_names[index_int]
+            else:
+                index_int -= index_len
+                dtype_mapping = column_dtypes
+                name = self.columns[index_int]
+            if is_dict_like(dtype_mapping):
+                if name in dtype_mapping:
+                    dtype_mapping = dtype_mapping[name]
+                elif index_int in dtype_mapping:
+                    dtype_mapping = dtype_mapping[index_int]
+                else:
+                    dtype_mapping = None
+            if dtype_mapping is None:
+                formats.append(v.dtype)
+            elif isinstance(dtype_mapping, (type, np.dtype, str)):
+                formats.append(dtype_mapping)
+            else:
+                element = 'row' if i < index_len else 'column'
+                msg = f'Invalid dtype {dtype_mapping} specified for {element} {name}'
+                raise ValueError(msg)
+        return np.rec.fromarrays(arrays, dtype={'names': names, 'formats': formats})
+
+    @classmethod
+    def _from_arrays(cls, arrays, columns, index, dtype: Dtype | None=None, verify_integrity: bool=True) -> Self:
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+        columns = ensure_index(columns)
+        if len(columns) != len(arrays):
+            raise ValueError('len(columns) must match len(arrays)')
+        mgr = arrays_to_mgr(arrays, columns, index, dtype=dtype, verify_integrity=verify_integrity)
+        return cls._from_mgr(mgr, axes=mgr.axes)
+
+    @doc(storage_options=_shared_docs['storage_options'], compression_options=_shared_docs['compression_options'] % 'path')
+    def to_stata(self, path: FilePath | WriteBuffer[bytes], *, convert_dates: dict[Hashable, str] | None=None, write_index: bool=True, byteorder: ToStataByteorder | None=None, time_stamp: datetime.datetime | None=None, data_label: str | None=None, variable_labels: dict[Hashable, str] | None=None, version: int | None=114, convert_strl: Sequence[Hashable] | None=None, compression: CompressionOptions='infer', storage_options: StorageOptions | None=None, value_labels: dict[Hashable, dict[float, str]] | None=None) -> None:
+        if version not in (114, 117, 118, 119, None):
+            raise ValueError('Only formats 114, 117, 118 and 119 are supported.')
+        if version == 114:
+            if convert_strl is not None:
+                raise ValueError('strl is not supported in format 114')
+            from pandas.io.stata import StataWriter as statawriter
+        elif version == 117:
+            from pandas.io.stata import StataWriter117 as statawriter
+        else:
+            from pandas.io.stata import StataWriterUTF8 as statawriter
+        kwargs: dict[str, Any] = {}
+        if version is None or version >= 117:
+            kwargs['convert_strl'] = convert_strl
+        if version is None or version >= 118:
+            kwargs['version'] = version
+        writer = statawriter(path, self, convert_dates=convert_dates, byteorder=byteorder, time_stamp=time_stamp, data_label=data_label, write_index=write_index, variable_labels=variable_labels, compression=compression, storage_options=storage_options, value_labels=value_labels, **kwargs)
+        writer.write_file()
+
+    def to_feather(self, path: FilePath | WriteBuffer[bytes], **kwargs) -> None:
+        from pandas.io.feather_format import to_feather
+        to_feather(self, path, **kwargs)
+
+    @overload
+    def to_markdown(self, buf: None=..., *, mode: str=..., index: bool=..., storage_options: StorageOptions | None=..., **kwargs) -> str:
+        ...
+
+    @overload
+    def to_markdown(self, buf: FilePath | WriteBuffer[str], *, mode: str=..., index: bool=..., storage_options: StorageOptions | None=..., **kwargs) -> None:
+        ...
+
+    @overload
+    def to_markdown(self, buf: FilePath | WriteBuffer[str] | None, *, mode: str=..., index: bool=..., storage_options: StorageOptions | None=..., **kwargs) -> str | None:
+        ...
+
+    def to_markdown(self, buf: FilePath | WriteBuffer[str] | None=None, *, mode: str='wt', index: bool=True, storage_options: StorageOptions | None=None, **kwargs) -> str | None:
+        if 'showindex' in kwargs:
+            raise ValueError("Pass 'index' instead of 'showindex")
+        kwargs.setdefault('headers', 'keys')
+        kwargs.setdefault('tablefmt', 'pipe')
+        kwargs.setdefault('showindex', index)
+        tabulate = import_optional_dependency('tabulate')
+        result = tabulate.tabulate(self, **kwargs)
+        if buf is None:
+            return result
+        with get_handle(buf, mode, storage_options=storage_options) as handles:
+            handles.handle.write(result)
+        return None
+
+    @overload
+    def to_parquet(self, path: None=..., *, engine: Literal['auto', 'pyarrow', 'fastparquet']=..., compression: str | None=..., index: bool | None=..., partition_cols: list[str] | None=..., storage_options: StorageOptions=..., **kwargs) -> bytes:
+        ...
+
+    @overload
+    def to_parquet(self, path: FilePath | WriteBuffer[bytes], *, engine: Literal['auto', 'pyarrow', 'fastparquet']=..., compression: str | None=..., index: bool | None=..., partition_cols: list[str] | None=..., storage_options: StorageOptions=..., **kwargs) -> None:
+        ...
+
+    @doc(storage_options=_shared_docs['storage_options'])
+    def to_parquet(self, path: FilePath | WriteBuffer[bytes] | None=None, *, engine: Literal['auto', 'pyarrow', 'fastparquet']='auto', compression: str | None='snappy', index: bool | None=None, partition_cols: list[str] | None=None, storage_options: StorageOptions | None=None, **kwargs) -> bytes | None:
+        from pandas.io.parquet import to_parquet
+        return to_parquet(self, path, engine, compression=compression, index=index, partition_cols=partition_cols, storage_options=storage_options, **kwargs)
+
+    @overload
+    def to_orc(self, path: None=..., *, engine: Literal['pyarrow']=..., index: bool | None=..., engine_kwargs: dict[str, Any] | None=...) -> bytes:
+        ...
+
+    @overload
+    def to_orc(self, path: FilePath | WriteBuffer[bytes], *, engine: Literal['pyarrow']=..., index: bool | None=..., engine_kwargs: dict[str, Any] | None=...) -> None:
+        ...
+
+    @overload
+    def to_orc(self, path: FilePath | WriteBuffer[bytes] | None, *, engine: Literal['pyarrow']=..., index: bool | None=..., engine_kwargs: dict[str, Any] | None=...) -> bytes | None:
+        ...
+
+    def to_orc(self, path: FilePath | WriteBuffer[bytes] | None=None, *, engine: Literal['pyarrow']='pyarrow', index: bool | None=None, engine_kwargs: dict[str, Any] | None=None) -> bytes | None:
+        from pandas.io.orc import to_orc
+        return to_orc(self, path, engine=engine, index=index, engine_kwargs=engine_kwargs)
+
+    @overload
+    def to_html(self, buf: FilePath | WriteBuffer[str], *, columns: Axes | None=..., col_space: ColspaceArgType | None=..., header: bool=..., index: bool=..., na_rep: str=..., formatters: FormattersType | None=..., float_format: FloatFormatType | None=..., sparsify: bool | None=..., index_names: bool=..., justify: str | None=..., max_rows: int | None=..., max_cols: int | None=..., show_dimensions: bool | str=..., decimal: str=..., bold_rows: bool=..., classes: str | list | tuple | None=..., escape: bool=..., notebook: bool=..., border: int | bool | None=..., table_id: str | None=..., render_links: bool=..., encoding: str | None=...) -> None:
+        ...
+
+    @overload
+    def to_html(self, buf: None=..., *, columns: Axes | None=..., col_space: ColspaceArgType | None=..., header: bool=..., index: bool=..., na_rep: str=..., formatters: FormattersType | None=..., float_format: FloatFormatType | None=..., sparsify: bool | None=..., index_names: bool=..., justify: str | None=..., max_rows: int | None=..., max_cols: int | None=..., show_dimensions: bool | str=..., decimal: str=..., bold_rows: bool=..., classes: str | list | tuple | None=..., escape: bool=..., notebook: bool=..., border: int | bool | None=..., table_id: str | None=..., render_links: bool=..., encoding: str | None=...) -> str:
+        ...
+
+    @Substitution(header_type='bool', header='Whether to print column labels, default True', col_space_type='str or int, list or dict of int or str', col_space='The minimum width of each column in CSS length units.  An int is assumed to be px units.')
+    @Substitution(shared_params=fmt.common_docstring, returns=fmt.return_docstring)
+    def to_html(self, buf: FilePath | WriteBuffer[str] | None=None, *, columns: Axes | None=None, col_space: ColspaceArgType | None=None, header: bool=True, index: bool=True, na_rep: str='NaN', formatters: FormattersType | None=None, float_format: FloatFormatType | None=None, sparsify: bool | None=None, index_names: bool=True, justify: str | None=None, max_rows: int | None=None, max_cols: int | None=None, show_dimensions: bool | str=False, decimal: str='.', bold_rows: bool=True, classes: str | list | tuple | None=None, escape: bool=True, notebook: bool=False, border: int | bool | None=None, table_id: str | None=None, render_links: bool=False, encoding: str | None=None) -> str | None:
+        if justify is not None and justify not in fmt.VALID_JUSTIFY_PARAMETERS:
+            raise ValueError('Invalid value for justify parameter')
+        formatter = fmt.DataFrameFormatter(self, columns=columns, col_space=col_space, na_rep=na_rep, header=header, index=index, formatters=formatters, float_format=float_format, bold_rows=bold_rows, sparsify=sparsify, justify=justify, index_names=index_names, escape=escape, decimal=decimal, max_rows=max_rows, max_cols=max_cols, show_dimensions=show_dimensions)
+        return fmt.DataFrameRenderer(formatter).to_html(buf=buf, classes=classes, notebook=notebook, border=border, encoding=encoding, table_id=table_id, render_links=render_links)
+
+    @overload
+    def to_xml(self, path_or_buffer: None=..., *, index: bool=..., root_name: str | None=..., row_name: str | None=..., na_rep: str | None=..., attr_cols: list[str] | None=..., elem_cols: list[str] | None=..., namespaces: dict[str | None, str] | None=..., prefix: str | None=..., encoding: str=..., xml_declaration: bool | None=..., pretty_print: bool | None=..., parser: XMLParsers | None=..., stylesheet: FilePath | ReadBuffer[str] | ReadBuffer[bytes] | None=..., compression: CompressionOptions=..., storage_options: StorageOptions | None=...) -> str:
+        ...
+
+    @overload
+    def to_xml(self, path_or_buffer: FilePath | WriteBuffer[bytes] | WriteBuffer[str], *, index: bool=..., root_name: str | None=..., row_name: str | None=..., na_rep: str | None=..., attr_cols: list[str] | None=..., elem_cols: list[str] | None=..., namespaces: dict[str | None, str] | None=..., prefix: str | None=..., encoding: str=..., xml_declaration: bool | None=..., pretty_print: bool | None=..., parser: XMLParsers | None=..., stylesheet: FilePath | ReadBuffer[str] | ReadBuffer[bytes] | None=..., compression: CompressionOptions=..., storage_options: StorageOptions | None=...) -> None:
+        ...
+
+    @doc(storage_options=_shared_docs['storage_options'], compression_options=_shared_docs['compression_options'] % 'path_or_buffer')
+    def to_xml(self, path_or_buffer: FilePath | WriteBuffer[bytes] | WriteBuffer[str] | None=None, *, index: bool=True, root_name: str | None='data', row_name: str | None='row', na_rep: str | None=None, attr_cols: list[str] | None=None, elem_cols: list[str] | None=None, namespaces: dict[str | None, str] | None=None, prefix: str | None=None, encoding: str='utf-8', xml_declaration: bool | None=True, pretty_print: bool | None=True, parser: XMLParsers | None='lxml', stylesheet: FilePath | ReadBuffer[str] | ReadBuffer[bytes] | None=None, compression: CompressionOptions='infer', storage_options: StorageOptions | None=None) -> str | None:
+        from pandas.io.formats.xml import EtreeXMLFormatter, LxmlXMLFormatter
+        lxml = import_optional_dependency('lxml.etree', errors='ignore')
+        TreeBuilder: type[EtreeXMLFormatter | LxmlXMLFormatter]
+        if parser == 'lxml':
+            if lxml is not None:
+                TreeBuilder = LxmlXMLFormatter
+            else:
+                raise ImportError('lxml not found, please install or use the etree parser.')
+        elif parser == 'etree':
+            TreeBuilder = EtreeXMLFormatter
+        else:
+            raise ValueError('Values for parser can only be lxml or etree.')
+        xml_formatter = TreeBuilder(self, path_or_buffer=path_or_buffer, index=index, root_name=root_name, row_name=row_name, na_rep=na_rep, attr_cols=attr_cols, elem_cols=elem_cols, namespaces=namespaces, prefix=prefix, encoding=encoding, xml_declaration=xml_declaration, pretty_print=pretty_print, stylesheet=stylesheet, compression=compression, storage_options=storage_options)
+        return xml_formatter.write_output()
+
+    @doc(INFO_DOCSTRING, **frame_sub_kwargs)
+    def info(self, verbose: bool | None=None, buf: WriteBuffer[str] | None=None, max_cols: int | None=None, memory_usage: bool | str | None=None, show_counts: bool | None=None) -> None:
+        info = DataFrameInfo(data=self, memory_usage=memory_usage)
+        info.render(buf=buf, max_cols=max_cols, verbose=verbose, show_counts=show_counts)
+
+    def memory_usage(self, index: bool=True, deep: bool=False) -> Series:
+        result = self._constructor_sliced([c.memory_usage(index=False, deep=deep) for (col, c) in self.items()], index=self.columns, dtype=np.intp)
+        if index:
+            index_memory_usage = self._constructor_sliced(self.index.memory_usage(deep=deep), index=['Index'])
+            result = index_memory_usage._append(result)
+        return result
+
+    def transpose(self, *args, copy: bool | lib.NoDefault=lib.no_default) -> DataFrame:
+        self._check_copy_deprecation(copy)
+        nv.validate_transpose(args, {})
+        first_dtype = self.dtypes.iloc[0] if len(self.columns) else None
+        if self._can_fast_transpose:
+            new_vals = self._values.T
+            result = self._constructor(new_vals, index=self.columns, columns=self.index, copy=False, dtype=new_vals.dtype)
+            if len(self) > 0:
+                result._mgr.add_references(self._mgr)
+        elif self._is_homogeneous_type and first_dtype is not None and isinstance(first_dtype, ExtensionDtype):
+            new_values: list
+            if isinstance(first_dtype, BaseMaskedDtype):
+                from pandas.core.arrays.masked import transpose_homogeneous_masked_arrays
+                new_values = transpose_homogeneous_masked_arrays(cast(Sequence[BaseMaskedArray], self._iter_column_arrays()))
+            elif isinstance(first_dtype, ArrowDtype):
+                from pandas.core.arrays.arrow.array import ArrowExtensionArray, transpose_homogeneous_pyarrow
+                new_values = transpose_homogeneous_pyarrow(cast(Sequence[ArrowExtensionArray], self._iter_column_arrays()))
+            else:
+                arr_typ = first_dtype.construct_array_type()
+                values = self.values
+                new_values = [arr_typ._from_sequence(row, dtype=first_dtype) for row in values]
+            result = type(self)._from_arrays(new_values, index=self.columns, columns=self.index, verify_integrity=False)
+        else:
+            new_arr = self.values.T
+            result = self._constructor(new_arr, index=self.columns, columns=self.index, dtype=new_arr.dtype, copy=False)
+        return result.__finalize__(self, method='transpose')
+
+    @property
+    def T(self) -> DataFrame:
+        return self.transpose()
+
+    def _ixs(self, i: int, axis: AxisInt=0) -> Series:
+        if axis == 0:
+            new_mgr = self._mgr.fast_xs(i)
+            result = self._constructor_sliced_from_mgr(new_mgr, axes=new_mgr.axes)
+            result._name = self.index[i]
+            return result.__finalize__(self)
+        else:
+            col_mgr = self._mgr.iget(i)
+            return self._box_col_values(col_mgr, i)
+
+    def _get_column_array(self, i: int) -> ArrayLike:
+        return self._mgr.iget_values(i)
+
+    def _iter_column_arrays(self) -> Iterator[ArrayLike]:
+        for i in range(len(self.columns)):
+            yield self._get_column_array(i)
+
+    def __getitem__(self, key):
+        check_dict_or_set_indexers(key)
+        key = lib.item_from_zerodim(key)
+        key = com.apply_if_callable(key, self)
+        if is_hashable(key) and (not is_iterator(key)) and (not isinstance(key, slice)):
+            is_mi = isinstance(self.columns, MultiIndex)
+            if not is_mi and (self.columns.is_unique and key in self.columns or key in self.columns.drop_duplicates(keep=False)):
+                return self._get_item(key)
+            elif is_mi and self.columns.is_unique and (key in self.columns):
+                return self._getitem_multilevel(key)
+        if isinstance(key, slice):
+            return self._getitem_slice(key)
+        if isinstance(key, DataFrame):
+            return self.where(key)
+        if com.is_bool_indexer(key):
+            return self._getitem_bool_array(key)
+        is_single_key = isinstance(key, tuple) or not is_list_like(key)
+        if is_single_key:
+            if self.columns.nlevels > 1:
+                return self._getitem_multilevel(key)
+            indexer = self.columns.get_loc(key)
+            if is_integer(indexer):
+                indexer = [indexer]
+        else:
+            if is_iterator(key):
+                key = list(key)
+            indexer = self.columns._get_indexer_strict(key, 'columns')[1]
+        if getattr(indexer, 'dtype', None) == bool:
+            indexer = np.where(indexer)[0]
+        if isinstance(indexer, slice):
+            return self._slice(indexer, axis=1)
+        data = self.take(indexer, axis=1)
+        if is_single_key:
+            if data.shape[1] == 1 and (not isinstance(self.columns, MultiIndex)):
+                return data._get_item(key)
+        return data
+
+    def _getitem_bool_array(self, key):
+        if isinstance(key, Series) and (not key.index.equals(self.index)):
+            warnings.warn('Boolean Series key will be reindexed to match DataFrame index.', UserWarning, stacklevel=find_stack_level())
+        elif len(key) != len(self.index):
+            raise ValueError(f'Item wrong length {len(key)} instead of {len(self.index)}.')
+        key = check_bool_indexer(self.index, key)
+        if key.all():
+            return self.copy(deep=False)
+        indexer = key.nonzero()[0]
+        return self.take(indexer, axis=0)
+
+    def _getitem_multilevel(self, key):
+        loc = self.columns.get_loc(key)
+        if isinstance(loc, (slice, np.ndarray)):
+            new_columns = self.columns[loc]
+            result_columns = maybe_droplevels(new_columns, key)
+            result = self.iloc[:, loc]
+            result.columns = result_columns
+            if len(result.columns) == 1:
+                top = result.columns[0]
+                if isinstance(top, tuple):
+                    top = top[0]
+                if top == '':
+                    result = result['']
+                    if isinstance(result, Series):
+                        result = self._constructor_sliced(result, index=self.index, name=key)
+            return result
+        else:
+            return self._ixs(loc, axis=1)
+
+    def _get_value(self, index, col, takeable: bool=False) -> Scalar:
+        if takeable:
+            series = self._ixs(col, axis=1)
+            return series._values[index]
+        series = self._get_item(col)
+        if not isinstance(self.index, MultiIndex):
+            row = self.index.get_loc(index)
+            return series._values[row]
+        loc = self.index._engine.get_loc(index)
+        return series._values[loc]
+
+    def isetitem(self, loc, value) -> None:
+        if isinstance(value, DataFrame):
+            if is_integer(loc):
+                loc = [loc]
+            if len(loc) != len(value.columns):
+                raise ValueError(f'Got {len(loc)} positions but value has {len(value.columns)} columns.')
+            for (i, idx) in enumerate(loc):
+                (arraylike, refs) = self._sanitize_column(value.iloc[:, i])
+                self._iset_item_mgr(idx, arraylike, inplace=False, refs=refs)
+            return
+        (arraylike, refs) = self._sanitize_column(value)
+        self._iset_item_mgr(loc, arraylike, inplace=False, refs=refs)
+
+    def __setitem__(self, key, value) -> None:
+        if not PYPY:
+            if sys.getrefcount(self) <= 3:
+                warnings.warn(_chained_assignment_msg, ChainedAssignmentError, stacklevel=2)
+        key = com.apply_if_callable(key, self)
+        if isinstance(key, slice):
+            slc = self.index._convert_slice_indexer(key, kind='getitem')
+            return self._setitem_slice(slc, value)
+        if isinstance(key, DataFrame) or getattr(key, 'ndim', None) == 2:
+            self._setitem_frame(key, value)
+        elif isinstance(key, (Series, np.ndarray, list, Index)):
+            self._setitem_array(key, value)
+        elif isinstance(value, DataFrame):
+            self._set_item_frame_value(key, value)
+        elif is_list_like(value) and (not self.columns.is_unique) and (1 < len(self.columns.get_indexer_for([key])) == len(value)):
+            self._setitem_array([key], value)
+        else:
+            self._set_item(key, value)
+
+    def _setitem_slice(self, key: slice, value) -> None:
+        self.iloc[key] = value
+
+    def _setitem_array(self, key, value) -> None:
+        if com.is_bool_indexer(key):
+            if len(key) != len(self.index):
+                raise ValueError(f'Item wrong length {len(key)} instead of {len(self.index)}!')
+            key = check_bool_indexer(self.index, key)
+            indexer = key.nonzero()[0]
+            if isinstance(value, DataFrame):
+                value = value.reindex(self.index.take(indexer))
+            self.iloc[indexer] = value
+        elif isinstance(value, DataFrame):
+            check_key_length(self.columns, key, value)
+            for (k1, k2) in zip(key, value.columns):
+                self[k1] = value[k2]
+        elif not is_list_like(value):
+            for col in key:
+                self[col] = value
+        elif isinstance(value, np.ndarray) and value.ndim == 2:
+            self._iset_not_inplace(key, value)
+        elif np.ndim(value) > 1:
+            value = DataFrame(value).values
+            self._setitem_array(key, value)
+        else:
+            self._iset_not_inplace(key, value)
+
+    def _iset_not_inplace(self, key, value) -> None:
+
+        def igetitem(obj, i: int):
+            if isinstance(obj, np.ndarray):
+                return obj[..., i]
+            else:
+                return obj[i]
+        if self.columns.is_unique:
+            if np.shape(value)[-1] != len(key):
+                raise ValueError('Columns must be same length as key')
+            for (i, col) in enumerate(key):
+                self[col] = igetitem(value, i)
+        else:
+            ilocs = self.columns.get_indexer_non_unique(key)[0]
+            if (ilocs < 0).any():
+                raise NotImplementedError
+            if np.shape(value)[-1] != len(ilocs):
+                raise ValueError('Columns must be same length as key')
+            assert np.ndim(value) <= 2
+            orig_columns = self.columns
+            try:
+                self.columns = Index(range(len(self.columns)))
+                for (i, iloc) in enumerate(ilocs):
+                    self[iloc] = igetitem(value, i)
+            finally:
+                self.columns = orig_columns
+
+    def _setitem_frame(self, key, value) -> None:
+        if isinstance(key, np.ndarray):
+            if key.shape != self.shape:
+                raise ValueError('Array conditional must be same shape as self')
+            key = self._constructor(key, **self._construct_axes_dict(), copy=False)
+        if key.size and (not all((is_bool_dtype(dtype) for dtype in key.dtypes))):
+            raise TypeError('Must pass DataFrame or 2-d ndarray with boolean values only')
+        self._where(-key, value, inplace=True)
+
+    def _set_item_frame_value(self, key, value: DataFrame) -> None:
+        self._ensure_valid_index(value)
+        if key in self.columns:
+            loc = self.columns.get_loc(key)
+            cols = self.columns[loc]
+            len_cols = 1 if is_scalar(cols) or isinstance(cols, tuple) else len(cols)
+            if len_cols != len(value.columns):
+                raise ValueError('Columns must be same length as key')
+            if isinstance(self.columns, MultiIndex) and isinstance(loc, (slice, Series, np.ndarray, Index)):
+                cols_droplevel = maybe_droplevels(cols, key)
+                if len(cols_droplevel) and (not cols_droplevel.equals(value.columns)):
+                    value = value.reindex(cols_droplevel, axis=1)
+                for (col, col_droplevel) in zip(cols, cols_droplevel):
+                    self[col] = value[col_droplevel]
+                return
+            if is_scalar(cols):
+                self[cols] = value[value.columns[0]]
+                return
+            locs: np.ndarray | list
+            if isinstance(loc, slice):
+                locs = np.arange(loc.start, loc.stop, loc.step)
+            elif is_scalar(loc):
+                locs = [loc]
+            else:
+                locs = loc.nonzero()[0]
+            return self.isetitem(locs, value)
+        if len(value.columns) > 1:
+            raise ValueError(f'Cannot set a DataFrame with multiple columns to the single column {key}')
+        elif len(value.columns) == 0:
+            raise ValueError(f'Cannot set a DataFrame without columns to the column {key}')
+        self[key] = value[value.columns[0]]
+
+    def _iset_item_mgr(self, loc: int | slice | np.ndarray, value, inplace: bool=False, refs: BlockValuesRefs | None=None) -> None:
+        self._mgr.iset(loc, value, inplace=inplace, refs=refs)
+
+    def _set_item_mgr(self, key, value: ArrayLike, refs: BlockValuesRefs | None=None) -> None:
+        try:
+            loc = self._info_axis.get_loc(key)
+        except KeyError:
+            self._mgr.insert(len(self._info_axis), key, value, refs)
+        else:
+            self._iset_item_mgr(loc, value, refs=refs)
+
+    def _iset_item(self, loc: int, value: Series, inplace: bool=True) -> None:
+        self._iset_item_mgr(loc, value._values, inplace=inplace, refs=value._references)
+
+    def _set_item(self, key, value) -> None:
+        (value, refs) = self._sanitize_column(value)
+        if key in self.columns and value.ndim == 1 and (not isinstance(value.dtype, ExtensionDtype)):
+            if not self.columns.is_unique or isinstance(self.columns, MultiIndex):
+                existing_piece = self[key]
+                if isinstance(existing_piece, DataFrame):
+                    value = np.tile(value, (len(existing_piece.columns), 1)).T
+                    refs = None
+        self._set_item_mgr(key, value, refs)
+
+    def _set_value(self, index: IndexLabel, col, value: Scalar, takeable: bool=False) -> None:
+        try:
+            if takeable:
+                icol = col
+                iindex = cast(int, index)
+            else:
+                icol = self.columns.get_loc(col)
+                iindex = self.index.get_loc(index)
+            self._mgr.column_setitem(icol, iindex, value, inplace_only=True)
+        except (KeyError, TypeError, ValueError, LossySetitemError):
+            if takeable:
+                self.iloc[index, col] = value
+            else:
+                self.loc[index, col] = value
+        except InvalidIndexError as ii_err:
+            raise InvalidIndexError(f'You can only assign a scalar value not a {type(value)}') from ii_err
+
+    def _ensure_valid_index(self, value) -> None:
+        if not len(self.index) and is_list_like(value) and len(value):
+            if not isinstance(value, DataFrame):
+                try:
+                    value = Series(value)
+                except (ValueError, NotImplementedError, TypeError) as err:
+                    raise ValueError('Cannot set a frame with no defined index and a value that cannot be converted to a Series') from err
+            index_copy = value.index.copy()
+            if self.index.name is not None:
+                index_copy.name = self.index.name
+            self._mgr = self._mgr.reindex_axis(index_copy, axis=1, fill_value=np.nan)
+
+    def _box_col_values(self, values: SingleBlockManager, loc: int) -> Series:
+        name = self.columns[loc]
+        obj = self._constructor_sliced_from_mgr(values, axes=values.axes)
+        obj._name = name
+        return obj.__finalize__(self)
+
+    def _get_item(self, item: Hashable) -> Series:
+        loc = self.columns.get_loc(item)
+        return self._ixs(loc, axis=1)
+
+    @overload
+    def query(self, expr: str, *, inplace: Literal[False]=..., **kwargs) -> DataFrame:
+        ...
+
+    @overload
+    def query(self, expr: str, *, inplace: Literal[True], **kwargs) -> None:
+        ...
+
+    @overload
+    def query(self, expr: str, *, inplace: bool=..., **kwargs) -> DataFrame | None:
+        ...
+
+    def query(self, expr: str, *, inplace: bool=False, **kwargs) -> DataFrame | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if not isinstance(expr, str):
+            msg = f'expr must be a string to be evaluated, {type(expr)} given'
+            raise ValueError(msg)
+        kwargs['level'] = kwargs.pop('level', 0) + 1
+        kwargs['target'] = None
+        res = self.eval(expr, **kwargs)
+        try:
+            result = self.loc[res]
+        except ValueError:
+            result = self[res]
+        if inplace:
+            self._update_inplace(result)
+            return None
+        else:
+            return result
+
+    @overload
+    def eval(self, expr: str, *, inplace: Literal[False]=..., **kwargs) -> Any:
+        ...
+
+    @overload
+    def eval(self, expr: str, *, inplace: Literal[True], **kwargs) -> None:
+        ...
+
+    def eval(self, expr: str, *, inplace: bool=False, **kwargs) -> Any | None:
+        from pandas.core.computation.eval import eval as _eval
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        kwargs['level'] = kwargs.pop('level', 0) + 1
+        index_resolvers = self._get_index_resolvers()
+        column_resolvers = self._get_cleaned_column_resolvers()
+        resolvers = (column_resolvers, index_resolvers)
+        if 'target' not in kwargs:
+            kwargs['target'] = self
+        kwargs['resolvers'] = tuple(kwargs.get('resolvers', ())) + resolvers
+        return _eval(expr, inplace=inplace, **kwargs)
+
+    def select_dtypes(self, include=None, exclude=None) -> DataFrame:
+        if not is_list_like(include):
+            include = (include,) if include is not None else ()
+        if not is_list_like(exclude):
+            exclude = (exclude,) if exclude is not None else ()
+        selection = (frozenset(include), frozenset(exclude))
+        if not any(selection):
+            raise ValueError('at least one of include or exclude must be nonempty')
+
+        def check_int_infer_dtype(dtypes):
+            converted_dtypes: list[type] = []
+            for dtype in dtypes:
+                if isinstance(dtype, str) and dtype == 'int' or dtype is int:
+                    converted_dtypes.append(np.int32)
+                    converted_dtypes.append(np.int64)
+                elif dtype == 'float' or dtype is float:
+                    converted_dtypes.extend([np.float64, np.float32])
+                else:
+                    converted_dtypes.append(infer_dtype_from_object(dtype))
+            return frozenset(converted_dtypes)
+        include = check_int_infer_dtype(include)
+        exclude = check_int_infer_dtype(exclude)
+        for dtypes in (include, exclude):
+            invalidate_string_dtypes(dtypes)
+        if not include.isdisjoint(exclude):
+            raise ValueError(f'include and exclude overlap on {include & exclude}')
+
+        def dtype_predicate(dtype: DtypeObj, dtypes_set) -> bool:
+            dtype = dtype if not isinstance(dtype, ArrowDtype) else dtype.numpy_dtype
+            return issubclass(dtype.type, tuple(dtypes_set)) or (np.number in dtypes_set and getattr(dtype, '_is_numeric', False) and (not is_bool_dtype(dtype)))
+
+        def predicate(arr: ArrayLike) -> bool:
+            dtype = arr.dtype
+            if include:
+                if not dtype_predicate(dtype, include):
+                    return False
+            if exclude:
+                if dtype_predicate(dtype, exclude):
+                    return False
+            return True
+        mgr = self._mgr._get_data_subset(predicate).copy(deep=False)
+        return self._constructor_from_mgr(mgr, axes=mgr.axes).__finalize__(self)
+
+    def insert(self, loc: int, column: Hashable, value: object, allow_duplicates: bool | lib.NoDefault=lib.no_default) -> None:
+        if allow_duplicates is lib.no_default:
+            allow_duplicates = False
+        if allow_duplicates and (not self.flags.allows_duplicate_labels):
+            raise ValueError("Cannot specify 'allow_duplicates=True' when 'self.flags.allows_duplicate_labels' is False.")
+        if not allow_duplicates and column in self.columns:
+            raise ValueError(f'cannot insert {column}, already exists')
+        if not is_integer(loc):
+            raise TypeError('loc must be int')
+        loc = int(loc)
+        if isinstance(value, DataFrame) and len(value.columns) > 1:
+            raise ValueError(f'Expected a one-dimensional object, got a DataFrame with {len(value.columns)} columns instead.')
+        elif isinstance(value, DataFrame):
+            value = value.iloc[:, 0]
+        (value, refs) = self._sanitize_column(value)
+        self._mgr.insert(loc, column, value, refs=refs)
+
+    def assign(self, **kwargs) -> DataFrame:
+        data = self.copy(deep=False)
+        for (k, v) in kwargs.items():
+            data[k] = com.apply_if_callable(v, data)
+        return data
+
+    def _sanitize_column(self, value) -> tuple[ArrayLike, BlockValuesRefs | None]:
+        self._ensure_valid_index(value)
+        assert not isinstance(value, DataFrame)
+        if is_dict_like(value):
+            if not isinstance(value, Series):
+                value = Series(value)
+            return _reindex_for_setitem(value, self.index)
+        if is_list_like(value):
+            com.require_length_match(value, self.index)
+        return (sanitize_array(value, self.index, copy=True, allow_2d=True), None)
+
+    @property
+    def _series(self):
+        return {item: self._ixs(idx, axis=1) for (idx, item) in enumerate(self.columns)}
+
+    def _reindex_multi(self, axes: dict[str, Index], fill_value) -> DataFrame:
+        (new_index, row_indexer) = self.index.reindex(axes['index'])
+        (new_columns, col_indexer) = self.columns.reindex(axes['columns'])
+        if row_indexer is not None and col_indexer is not None:
+            indexer = (row_indexer, col_indexer)
+            new_values = take_2d_multi(self.values, indexer, fill_value=fill_value)
+            return self._constructor(new_values, index=new_index, columns=new_columns, copy=False)
+        else:
+            return self._reindex_with_indexers({0: [new_index, row_indexer], 1: [new_columns, col_indexer]}, fill_value=fill_value)
+
+    @Appender('\n        Examples\n        --------\n        >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})\n\n        Change the row labels.\n\n        >>> df.set_axis([\'a\', \'b\', \'c\'], axis=\'index\')\n           A  B\n        a  1  4\n        b  2  5\n        c  3  6\n\n        Change the column labels.\n\n        >>> df.set_axis([\'I\', \'II\'], axis=\'columns\')\n           I  II\n        0  1   4\n        1  2   5\n        2  3   6\n        ')
+    @Substitution(klass=_shared_doc_kwargs['klass'], axes_single_arg=_shared_doc_kwargs['axes_single_arg'], extended_summary_sub=' column or', axis_description_sub=', and 1 identifies the columns', see_also_sub=' or columns')
+    @Appender(NDFrame.set_axis.__doc__)
+    def set_axis(self, labels, *, axis: Axis=0, copy: bool | lib.NoDefault=lib.no_default) -> DataFrame:
+        return super().set_axis(labels, axis=axis, copy=copy)
+
+    @doc(NDFrame.reindex, klass=_shared_doc_kwargs['klass'], optional_reindex=_shared_doc_kwargs['optional_reindex'])
+    def reindex(self, labels=None, *, index=None, columns=None, axis: Axis | None=None, method: ReindexMethod | None=None, copy: bool | lib.NoDefault=lib.no_default, level: Level | None=None, fill_value: Scalar | None=np.nan, limit: int | None=None, tolerance=None) -> DataFrame:
+        return super().reindex(labels=labels, index=index, columns=columns, axis=axis, method=method, level=level, fill_value=fill_value, limit=limit, tolerance=tolerance, copy=copy)
+
+    @overload
+    def drop(self, labels: IndexLabel | ListLike=..., *, axis: Axis=..., index: IndexLabel | ListLike=..., columns: IndexLabel | ListLike=..., level: Level=..., inplace: Literal[True], errors: IgnoreRaise=...) -> None:
+        ...
+
+    @overload
+    def drop(self, labels: IndexLabel | ListLike=..., *, axis: Axis=..., index: IndexLabel | ListLike=..., columns: IndexLabel | ListLike=..., level: Level=..., inplace: Literal[False]=..., errors: IgnoreRaise=...) -> DataFrame:
+        ...
+
+    @overload
+    def drop(self, labels: IndexLabel | ListLike=..., *, axis: Axis=..., index: IndexLabel | ListLike=..., columns: IndexLabel | ListLike=..., level: Level=..., inplace: bool=..., errors: IgnoreRaise=...) -> DataFrame | None:
+        ...
+
+    def drop(self, labels: IndexLabel | ListLike=None, *, axis: Axis=0, index: IndexLabel | ListLike=None, columns: IndexLabel | ListLike=None, level: Level | None=None, inplace: bool=False, errors: IgnoreRaise='raise') -> DataFrame | None:
+        return super().drop(labels=labels, axis=axis, index=index, columns=columns, level=level, inplace=inplace, errors=errors)
+
+    @overload
+    def rename(self, mapper: Renamer | None=..., *, index: Renamer | None=..., columns: Renamer | None=..., axis: Axis | None=..., copy: bool | lib.NoDefault=lib.no_default, inplace: Literal[True], level: Level=..., errors: IgnoreRaise=...) -> None:
+        ...
+
+    @overload
+    def rename(self, mapper: Renamer | None=..., *, index: Renamer | None=..., columns: Renamer | None=..., axis: Axis | None=..., copy: bool | lib.NoDefault=lib.no_default, inplace: Literal[False]=..., level: Level=..., errors: IgnoreRaise=...) -> DataFrame:
+        ...
+
+    @overload
+    def rename(self, mapper: Renamer | None=..., *, index: Renamer | None=..., columns: Renamer | None=..., axis: Axis | None=..., copy: bool | lib.NoDefault=lib.no_default, inplace: bool=..., level: Level=..., errors: IgnoreRaise=...) -> DataFrame | None:
+        ...
+
+    def rename(self, mapper: Renamer | None=None, *, index: Renamer | None=None, columns: Renamer | None=None, axis: Axis | None=None, copy: bool | lib.NoDefault=lib.no_default, inplace: bool=False, level: Level | None=None, errors: IgnoreRaise='ignore') -> DataFrame | None:
+        self._check_copy_deprecation(copy)
+        return super()._rename(mapper=mapper, index=index, columns=columns, axis=axis, inplace=inplace, level=level, errors=errors)
+
+    def pop(self, item: Hashable) -> Series:
+        return super().pop(item=item)
+
+    @overload
+    def _replace_columnwise(self, mapping: dict[Hashable, tuple[Any, Any]], inplace: Literal[True], regex) -> None:
+        ...
+
+    @overload
+    def _replace_columnwise(self, mapping: dict[Hashable, tuple[Any, Any]], inplace: Literal[False], regex) -> Self:
+        ...
+
+    def _replace_columnwise(self, mapping: dict[Hashable, tuple[Any, Any]], inplace: bool, regex) -> Self | None:
+        res = self if inplace else self.copy(deep=False)
+        ax = self.columns
+        for (i, ax_value) in enumerate(ax):
+            if ax_value in mapping:
+                ser = self.iloc[:, i]
+                (target, value) = mapping[ax_value]
+                newobj = ser.replace(target, value, regex=regex)
+                res._iset_item(i, newobj, inplace=inplace)
+        if inplace:
+            return None
+        return res.__finalize__(self)
+
+    @doc(NDFrame.shift, klass=_shared_doc_kwargs['klass'])
+    def shift(self, periods: int | Sequence[int]=1, freq: Frequency | None=None, axis: Axis=0, fill_value: Hashable=lib.no_default, suffix: str | None=None) -> DataFrame:
+        if freq is not None and fill_value is not lib.no_default:
+            raise ValueError("Passing a 'freq' together with a 'fill_value' is not allowed.")
+        if self.empty:
+            return self.copy()
+        axis = self._get_axis_number(axis)
+        if is_list_like(periods):
+            periods = cast(Sequence, periods)
+            if axis == 1:
+                raise ValueError('If `periods` contains multiple shifts, `axis` cannot be 1.')
+            if len(periods) == 0:
+                raise ValueError('If `periods` is an iterable, it cannot be empty.')
+            from pandas.core.reshape.concat import concat
+            shifted_dataframes = []
+            for period in periods:
+                if not is_integer(period):
+                    raise TypeError(f'Periods must be integer, but {period} is {type(period)}.')
+                period = cast(int, period)
+                shifted_dataframes.append(super().shift(periods=period, freq=freq, axis=axis, fill_value=fill_value).add_suffix(f'{suffix}_{period}' if suffix else f'_{period}'))
+            return concat(shifted_dataframes, axis=1)
+        elif suffix:
+            raise ValueError('Cannot specify `suffix` if `periods` is an int.')
+        periods = cast(int, periods)
+        ncols = len(self.columns)
+        if axis == 1 and periods != 0 and (ncols > 0) and (freq is None):
+            if fill_value is lib.no_default:
+                label = self.columns[0]
+                if periods > 0:
+                    result = self.iloc[:, :-periods]
+                    for col in range(min(ncols, abs(periods))):
+                        filler = self.iloc[:, 0].shift(len(self))
+                        result.insert(0, label, filler, allow_duplicates=True)
+                else:
+                    result = self.iloc[:, -periods:]
+                    for col in range(min(ncols, abs(periods))):
+                        filler = self.iloc[:, -1].shift(len(self))
+                        result.insert(len(result.columns), label, filler, allow_duplicates=True)
+                result.columns = self.columns.copy()
+                return result
+            elif len(self._mgr.blocks) > 1 or not can_hold_element(self._mgr.blocks[0].values, fill_value):
+                nper = abs(periods)
+                nper = min(nper, ncols)
+                if periods > 0:
+                    indexer = np.array([-1] * nper + list(range(ncols - periods)), dtype=np.intp)
+                else:
+                    indexer = np.array(list(range(nper, ncols)) + [-1] * nper, dtype=np.intp)
+                mgr = self._mgr.reindex_indexer(self.columns, indexer, axis=0, fill_value=fill_value, allow_dups=True)
+                res_df = self._constructor_from_mgr(mgr, axes=mgr.axes)
+                return res_df.__finalize__(self, method='shift')
+            else:
+                return self.T.shift(periods=periods, fill_value=fill_value).T
+        return super().shift(periods=periods, freq=freq, axis=axis, fill_value=fill_value)
+
+    @overload
+    def set_index(self, keys, *, drop: bool=..., append: bool=..., inplace: Literal[False]=..., verify_integrity: bool=...) -> DataFrame:
+        ...
+
+    @overload
+    def set_index(self, keys, *, drop: bool=..., append: bool=..., inplace: Literal[True], verify_integrity: bool=...) -> None:
+        ...
+
+    def set_index(self, keys, *, drop: bool=True, append: bool=False, inplace: bool=False, verify_integrity: bool=False) -> DataFrame | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        self._check_inplace_and_allows_duplicate_labels(inplace)
+        if not isinstance(keys, list):
+            keys = [keys]
+        err_msg = 'The parameter "keys" may be a column key, one-dimensional array, or a list containing only valid column keys and one-dimensional arrays.'
+        missing: list[Hashable] = []
+        for col in keys:
+            if isinstance(col, (Index, Series, np.ndarray, list, abc.Iterator)):
+                if getattr(col, 'ndim', 1) != 1:
+                    raise ValueError(err_msg)
+            else:
+                try:
+                    found = col in self.columns
+                except TypeError as err:
+                    raise TypeError(f'{err_msg}. Received column of type {type(col)}') from err
+                else:
+                    if not found:
+                        missing.append(col)
+        if missing:
+            raise KeyError(f'None of {missing} are in the columns')
+        if inplace:
+            frame = self
+        else:
+            frame = self.copy(deep=False)
+        arrays: list[Index] = []
+        names: list[Hashable] = []
+        if append:
+            names = list(self.index.names)
+            if isinstance(self.index, MultiIndex):
+                arrays.extend((self.index._get_level_values(i) for i in range(self.index.nlevels)))
+            else:
+                arrays.append(self.index)
+        to_remove: set[Hashable] = set()
+        for col in keys:
+            if isinstance(col, MultiIndex):
+                arrays.extend((col._get_level_values(n) for n in range(col.nlevels)))
+                names.extend(col.names)
+            elif isinstance(col, (Index, Series)):
+                arrays.append(col)
+                names.append(col.name)
+            elif isinstance(col, (list, np.ndarray)):
+                arrays.append(col)
+                names.append(None)
+            elif isinstance(col, abc.Iterator):
+                arrays.append(list(col))
+                names.append(None)
+            else:
+                arrays.append(frame[col])
+                names.append(col)
+                if drop:
+                    to_remove.add(col)
+            if len(arrays[-1]) != len(self):
+                raise ValueError(f'Length mismatch: Expected {len(self)} rows, received array of length {len(arrays[-1])}')
+        index = ensure_index_from_sequences(arrays, names)
+        if verify_integrity and (not index.is_unique):
+            duplicates = index[index.duplicated()].unique()
+            raise ValueError(f'Index has duplicate keys: {duplicates}')
+        for c in to_remove:
+            del frame[c]
+        index._cleanup()
+        frame.index = index
+        if not inplace:
+            return frame
+        return None
+
+    @overload
+    def reset_index(self, level: IndexLabel=..., *, drop: bool=..., inplace: Literal[False]=..., col_level: Hashable=..., col_fill: Hashable=..., allow_duplicates: bool | lib.NoDefault=..., names: Hashable | Sequence[Hashable] | None=None) -> DataFrame:
+        ...
+
+    @overload
+    def reset_index(self, level: IndexLabel=..., *, drop: bool=..., inplace: Literal[True], col_level: Hashable=..., col_fill: Hashable=..., allow_duplicates: bool | lib.NoDefault=..., names: Hashable | Sequence[Hashable] | None=None) -> None:
+        ...
+
+    @overload
+    def reset_index(self, level: IndexLabel=..., *, drop: bool=..., inplace: bool=..., col_level: Hashable=..., col_fill: Hashable=..., allow_duplicates: bool | lib.NoDefault=..., names: Hashable | Sequence[Hashable] | None=None) -> DataFrame | None:
+        ...
+
+    def reset_index(self, level: IndexLabel | None=None, *, drop: bool=False, inplace: bool=False, col_level: Hashable=0, col_fill: Hashable='', allow_duplicates: bool | lib.NoDefault=lib.no_default, names: Hashable | Sequence[Hashable] | None=None) -> DataFrame | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        self._check_inplace_and_allows_duplicate_labels(inplace)
+        if inplace:
+            new_obj = self
+        else:
+            new_obj = self.copy(deep=False)
+        if allow_duplicates is not lib.no_default:
+            allow_duplicates = validate_bool_kwarg(allow_duplicates, 'allow_duplicates')
+        new_index = default_index(len(new_obj))
+        if level is not None:
+            if not isinstance(level, (tuple, list)):
+                level = [level]
+            level = [self.index._get_level_number(lev) for lev in level]
+            if len(level) < self.index.nlevels:
+                new_index = self.index.droplevel(level)
+        if not drop:
+            to_insert: Iterable[tuple[Any, Any | None]]
+            default = 'index' if 'index' not in self else 'level_0'
+            names = self.index._get_default_index_names(names, default)
+            if isinstance(self.index, MultiIndex):
+                to_insert = zip(reversed(self.index.levels), reversed(self.index.codes))
+            else:
+                to_insert = ((self.index, None),)
+            multi_col = isinstance(self.columns, MultiIndex)
+            for (j, (lev, lab)) in enumerate(to_insert, start=1):
+                i = self.index.nlevels - j
+                if level is not None and i not in level:
+                    continue
+                name = names[i]
+                if multi_col:
+                    col_name = list(name) if isinstance(name, tuple) else [name]
+                    if col_fill is None:
+                        if len(col_name) not in (1, self.columns.nlevels):
+                            raise ValueError(f'col_fill=None is incompatible with incomplete column name {name}')
+                        col_fill = col_name[0]
+                    lev_num = self.columns._get_level_number(col_level)
+                    name_lst = [col_fill] * lev_num + col_name
+                    missing = self.columns.nlevels - len(name_lst)
+                    name_lst += [col_fill] * missing
+                    name = tuple(name_lst)
+                level_values = lev._values
+                if level_values.dtype == np.object_:
+                    level_values = lib.maybe_convert_objects(level_values)
+                if lab is not None:
+                    level_values = algorithms.take(level_values, lab, allow_fill=True, fill_value=lev._na_value)
+                new_obj.insert(0, name, level_values, allow_duplicates=allow_duplicates)
+        new_obj.index = new_index
+        if not inplace:
+            return new_obj
+        return None
+
+    @doc(NDFrame.isna, klass=_shared_doc_kwargs['klass'])
+    def isna(self) -> DataFrame:
+        res_mgr = self._mgr.isna(func=isna)
+        result = self._constructor_from_mgr(res_mgr, axes=res_mgr.axes)
+        return result.__finalize__(self, method='isna')
+
+    @doc(NDFrame.isna, klass=_shared_doc_kwargs['klass'])
+    def isnull(self) -> DataFrame:
+        return self.isna()
+
+    @doc(NDFrame.notna, klass=_shared_doc_kwargs['klass'])
+    def notna(self) -> DataFrame:
+        return ~self.isna()
+
+    @doc(NDFrame.notna, klass=_shared_doc_kwargs['klass'])
+    def notnull(self) -> DataFrame:
+        return ~self.isna()
+
+    @overload
+    def dropna(self, *, axis: Axis=..., how: AnyAll | lib.NoDefault=..., thresh: int | lib.NoDefault=..., subset: IndexLabel=..., inplace: Literal[False]=..., ignore_index: bool=...) -> DataFrame:
+        ...
+
+    @overload
+    def dropna(self, *, axis: Axis=..., how: AnyAll | lib.NoDefault=..., thresh: int | lib.NoDefault=..., subset: IndexLabel=..., inplace: Literal[True], ignore_index: bool=...) -> None:
+        ...
+
+    def dropna(self, *, axis: Axis=0, how: AnyAll | lib.NoDefault=lib.no_default, thresh: int | lib.NoDefault=lib.no_default, subset: IndexLabel | AnyArrayLike | None=None, inplace: bool=False, ignore_index: bool=False) -> DataFrame | None:
+        if how is not lib.no_default and thresh is not lib.no_default:
+            raise TypeError('You cannot set both the how and thresh arguments at the same time.')
+        if how is lib.no_default:
+            how = 'any'
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if isinstance(axis, (tuple, list)):
+            raise TypeError('supplying multiple axes to axis is no longer supported.')
+        axis = self._get_axis_number(axis)
+        agg_axis = 1 - axis
+        agg_obj = self
+        if subset is not None:
+            if not is_list_like(subset):
+                subset = [cast(Hashable, subset)]
+            ax = self._get_axis(agg_axis)
+            indices = ax.get_indexer_for(subset)
+            check = indices == -1
+            if check.any():
+                raise KeyError(np.array(subset)[check].tolist())
+            agg_obj = self.take(indices, axis=agg_axis)
+        if thresh is not lib.no_default:
+            count = agg_obj.count(axis=agg_axis)
+            mask = count >= thresh
+        elif how == 'any':
+            mask = notna(agg_obj).all(axis=agg_axis, bool_only=False)
+        elif how == 'all':
+            mask = notna(agg_obj).any(axis=agg_axis, bool_only=False)
+        else:
+            raise ValueError(f'invalid how option: {how}')
+        if np.all(mask):
+            result = self.copy(deep=False)
+        else:
+            result = self.loc(axis=axis)[mask]
+        if ignore_index:
+            result.index = default_index(len(result))
+        if not inplace:
+            return result
+        self._update_inplace(result)
+        return None
+
+    @overload
+    def drop_duplicates(self, subset: Hashable | Iterable[Hashable] | None=..., *, keep: DropKeep=..., inplace: Literal[True], ignore_index: bool=...) -> None:
+        ...
+
+    @overload
+    def drop_duplicates(self, subset: Hashable | Iterable[Hashable] | None=..., *, keep: DropKeep=..., inplace: Literal[False]=..., ignore_index: bool=...) -> DataFrame:
+        ...
+
+    @overload
+    def drop_duplicates(self, subset: Hashable | Iterable[Hashable] | None=..., *, keep: DropKeep=..., inplace: bool=..., ignore_index: bool=...) -> DataFrame | None:
+        ...
+
+    def drop_duplicates(self, subset: Hashable | Iterable[Hashable] | None=None, *, keep: DropKeep='first', inplace: bool=False, ignore_index: bool=False) -> DataFrame | None:
+        if self.empty:
+            return self.copy(deep=False)
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        ignore_index = validate_bool_kwarg(ignore_index, 'ignore_index')
+        result = self[-self.duplicated(subset, keep=keep)]
+        if ignore_index:
+            result.index = default_index(len(result))
+        if inplace:
+            self._update_inplace(result)
+            return None
+        else:
+            return result
+
+    def duplicated(self, subset: Hashable | Iterable[Hashable] | None=None, keep: DropKeep='first') -> Series:
+        if self.empty:
+            return self._constructor_sliced(dtype=bool)
+
+        def f(vals) -> tuple[np.ndarray, int]:
+            (labels, shape) = algorithms.factorize(vals, size_hint=len(self))
+            return (labels.astype('i8'), len(shape))
+        if subset is None:
+            subset = self.columns
+        elif not np.iterable(subset) or isinstance(subset, str) or (isinstance(subset, tuple) and subset in self.columns):
+            subset = (subset,)
+        subset = cast(Sequence, subset)
+        diff = set(subset) - set(self.columns)
+        if diff:
+            raise KeyError(Index(diff))
+        if len(subset) == 1 and self.columns.is_unique:
+            result = self[next(iter(subset))].duplicated(keep)
+            result.name = None
+        else:
+            vals = (col.values for (name, col) in self.items() if name in subset)
+            (labels, shape) = map(list, zip(*map(f, vals)))
+            ids = get_group_index(labels, tuple(shape), sort=False, xnull=False)
+            result = self._constructor_sliced(duplicated(ids, keep), index=self.index)
+        return result.__finalize__(self, method='duplicated')
+
+    @overload
+    def sort_values(self, by: IndexLabel, *, axis: Axis=..., ascending=..., inplace: Literal[False]=..., kind: SortKind=..., na_position: NaPosition=..., ignore_index: bool=..., key: ValueKeyFunc=...) -> DataFrame:
+        ...
+
+    @overload
+    def sort_values(self, by: IndexLabel, *, axis: Axis=..., ascending=..., inplace: Literal[True], kind: SortKind=..., na_position: str=..., ignore_index: bool=..., key: ValueKeyFunc=...) -> None:
+        ...
+
+    def sort_values(self, by: IndexLabel, *, axis: Axis=0, ascending: bool | list[bool] | tuple[bool, ...]=True, inplace: bool=False, kind: SortKind='quicksort', na_position: str='last', ignore_index: bool=False, key: ValueKeyFunc | None=None) -> DataFrame | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        axis = self._get_axis_number(axis)
+        ascending = validate_ascending(ascending)
+        if not isinstance(by, list):
+            by = [by]
+        if is_sequence(ascending) and len(by) != len(ascending):
+            raise ValueError(f'Length of ascending ({len(ascending)}) != length of by ({len(by)})')
+        if len(by) > 1:
+            keys = (self._get_label_or_level_values(x, axis=axis) for x in by)
+            if key is not None:
+                keys_data = [Series(k, name=name) for (k, name) in zip(keys, by)]
+            else:
+                keys_data = list(keys)
+            indexer = lexsort_indexer(keys_data, orders=ascending, na_position=na_position, key=key)
+        elif len(by):
+            k = self._get_label_or_level_values(by[0], axis=axis)
+            if key is not None:
+                k = Series(k, name=by[0])
+            if isinstance(ascending, (tuple, list)):
+                ascending = ascending[0]
+            indexer = nargsort(k, kind=kind, ascending=ascending, na_position=na_position, key=key)
+        elif inplace:
+            return self._update_inplace(self)
+        else:
+            return self.copy(deep=False)
+        if is_range_indexer(indexer, len(indexer)):
+            result = self.copy(deep=False)
+            if ignore_index:
+                result.index = default_index(len(result))
+            if inplace:
+                return self._update_inplace(result)
+            else:
+                return result
+        new_data = self._mgr.take(indexer, axis=self._get_block_manager_axis(axis), verify=False)
+        if ignore_index:
+            new_data.set_axis(self._get_block_manager_axis(axis), default_index(len(indexer)))
+        result = self._constructor_from_mgr(new_data, axes=new_data.axes)
+        if inplace:
+            return self._update_inplace(result)
+        else:
+            return result.__finalize__(self, method='sort_values')
+
+    @overload
+    def sort_index(self, *, axis: Axis=..., level: IndexLabel=..., ascending: bool | Sequence[bool]=..., inplace: Literal[True], kind: SortKind=..., na_position: NaPosition=..., sort_remaining: bool=..., ignore_index: bool=..., key: IndexKeyFunc=...) -> None:
+        ...
+
+    @overload
+    def sort_index(self, *, axis: Axis=..., level: IndexLabel=..., ascending: bool | Sequence[bool]=..., inplace: Literal[False]=..., kind: SortKind=..., na_position: NaPosition=..., sort_remaining: bool=..., ignore_index: bool=..., key: IndexKeyFunc=...) -> DataFrame:
+        ...
+
+    @overload
+    def sort_index(self, *, axis: Axis=..., level: IndexLabel=..., ascending: bool | Sequence[bool]=..., inplace: bool=..., kind: SortKind=..., na_position: NaPosition=..., sort_remaining: bool=..., ignore_index: bool=..., key: IndexKeyFunc=...) -> DataFrame | None:
+        ...
+
+    def sort_index(self, *, axis: Axis=0, level: IndexLabel | None=None, ascending: bool | Sequence[bool]=True, inplace: bool=False, kind: SortKind='quicksort', na_position: NaPosition='last', sort_remaining: bool=True, ignore_index: bool=False, key: IndexKeyFunc | None=None) -> DataFrame | None:
+        return super().sort_index(axis=axis, level=level, ascending=ascending, inplace=inplace, kind=kind, na_position=na_position, sort_remaining=sort_remaining, ignore_index=ignore_index, key=key)
+
+    def value_counts(self, subset: IndexLabel | None=None, normalize: bool=False, sort: bool=True, ascending: bool=False, dropna: bool=True) -> Series:
+        if subset is None:
+            subset = self.columns.tolist()
+        name = 'proportion' if normalize else 'count'
+        counts = self.groupby(subset, dropna=dropna, observed=False)._grouper.size()
+        counts.name = name
+        if sort:
+            counts = counts.sort_values(ascending=ascending)
+        if normalize:
+            counts /= counts.sum()
+        if is_list_like(subset) and len(subset) == 1:
+            counts.index = MultiIndex.from_arrays([counts.index], names=[counts.index.name])
+        return counts
+
+    def nlargest(self, n: int, columns: IndexLabel, keep: NsmallestNlargestKeep='first') -> DataFrame:
+        return selectn.SelectNFrame(self, n=n, keep=keep, columns=columns).nlargest()
+
+    def nsmallest(self, n: int, columns: IndexLabel, keep: NsmallestNlargestKeep='first') -> DataFrame:
+        return selectn.SelectNFrame(self, n=n, keep=keep, columns=columns).nsmallest()
+
+    def swaplevel(self, i: Axis=-2, j: Axis=-1, axis: Axis=0) -> DataFrame:
+        result = self.copy(deep=False)
+        axis = self._get_axis_number(axis)
+        if not isinstance(result._get_axis(axis), MultiIndex):
+            raise TypeError('Can only swap levels on a hierarchical axis.')
+        if axis == 0:
+            assert isinstance(result.index, MultiIndex)
+            result.index = result.index.swaplevel(i, j)
+        else:
+            assert isinstance(result.columns, MultiIndex)
+            result.columns = result.columns.swaplevel(i, j)
+        return result
+
+    def reorder_levels(self, order: Sequence[int | str], axis: Axis=0) -> DataFrame:
+        axis = self._get_axis_number(axis)
+        if not isinstance(self._get_axis(axis), MultiIndex):
+            raise TypeError('Can only reorder levels on a hierarchical axis.')
+        result = self.copy(deep=False)
+        if axis == 0:
+            assert isinstance(result.index, MultiIndex)
+            result.index = result.index.reorder_levels(order)
+        else:
+            assert isinstance(result.columns, MultiIndex)
+            result.columns = result.columns.reorder_levels(order)
+        return result
+
+    def _cmp_method(self, other, op):
+        axis: Literal[1] = 1
+        (self, other) = self._align_for_op(other, axis, flex=False, level=None)
+        new_data = self._dispatch_frame_op(other, op, axis=axis)
+        return self._construct_result(new_data)
+
+    def _arith_method(self, other, op):
+        if self._should_reindex_frame_op(other, op, 1, None, None):
+            return self._arith_method_with_reindex(other, op)
+        axis: Literal[1] = 1
+        other = ops.maybe_prepare_scalar_for_op(other, (self.shape[axis],))
+        (self, other) = self._align_for_op(other, axis, flex=True, level=None)
+        with np.errstate(all='ignore'):
+            new_data = self._dispatch_frame_op(other, op, axis=axis)
+        return self._construct_result(new_data)
+    _logical_method = _arith_method
+
+    def _dispatch_frame_op(self, right, func: Callable, axis: AxisInt | None=None) -> DataFrame:
+        array_op = ops.get_array_op(func)
+        right = lib.item_from_zerodim(right)
+        if not is_list_like(right):
+            bm = self._mgr.apply(array_op, right=right)
+            return self._constructor_from_mgr(bm, axes=bm.axes)
+        elif isinstance(right, DataFrame):
+            assert self.index.equals(right.index)
+            assert self.columns.equals(right.columns)
+            bm = self._mgr.operate_blockwise(right._mgr, array_op)
+            return self._constructor_from_mgr(bm, axes=bm.axes)
+        elif isinstance(right, Series) and axis == 1:
+            assert right.index.equals(self.columns)
+            right = right._values
+            assert not isinstance(right, np.ndarray)
+            arrays = [array_op(_left, _right) for (_left, _right) in zip(self._iter_column_arrays(), right)]
+        elif isinstance(right, Series):
+            assert right.index.equals(self.index)
+            right = right._values
+            arrays = [array_op(left, right) for left in self._iter_column_arrays()]
+        else:
+            raise NotImplementedError(right)
+        return type(self)._from_arrays(arrays, self.columns, self.index, verify_integrity=False)
+
+    def _combine_frame(self, other: DataFrame, func, fill_value=None):
+        if fill_value is None:
+            _arith_op = func
+        else:
+
+            def _arith_op(left, right):
+                (left, right) = ops.fill_binop(left, right, fill_value)
+                return func(left, right)
+        new_data = self._dispatch_frame_op(other, _arith_op)
+        return new_data
+
+    def _arith_method_with_reindex(self, right: DataFrame, op) -> DataFrame:
+        left = self
+        (cols, lcol_indexer, rcol_indexer) = left.columns.join(right.columns, how='inner', return_indexers=True)
+        new_left = left if lcol_indexer is None else left.iloc[:, lcol_indexer]
+        new_right = right if rcol_indexer is None else right.iloc[:, rcol_indexer]
+        result = op(new_left, new_right)
+        join_columns = left.columns.join(right.columns, how='outer')
+        if result.columns.has_duplicates:
+            (indexer, _) = result.columns.get_indexer_non_unique(join_columns)
+            indexer = algorithms.unique1d(indexer)
+            result = result._reindex_with_indexers({1: [join_columns, indexer]}, allow_dups=True)
+        else:
+            result = result.reindex(join_columns, axis=1)
+        return result
+
+    def _should_reindex_frame_op(self, right, op, axis: int, fill_value, level) -> bool:
+        if op is operator.pow or op is roperator.rpow:
+            return False
+        if not isinstance(right, DataFrame):
+            return False
+        if fill_value is None and level is None and (axis == 1):
+            left_uniques = self.columns.unique()
+            right_uniques = right.columns.unique()
+            cols = left_uniques.intersection(right_uniques)
+            if len(cols) and (not (len(cols) == len(left_uniques) and len(cols) == len(right_uniques))):
+                return True
+        return False
+
+    def _align_for_op(self, other, axis: AxisInt, flex: bool | None=False, level: Level | None=None):
+        (left, right) = (self, other)
+
+        def to_series(right):
+            msg = 'Unable to coerce to Series, length must be {req_len}: given {given_len}'
+            dtype = None
+            if getattr(right, 'dtype', None) == object:
+                dtype = object
+            if axis == 0:
+                if len(left.index) != len(right):
+                    raise ValueError(msg.format(req_len=len(left.index), given_len=len(right)))
+                right = left._constructor_sliced(right, index=left.index, dtype=dtype)
+            else:
+                if len(left.columns) != len(right):
+                    raise ValueError(msg.format(req_len=len(left.columns), given_len=len(right)))
+                right = left._constructor_sliced(right, index=left.columns, dtype=dtype)
+            return right
+        if isinstance(right, np.ndarray):
+            if right.ndim == 1:
+                right = to_series(right)
+            elif right.ndim == 2:
+                dtype = None
+                if right.dtype == object:
+                    dtype = object
+                if right.shape == left.shape:
+                    right = left._constructor(right, index=left.index, columns=left.columns, dtype=dtype)
+                elif right.shape[0] == left.shape[0] and right.shape[1] == 1:
+                    right = np.broadcast_to(right, left.shape)
+                    right = left._constructor(right, index=left.index, columns=left.columns, dtype=dtype)
+                elif right.shape[1] == left.shape[1] and right.shape[0] == 1:
+                    right = to_series(right[0, :])
+                else:
+                    raise ValueError(f'Unable to coerce to DataFrame, shape must be {left.shape}: given {right.shape}')
+            elif right.ndim > 2:
+                raise ValueError(f'Unable to coerce to Series/DataFrame, dimension must be <= 2: {right.shape}')
+        elif is_list_like(right) and (not isinstance(right, (Series, DataFrame))):
+            if any((is_array_like(el) for el in right)):
+                raise ValueError(f'Unable to coerce list of {type(right[0])} to Series/DataFrame')
+            right = to_series(right)
+        if flex is not None and isinstance(right, DataFrame):
+            if not left._indexed_same(right):
+                if flex:
+                    (left, right) = left.align(right, join='outer', level=level)
+                else:
+                    raise ValueError('Can only compare identically-labeled (both index and columns) DataFrame objects')
+        elif isinstance(right, Series):
+            axis = axis if axis is not None else 1
+            if not flex:
+                if not left.axes[axis].equals(right.index):
+                    raise ValueError('Operands are not aligned. Do `left, right = left.align(right, axis=1)` before operating.')
+            (left, right) = left.align(right, join='outer', axis=axis, level=level)
+            right = left._maybe_align_series_as_frame(right, axis)
+        return (left, right)
+
+    def _maybe_align_series_as_frame(self, series: Series, axis: AxisInt):
+        rvalues = series._values
+        if not isinstance(rvalues, np.ndarray):
+            if rvalues.dtype in ('datetime64[ns]', 'timedelta64[ns]'):
+                rvalues = np.asarray(rvalues)
+            else:
+                return series
+        if axis == 0:
+            rvalues = rvalues.reshape(-1, 1)
+        else:
+            rvalues = rvalues.reshape(1, -1)
+        rvalues = np.broadcast_to(rvalues, self.shape)
+        return self._constructor(rvalues, index=self.index, columns=self.columns, dtype=rvalues.dtype)
+
+    def _flex_arith_method(self, other, op, *, axis: Axis='columns', level=None, fill_value=None):
+        axis = self._get_axis_number(axis) if axis is not None else 1
+        if self._should_reindex_frame_op(other, op, axis, fill_value, level):
+            return self._arith_method_with_reindex(other, op)
+        if isinstance(other, Series) and fill_value is not None:
+            raise NotImplementedError(f'fill_value {fill_value} not supported.')
+        other = ops.maybe_prepare_scalar_for_op(other, self.shape)
+        (self, other) = self._align_for_op(other, axis, flex=True, level=level)
+        with np.errstate(all='ignore'):
+            if isinstance(other, DataFrame):
+                new_data = self._combine_frame(other, op, fill_value)
+            elif isinstance(other, Series):
+                new_data = self._dispatch_frame_op(other, op, axis=axis)
+            else:
+                if fill_value is not None:
+                    self = self.fillna(fill_value)
+                new_data = self._dispatch_frame_op(other, op)
+        return self._construct_result(new_data)
+
+    def _construct_result(self, result) -> DataFrame:
+        out = self._constructor(result, copy=False).__finalize__(self)
+        out.columns = self.columns
+        out.index = self.index
+        return out
+
+    def __divmod__(self, other) -> tuple[DataFrame, DataFrame]:
+        div = self // other
+        mod = self - div * other
+        return (div, mod)
+
+    def __rdivmod__(self, other) -> tuple[DataFrame, DataFrame]:
+        div = other // self
+        mod = other - div * self
+        return (div, mod)
+
+    def _flex_cmp_method(self, other, op, *, axis: Axis='columns', level=None):
+        axis = self._get_axis_number(axis) if axis is not None else 1
+        (self, other) = self._align_for_op(other, axis, flex=True, level=level)
+        new_data = self._dispatch_frame_op(other, op, axis=axis)
+        return self._construct_result(new_data)
+
+    @Appender(ops.make_flex_doc('eq', 'dataframe'))
+    def eq(self, other, axis: Axis='columns', level=None) -> DataFrame:
+        return self._flex_cmp_method(other, operator.eq, axis=axis, level=level)
+
+    @Appender(ops.make_flex_doc('ne', 'dataframe'))
+    def ne(self, other, axis: Axis='columns', level=None) -> DataFrame:
+        return self._flex_cmp_method(other, operator.ne, axis=axis, level=level)
+
+    @Appender(ops.make_flex_doc('le', 'dataframe'))
+    def le(self, other, axis: Axis='columns', level=None) -> DataFrame:
+        return self._flex_cmp_method(other, operator.le, axis=axis, level=level)
+
+    @Appender(ops.make_flex_doc('lt', 'dataframe'))
+    def lt(self, other, axis: Axis='columns', level=None) -> DataFrame:
+        return self._flex_cmp_method(other, operator.lt, axis=axis, level=level)
+
+    @Appender(ops.make_flex_doc('ge', 'dataframe'))
+    def ge(self, other, axis: Axis='columns', level=None) -> DataFrame:
+        return self._flex_cmp_method(other, operator.ge, axis=axis, level=level)
+
+    @Appender(ops.make_flex_doc('gt', 'dataframe'))
+    def gt(self, other, axis: Axis='columns', level=None) -> DataFrame:
+        return self._flex_cmp_method(other, operator.gt, axis=axis, level=level)
+
+    @Appender(ops.make_flex_doc('add', 'dataframe'))
+    def add(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, operator.add, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('radd', 'dataframe'))
+    def radd(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, roperator.radd, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('sub', 'dataframe'))
+    def sub(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, operator.sub, level=level, fill_value=fill_value, axis=axis)
+    subtract = sub
+
+    @Appender(ops.make_flex_doc('rsub', 'dataframe'))
+    def rsub(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, roperator.rsub, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('mul', 'dataframe'))
+    def mul(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, operator.mul, level=level, fill_value=fill_value, axis=axis)
+    multiply = mul
+
+    @Appender(ops.make_flex_doc('rmul', 'dataframe'))
+    def rmul(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, roperator.rmul, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('truediv', 'dataframe'))
+    def truediv(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, operator.truediv, level=level, fill_value=fill_value, axis=axis)
+    div = truediv
+    divide = truediv
+
+    @Appender(ops.make_flex_doc('rtruediv', 'dataframe'))
+    def rtruediv(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, roperator.rtruediv, level=level, fill_value=fill_value, axis=axis)
+    rdiv = rtruediv
+
+    @Appender(ops.make_flex_doc('floordiv', 'dataframe'))
+    def floordiv(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, operator.floordiv, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('rfloordiv', 'dataframe'))
+    def rfloordiv(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, roperator.rfloordiv, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('mod', 'dataframe'))
+    def mod(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, operator.mod, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('rmod', 'dataframe'))
+    def rmod(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, roperator.rmod, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('pow', 'dataframe'))
+    def pow(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, operator.pow, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('rpow', 'dataframe'))
+    def rpow(self, other, axis: Axis='columns', level=None, fill_value=None) -> DataFrame:
+        return self._flex_arith_method(other, roperator.rpow, level=level, fill_value=fill_value, axis=axis)
+
+    @doc(_shared_docs['compare'], dedent('\n        Returns\n        -------\n        DataFrame\n            DataFrame that shows the differences stacked side by side.\n\n            The resulting index will be a MultiIndex with \'self\' and \'other\'\n            stacked alternately at the inner level.\n\n        Raises\n        ------\n        ValueError\n            When the two DataFrames don\'t have identical labels or shape.\n\n        See Also\n        --------\n        Series.compare : Compare with another Series and show differences.\n        DataFrame.equals : Test whether two objects contain the same elements.\n\n        Notes\n        -----\n        Matching NaNs will not appear as a difference.\n\n        Can only compare identically-labeled\n        (i.e. same shape, identical row and column labels) DataFrames\n\n        Examples\n        --------\n        >>> df = pd.DataFrame(\n        ...     {{\n        ...         "col1": ["a", "a", "b", "b", "a"],\n        ...         "col2": [1.0, 2.0, 3.0, np.nan, 5.0],\n        ...         "col3": [1.0, 2.0, 3.0, 4.0, 5.0]\n        ...     }},\n        ...     columns=["col1", "col2", "col3"],\n        ... )\n        >>> df\n          col1  col2  col3\n        0    a   1.0   1.0\n        1    a   2.0   2.0\n        2    b   3.0   3.0\n        3    b   NaN   4.0\n        4    a   5.0   5.0\n\n        >>> df2 = df.copy()\n        >>> df2.loc[0, \'col1\'] = \'c\'\n        >>> df2.loc[2, \'col3\'] = 4.0\n        >>> df2\n          col1  col2  col3\n        0    c   1.0   1.0\n        1    a   2.0   2.0\n        2    b   3.0   4.0\n        3    b   NaN   4.0\n        4    a   5.0   5.0\n\n        Align the differences on columns\n\n        >>> df.compare(df2)\n          col1       col3\n          self other self other\n        0    a     c  NaN   NaN\n        2  NaN   NaN  3.0   4.0\n\n        Assign result_names\n\n        >>> df.compare(df2, result_names=("left", "right"))\n          col1       col3\n          left right left right\n        0    a     c  NaN   NaN\n        2  NaN   NaN  3.0   4.0\n\n        Stack the differences on rows\n\n        >>> df.compare(df2, align_axis=0)\n                col1  col3\n        0 self     a   NaN\n          other    c   NaN\n        2 self   NaN   3.0\n          other  NaN   4.0\n\n        Keep the equal values\n\n        >>> df.compare(df2, keep_equal=True)\n          col1       col3\n          self other self other\n        0    a     c  1.0   1.0\n        2    b     b  3.0   4.0\n\n        Keep all original rows and columns\n\n        >>> df.compare(df2, keep_shape=True)\n          col1       col2       col3\n          self other self other self other\n        0    a     c  NaN   NaN  NaN   NaN\n        1  NaN   NaN  NaN   NaN  NaN   NaN\n        2  NaN   NaN  NaN   NaN  3.0   4.0\n        3  NaN   NaN  NaN   NaN  NaN   NaN\n        4  NaN   NaN  NaN   NaN  NaN   NaN\n\n        Keep all original rows and columns and also all original values\n\n        >>> df.compare(df2, keep_shape=True, keep_equal=True)\n          col1       col2       col3\n          self other self other self other\n        0    a     c  1.0   1.0  1.0   1.0\n        1    a     a  2.0   2.0  2.0   2.0\n        2    b     b  3.0   3.0  3.0   4.0\n        3    b     b  NaN   NaN  4.0   4.0\n        4    a     a  5.0   5.0  5.0   5.0\n        '), klass=_shared_doc_kwargs['klass'])
+    def compare(self, other: DataFrame, align_axis: Axis=1, keep_shape: bool=False, keep_equal: bool=False, result_names: Suffixes=('self', 'other')) -> DataFrame:
+        return super().compare(other=other, align_axis=align_axis, keep_shape=keep_shape, keep_equal=keep_equal, result_names=result_names)
+
+    def combine(self, other: DataFrame, func: Callable[[Series, Series], Series | Hashable], fill_value=None, overwrite: bool=True) -> DataFrame:
+        other_idxlen = len(other.index)
+        (this, other) = self.align(other)
+        new_index = this.index
+        if other.empty and len(new_index) == len(self.index):
+            return self.copy()
+        if self.empty and len(other) == other_idxlen:
+            return other.copy()
+        new_columns = this.columns.union(other.columns)
+        do_fill = fill_value is not None
+        result = {}
+        for col in new_columns:
+            series = this[col]
+            other_series = other[col]
+            this_dtype = series.dtype
+            other_dtype = other_series.dtype
+            this_mask = isna(series)
+            other_mask = isna(other_series)
+            if not overwrite and other_mask.all():
+                result[col] = this[col].copy()
+                continue
+            if do_fill:
+                series = series.copy()
+                other_series = other_series.copy()
+                series[this_mask] = fill_value
+                other_series[other_mask] = fill_value
+            if col not in self.columns:
+                new_dtype = other_dtype
+                try:
+                    series = series.astype(new_dtype)
+                except ValueError:
+                    pass
+            else:
+                new_dtype = find_common_type([this_dtype, other_dtype])
+                series = series.astype(new_dtype)
+                other_series = other_series.astype(new_dtype)
+            arr = func(series, other_series)
+            if isinstance(new_dtype, np.dtype):
+                arr = maybe_downcast_to_dtype(arr, new_dtype)
+            result[col] = arr
+        frame_result = self._constructor(result, index=new_index, columns=new_columns)
+        return frame_result.__finalize__(self, method='combine')
+
+    def combine_first(self, other: DataFrame) -> DataFrame:
+        from pandas.core.computation import expressions
+
+        def combiner(x: Series, y: Series):
+            mask = x.isna()._values
+            x_values = x._values
+            y_values = y._values
+            if y.name not in self.columns:
+                return y_values
+            return expressions.where(mask, y_values, x_values)
+        if len(other) == 0:
+            combined = self.reindex(self.columns.append(other.columns.difference(self.columns)), axis=1)
+            combined = combined.astype(other.dtypes)
+        else:
+            combined = self.combine(other, combiner, overwrite=False)
+        dtypes = {col: find_common_type([self.dtypes[col], other.dtypes[col]]) for col in self.columns.intersection(other.columns) if combined.dtypes[col] != self.dtypes[col]}
+        if dtypes:
+            combined = combined.astype(dtypes)
+        return combined.__finalize__(self, method='combine_first')
+
+    def update(self, other, join: UpdateJoin='left', overwrite: bool=True, filter_func=None, errors: IgnoreRaise='ignore') -> None:
+        if not PYPY:
+            if sys.getrefcount(self) <= REF_COUNT:
+                warnings.warn(_chained_assignment_method_msg, ChainedAssignmentError, stacklevel=2)
+        if join != 'left':
+            raise NotImplementedError('Only left join is supported')
+        if errors not in ['ignore', 'raise']:
+            raise ValueError("The parameter errors must be either 'ignore' or 'raise'")
+        if not isinstance(other, DataFrame):
+            other = DataFrame(other)
+        if other.index.has_duplicates:
+            raise ValueError('Update not allowed with duplicate indexes on other.')
+        index_intersection = other.index.intersection(self.index)
+        if index_intersection.empty:
+            raise ValueError('Update not allowed when the index on `other` has no intersection with this dataframe.')
+        other = other.reindex(index_intersection)
+        this_data = self.loc[index_intersection]
+        for col in self.columns.intersection(other.columns):
+            this = this_data[col]
+            that = other[col]
+            if filter_func is not None:
+                mask = ~filter_func(this) | isna(that)
+            else:
+                if errors == 'raise':
+                    mask_this = notna(that)
+                    mask_that = notna(this)
+                    if any(mask_this & mask_that):
+                        raise ValueError('Data overlaps.')
+                if overwrite:
+                    mask = isna(that)
+                else:
+                    mask = notna(this)
+            if mask.all():
+                continue
+            self.loc[index_intersection, col] = this.where(mask, that)
+
+    @Appender(dedent('\n        Examples\n        --------\n        >>> df = pd.DataFrame({\'Animal\': [\'Falcon\', \'Falcon\',\n        ...                               \'Parrot\', \'Parrot\'],\n        ...                    \'Max Speed\': [380., 370., 24., 26.]})\n        >>> df\n           Animal  Max Speed\n        0  Falcon      380.0\n        1  Falcon      370.0\n        2  Parrot       24.0\n        3  Parrot       26.0\n        >>> df.groupby([\'Animal\']).mean()\n                Max Speed\n        Animal\n        Falcon      375.0\n        Parrot       25.0\n\n        **Hierarchical Indexes**\n\n        We can groupby different levels of a hierarchical index\n        using the `level` parameter:\n\n        >>> arrays = [[\'Falcon\', \'Falcon\', \'Parrot\', \'Parrot\'],\n        ...           [\'Captive\', \'Wild\', \'Captive\', \'Wild\']]\n        >>> index = pd.MultiIndex.from_arrays(arrays, names=(\'Animal\', \'Type\'))\n        >>> df = pd.DataFrame({\'Max Speed\': [390., 350., 30., 20.]},\n        ...                   index=index)\n        >>> df\n                        Max Speed\n        Animal Type\n        Falcon Captive      390.0\n               Wild         350.0\n        Parrot Captive       30.0\n               Wild          20.0\n        >>> df.groupby(level=0).mean()\n                Max Speed\n        Animal\n        Falcon      370.0\n        Parrot       25.0\n        >>> df.groupby(level="Type").mean()\n                 Max Speed\n        Type\n        Captive      210.0\n        Wild         185.0\n\n        We can also choose to include NA in group keys or not by setting\n        `dropna` parameter, the default setting is `True`.\n\n        >>> arr = [[1, 2, 3], [1, None, 4], [2, 1, 3], [1, 2, 2]]\n        >>> df = pd.DataFrame(arr, columns=["a", "b", "c"])\n\n        >>> df.groupby(by=["b"]).sum()\n            a   c\n        b\n        1.0 2   3\n        2.0 2   5\n\n        >>> df.groupby(by=["b"], dropna=False).sum()\n            a   c\n        b\n        1.0 2   3\n        2.0 2   5\n        NaN 1   4\n\n        >>> arr = [["a", 12, 12], [None, 12.3, 33.], ["b", 12.3, 123], ["a", 1, 1]]\n        >>> df = pd.DataFrame(arr, columns=["a", "b", "c"])\n\n        >>> df.groupby(by="a").sum()\n            b     c\n        a\n        a   13.0   13.0\n        b   12.3  123.0\n\n        >>> df.groupby(by="a", dropna=False).sum()\n            b     c\n        a\n        a   13.0   13.0\n        b   12.3  123.0\n        NaN 12.3   33.0\n\n        When using ``.apply()``, use ``group_keys`` to include or exclude the\n        group keys. The ``group_keys`` argument defaults to ``True`` (include).\n\n        >>> df = pd.DataFrame({\'Animal\': [\'Falcon\', \'Falcon\',\n        ...                               \'Parrot\', \'Parrot\'],\n        ...                    \'Max Speed\': [380., 370., 24., 26.]})\n        >>> df.groupby("Animal", group_keys=True)[[\'Max Speed\']].apply(lambda x: x)\n                  Max Speed\n        Animal\n        Falcon 0      380.0\n               1      370.0\n        Parrot 2       24.0\n               3       26.0\n\n        >>> df.groupby("Animal", group_keys=False)[[\'Max Speed\']].apply(lambda x: x)\n           Max Speed\n        0      380.0\n        1      370.0\n        2       24.0\n        3       26.0\n        '))
+    @Appender(_shared_docs['groupby'] % _shared_doc_kwargs)
+    def groupby(self, by=None, level: IndexLabel | None=None, as_index: bool=True, sort: bool=True, group_keys: bool=True, observed: bool=True, dropna: bool=True) -> DataFrameGroupBy:
+        from pandas.core.groupby.generic import DataFrameGroupBy
+        if level is None and by is None:
+            raise TypeError("You have to supply one of 'by' and 'level'")
+        return DataFrameGroupBy(obj=self, keys=by, level=level, as_index=as_index, sort=sort, group_keys=group_keys, observed=observed, dropna=dropna)
+    _shared_docs['pivot'] = '\n        Return reshaped DataFrame organized by given index / column values.\n\n        Reshape data (produce a "pivot" table) based on column values. Uses\n        unique values from specified `index` / `columns` to form axes of the\n        resulting DataFrame. This function does not support data\n        aggregation, multiple values will result in a MultiIndex in the\n        columns. See the :ref:`User Guide <reshaping>` for more on reshaping.\n\n        Parameters\n        ----------%s\n        columns : str or object or a list of str\n            Column to use to make new frame\'s columns.\n        index : str or object or a list of str, optional\n            Column to use to make new frame\'s index. If not given, uses existing index.\n        values : str, object or a list of the previous, optional\n            Column(s) to use for populating new frame\'s values. If not\n            specified, all remaining columns will be used and the result will\n            have hierarchically indexed columns.\n\n        Returns\n        -------\n        DataFrame\n            Returns reshaped DataFrame.\n\n        Raises\n        ------\n        ValueError:\n            When there are any `index`, `columns` combinations with multiple\n            values. `DataFrame.pivot_table` when you need to aggregate.\n\n        See Also\n        --------\n        DataFrame.pivot_table : Generalization of pivot that can handle\n            duplicate values for one index/column pair.\n        DataFrame.unstack : Pivot based on the index values instead of a\n            column.\n        wide_to_long : Wide panel to long format. Less flexible but more\n            user-friendly than melt.\n\n        Notes\n        -----\n        For finer-tuned control, see hierarchical indexing documentation along\n        with the related stack/unstack methods.\n\n        Reference :ref:`the user guide <reshaping.pivot>` for more examples.\n\n        Examples\n        --------\n        >>> df = pd.DataFrame({\'foo\': [\'one\', \'one\', \'one\', \'two\', \'two\',\n        ...                            \'two\'],\n        ...                    \'bar\': [\'A\', \'B\', \'C\', \'A\', \'B\', \'C\'],\n        ...                    \'baz\': [1, 2, 3, 4, 5, 6],\n        ...                    \'zoo\': [\'x\', \'y\', \'z\', \'q\', \'w\', \'t\']})\n        >>> df\n            foo   bar  baz  zoo\n        0   one   A    1    x\n        1   one   B    2    y\n        2   one   C    3    z\n        3   two   A    4    q\n        4   two   B    5    w\n        5   two   C    6    t\n\n        >>> df.pivot(index=\'foo\', columns=\'bar\', values=\'baz\')\n        bar  A   B   C\n        foo\n        one  1   2   3\n        two  4   5   6\n\n        >>> df.pivot(index=\'foo\', columns=\'bar\')[\'baz\']\n        bar  A   B   C\n        foo\n        one  1   2   3\n        two  4   5   6\n\n        >>> df.pivot(index=\'foo\', columns=\'bar\', values=[\'baz\', \'zoo\'])\n              baz       zoo\n        bar   A  B  C   A  B  C\n        foo\n        one   1  2  3   x  y  z\n        two   4  5  6   q  w  t\n\n        You could also assign a list of column names or a list of index names.\n\n        >>> df = pd.DataFrame({\n        ...                   "lev1": [1, 1, 1, 2, 2, 2],\n        ...                   "lev2": [1, 1, 2, 1, 1, 2],\n        ...                   "lev3": [1, 2, 1, 2, 1, 2],\n        ...                   "lev4": [1, 2, 3, 4, 5, 6],\n        ...                   "values": [0, 1, 2, 3, 4, 5]})\n        >>> df\n            lev1 lev2 lev3 lev4 values\n        0   1    1    1    1    0\n        1   1    1    2    2    1\n        2   1    2    1    3    2\n        3   2    1    2    4    3\n        4   2    1    1    5    4\n        5   2    2    2    6    5\n\n        >>> df.pivot(index="lev1", columns=["lev2", "lev3"], values="values")\n        lev2    1         2\n        lev3    1    2    1    2\n        lev1\n        1     0.0  1.0  2.0  NaN\n        2     4.0  3.0  NaN  5.0\n\n        >>> df.pivot(index=["lev1", "lev2"], columns=["lev3"], values="values")\n              lev3    1    2\n        lev1  lev2\n           1     1  0.0  1.0\n                 2  2.0  NaN\n           2     1  4.0  3.0\n                 2  NaN  5.0\n\n        A ValueError is raised if there are any duplicates.\n\n        >>> df = pd.DataFrame({"foo": [\'one\', \'one\', \'two\', \'two\'],\n        ...                    "bar": [\'A\', \'A\', \'B\', \'C\'],\n        ...                    "baz": [1, 2, 3, 4]})\n        >>> df\n           foo bar  baz\n        0  one   A    1\n        1  one   A    2\n        2  two   B    3\n        3  two   C    4\n\n        Notice that the first two rows are the same for our `index`\n        and `columns` arguments.\n\n        >>> df.pivot(index=\'foo\', columns=\'bar\', values=\'baz\')\n        Traceback (most recent call last):\n           ...\n        ValueError: Index contains duplicate entries, cannot reshape\n        '
+
+    @Substitution('')
+    @Appender(_shared_docs['pivot'])
+    def pivot(self, *, columns, index=lib.no_default, values=lib.no_default) -> DataFrame:
+        from pandas.core.reshape.pivot import pivot
+        return pivot(self, index=index, columns=columns, values=values)
+    _shared_docs['pivot_table'] = '\n        Create a spreadsheet-style pivot table as a DataFrame.\n\n        The levels in the pivot table will be stored in MultiIndex objects\n        (hierarchical indexes) on the index and columns of the result DataFrame.\n\n        Parameters\n        ----------%s\n        values : list-like or scalar, optional\n            Column or columns to aggregate.\n        index : column, Grouper, array, or list of the previous\n            Keys to group by on the pivot table index. If a list is passed,\n            it can contain any of the other types (except list). If an array is\n            passed, it must be the same length as the data and will be used in\n            the same manner as column values.\n        columns : column, Grouper, array, or list of the previous\n            Keys to group by on the pivot table column. If a list is passed,\n            it can contain any of the other types (except list). If an array is\n            passed, it must be the same length as the data and will be used in\n            the same manner as column values.\n        aggfunc : function, list of functions, dict, default "mean"\n            If a list of functions is passed, the resulting pivot table will have\n            hierarchical columns whose top level are the function names\n            (inferred from the function objects themselves).\n            If a dict is passed, the key is column to aggregate and the value is\n            function or list of functions. If ``margin=True``, aggfunc will be\n            used to calculate the partial aggregates.\n        fill_value : scalar, default None\n            Value to replace missing values with (in the resulting pivot table,\n            after aggregation).\n        margins : bool, default False\n            If ``margins=True``, special ``All`` columns and rows\n            will be added with partial group aggregates across the categories\n            on the rows and columns.\n        dropna : bool, default True\n            Do not include columns whose entries are all NaN. If True,\n            rows with a NaN value in any column will be omitted before\n            computing margins.\n        margins_name : str, default \'All\'\n            Name of the row / column that will contain the totals\n            when margins is True.\n        observed : bool, default False\n            This only applies if any of the groupers are Categoricals.\n            If True: only show observed values for categorical groupers.\n            If False: show all values for categorical groupers.\n\n            .. versionchanged:: 3.0.0\n\n                The default value is now ``True``.\n\n        sort : bool, default True\n            Specifies if the result should be sorted.\n\n            .. versionadded:: 1.3.0\n\n        **kwargs : dict\n            Optional keyword arguments to pass to ``aggfunc``.\n\n            .. versionadded:: 3.0.0\n\n        Returns\n        -------\n        DataFrame\n            An Excel style pivot table.\n\n        See Also\n        --------\n        DataFrame.pivot : Pivot without aggregation that can handle\n            non-numeric data.\n        DataFrame.melt: Unpivot a DataFrame from wide to long format,\n            optionally leaving identifiers set.\n        wide_to_long : Wide panel to long format. Less flexible but more\n            user-friendly than melt.\n\n        Notes\n        -----\n        Reference :ref:`the user guide <reshaping.pivot>` for more examples.\n\n        Examples\n        --------\n        >>> df = pd.DataFrame({"A": ["foo", "foo", "foo", "foo", "foo",\n        ...                          "bar", "bar", "bar", "bar"],\n        ...                    "B": ["one", "one", "one", "two", "two",\n        ...                          "one", "one", "two", "two"],\n        ...                    "C": ["small", "large", "large", "small",\n        ...                          "small", "large", "small", "small",\n        ...                          "large"],\n        ...                    "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],\n        ...                    "E": [2, 4, 5, 5, 6, 6, 8, 9, 9]})\n        >>> df\n             A    B      C  D  E\n        0  foo  one  small  1  2\n        1  foo  one  large  2  4\n        2  foo  one  large  2  5\n        3  foo  two  small  3  5\n        4  foo  two  small  3  6\n        5  bar  one  large  4  6\n        6  bar  one  small  5  8\n        7  bar  two  small  6  9\n        8  bar  two  large  7  9\n\n        This first example aggregates values by taking the sum.\n\n        >>> table = pd.pivot_table(df, values=\'D\', index=[\'A\', \'B\'],\n        ...                        columns=[\'C\'], aggfunc="sum")\n        >>> table\n        C        large  small\n        A   B\n        bar one    4.0    5.0\n            two    7.0    6.0\n        foo one    4.0    1.0\n            two    NaN    6.0\n\n        We can also fill missing values using the `fill_value` parameter.\n\n        >>> table = pd.pivot_table(df, values=\'D\', index=[\'A\', \'B\'],\n        ...                        columns=[\'C\'], aggfunc="sum", fill_value=0)\n        >>> table\n        C        large  small\n        A   B\n        bar one      4      5\n            two      7      6\n        foo one      4      1\n            two      0      6\n\n        The next example aggregates by taking the mean across multiple columns.\n\n        >>> table = pd.pivot_table(df, values=[\'D\', \'E\'], index=[\'A\', \'C\'],\n        ...                        aggfunc={\'D\': "mean", \'E\': "mean"})\n        >>> table\n                        D         E\n        A   C\n        bar large  5.500000  7.500000\n            small  5.500000  8.500000\n        foo large  2.000000  4.500000\n            small  2.333333  4.333333\n\n        We can also calculate multiple types of aggregations for any given\n        value column.\n\n        >>> table = pd.pivot_table(df, values=[\'D\', \'E\'], index=[\'A\', \'C\'],\n        ...                        aggfunc={\'D\': "mean",\n        ...                                 \'E\': ["min", "max", "mean"]})\n        >>> table\n                          D   E\n                       mean max      mean  min\n        A   C\n        bar large  5.500000   9  7.500000    6\n            small  5.500000   9  8.500000    8\n        foo large  2.000000   5  4.500000    4\n            small  2.333333   6  4.333333    2\n        '
+
+    @Substitution('')
+    @Appender(_shared_docs['pivot_table'])
+    def pivot_table(self, values=None, index=None, columns=None, aggfunc: AggFuncType='mean', fill_value=None, margins: bool=False, dropna: bool=True, margins_name: Level='All', observed: bool=True, sort: bool=True, **kwargs) -> DataFrame:
+        from pandas.core.reshape.pivot import pivot_table
+        return pivot_table(self, values=values, index=index, columns=columns, aggfunc=aggfunc, fill_value=fill_value, margins=margins, dropna=dropna, margins_name=margins_name, observed=observed, sort=sort, **kwargs)
+
+    def stack(self, level: IndexLabel=-1, dropna: bool | lib.NoDefault=lib.no_default, sort: bool | lib.NoDefault=lib.no_default, future_stack: bool=True):
+        if not future_stack:
+            from pandas.core.reshape.reshape import stack, stack_multiple
+            warnings.warn("The previous implementation of stack is deprecated and will be removed in a future version of pandas. See the What's New notes for pandas 2.1.0 for details. Do not specify the future_stack argument to adopt the new implementation and silence this warning.", FutureWarning, stacklevel=find_stack_level())
+            if dropna is lib.no_default:
+                dropna = True
+            if sort is lib.no_default:
+                sort = True
+            if isinstance(level, (tuple, list)):
+                result = stack_multiple(self, level, dropna=dropna, sort=sort)
+            else:
+                result = stack(self, level, dropna=dropna, sort=sort)
+        else:
+            from pandas.core.reshape.reshape import stack_v3
+            if dropna is not lib.no_default:
+                raise ValueError('dropna must be unspecified as the new implementation does not introduce rows of NA values. This argument will be removed in a future version of pandas.')
+            if sort is not lib.no_default:
+                raise ValueError('Cannot specify sort, this argument will be removed in a future version of pandas. Sort the result using .sort_index instead.')
+            if isinstance(level, (tuple, list)) and (not all((lev in self.columns.names for lev in level))) and (not all((isinstance(lev, int) for lev in level))):
+                raise ValueError('level should contain all level names or all level numbers, not a mixture of the two.')
+            if not isinstance(level, (tuple, list)):
+                level = [level]
+            level = [self.columns._get_level_number(lev) for lev in level]
+            result = stack_v3(self, level)
+        return result.__finalize__(self, method='stack')
+
+    def explode(self, column: IndexLabel, ignore_index: bool=False) -> DataFrame:
+        if not self.columns.is_unique:
+            duplicate_cols = self.columns[self.columns.duplicated()].tolist()
+            raise ValueError(f'DataFrame columns must be unique. Duplicate columns: {duplicate_cols}')
+        columns: list[Hashable]
+        if is_scalar(column) or isinstance(column, tuple):
+            columns = [column]
+        elif isinstance(column, list) and all((is_scalar(c) or isinstance(c, tuple) for c in column)):
+            if not column:
+                raise ValueError('column must be nonempty')
+            if len(column) > len(set(column)):
+                raise ValueError('column must be unique')
+            columns = column
+        else:
+            raise ValueError('column must be a scalar, tuple, or list thereof')
+        df = self.reset_index(drop=True)
+        if len(columns) == 1:
+            result = df[columns[0]].explode()
+        else:
+            mylen = lambda x: len(x) if is_list_like(x) and len(x) > 0 else 1
+            counts0 = self[columns[0]].apply(mylen)
+            for c in columns[1:]:
+                if not all(counts0 == self[c].apply(mylen)):
+                    raise ValueError('columns must have matching element counts')
+            result = DataFrame({c: df[c].explode() for c in columns})
+        result = df.drop(columns, axis=1).join(result)
+        if ignore_index:
+            result.index = default_index(len(result))
+        else:
+            result.index = self.index.take(result.index)
+        result = result.reindex(columns=self.columns)
+        return result.__finalize__(self, method='explode')
+
+    def unstack(self, level: IndexLabel=-1, fill_value=None, sort: bool=True) -> DataFrame | Series:
+        from pandas.core.reshape.reshape import unstack
+        result = unstack(self, level, fill_value, sort)
+        return result.__finalize__(self, method='unstack')
+
+    def melt(self, id_vars=None, value_vars=None, var_name=None, value_name: Hashable='value', col_level: Level | None=None, ignore_index: bool=True) -> DataFrame:
+        return melt(self, id_vars=id_vars, value_vars=value_vars, var_name=var_name, value_name=value_name, col_level=col_level, ignore_index=ignore_index).__finalize__(self, method='melt')
+
+    @doc(Series.diff, klass='DataFrame', extra_params="axis : {0 or 'index', 1 or 'columns'}, default 0\n    Take difference over rows (0) or columns (1).\n", other_klass='Series', examples=dedent("\n        Difference with previous row\n\n        >>> df = pd.DataFrame({'a': [1, 2, 3, 4, 5, 6],\n        ...                    'b': [1, 1, 2, 3, 5, 8],\n        ...                    'c': [1, 4, 9, 16, 25, 36]})\n        >>> df\n           a  b   c\n        0  1  1   1\n        1  2  1   4\n        2  3  2   9\n        3  4  3  16\n        4  5  5  25\n        5  6  8  36\n\n        >>> df.diff()\n             a    b     c\n        0  NaN  NaN   NaN\n        1  1.0  0.0   3.0\n        2  1.0  1.0   5.0\n        3  1.0  1.0   7.0\n        4  1.0  2.0   9.0\n        5  1.0  3.0  11.0\n\n        Difference with previous column\n\n        >>> df.diff(axis=1)\n            a  b   c\n        0 NaN  0   0\n        1 NaN -1   3\n        2 NaN -1   7\n        3 NaN -1  13\n        4 NaN  0  20\n        5 NaN  2  28\n\n        Difference with 3rd previous row\n\n        >>> df.diff(periods=3)\n             a    b     c\n        0  NaN  NaN   NaN\n        1  NaN  NaN   NaN\n        2  NaN  NaN   NaN\n        3  3.0  2.0  15.0\n        4  3.0  4.0  21.0\n        5  3.0  6.0  27.0\n\n        Difference with following row\n\n        >>> df.diff(periods=-1)\n             a    b     c\n        0 -1.0  0.0  -3.0\n        1 -1.0 -1.0  -5.0\n        2 -1.0 -1.0  -7.0\n        3 -1.0 -2.0  -9.0\n        4 -1.0 -3.0 -11.0\n        5  NaN  NaN   NaN\n\n        Overflow in input dtype\n\n        >>> df = pd.DataFrame({'a': [1, 0]}, dtype=np.uint8)\n        >>> df.diff()\n               a\n        0    NaN\n        1  255.0"))
+    def diff(self, periods: int=1, axis: Axis=0) -> DataFrame:
+        if not lib.is_integer(periods):
+            if not (is_float(periods) and periods.is_integer()):
+                raise ValueError('periods must be an integer')
+            periods = int(periods)
+        axis = self._get_axis_number(axis)
+        if axis == 1:
+            if periods != 0:
+                return self - self.shift(periods, axis=axis)
+            axis = 0
+        new_data = self._mgr.diff(n=periods)
+        res_df = self._constructor_from_mgr(new_data, axes=new_data.axes)
+        return res_df.__finalize__(self, 'diff')
+
+    def _gotitem(self, key: IndexLabel, ndim: int, subset: DataFrame | Series | None=None) -> DataFrame | Series:
+        if subset is None:
+            subset = self
+        elif subset.ndim == 1:
+            return subset
+        return subset[key]
+    _agg_see_also_doc = dedent('\n    See Also\n    --------\n    DataFrame.apply : Perform any type of operations.\n    DataFrame.transform : Perform transformation type operations.\n    DataFrame.groupby : Perform operations over groups.\n    DataFrame.resample : Perform operations over resampled bins.\n    DataFrame.rolling : Perform operations over rolling window.\n    DataFrame.expanding : Perform operations over expanding window.\n    core.window.ewm.ExponentialMovingWindow : Perform operation over exponential\n        weighted window.\n    ')
+    _agg_examples_doc = dedent('\n    Examples\n    --------\n    >>> df = pd.DataFrame([[1, 2, 3],\n    ...                    [4, 5, 6],\n    ...                    [7, 8, 9],\n    ...                    [np.nan, np.nan, np.nan]],\n    ...                   columns=[\'A\', \'B\', \'C\'])\n\n    Aggregate these functions over the rows.\n\n    >>> df.agg([\'sum\', \'min\'])\n            A     B     C\n    sum  12.0  15.0  18.0\n    min   1.0   2.0   3.0\n\n    Different aggregations per column.\n\n    >>> df.agg({\'A\' : [\'sum\', \'min\'], \'B\' : [\'min\', \'max\']})\n            A    B\n    sum  12.0  NaN\n    min   1.0  2.0\n    max   NaN  8.0\n\n    Aggregate different functions over the columns and rename the index of the resulting\n    DataFrame.\n\n    >>> df.agg(x=(\'A\', \'max\'), y=(\'B\', \'min\'), z=(\'C\', \'mean\'))\n         A    B    C\n    x  7.0  NaN  NaN\n    y  NaN  2.0  NaN\n    z  NaN  NaN  6.0\n\n    Aggregate over the columns.\n\n    >>> df.agg("mean", axis="columns")\n    0    2.0\n    1    5.0\n    2    8.0\n    3    NaN\n    dtype: float64\n    ')
+
+    @doc(_shared_docs['aggregate'], klass=_shared_doc_kwargs['klass'], axis=_shared_doc_kwargs['axis'], see_also=_agg_see_also_doc, examples=_agg_examples_doc)
+    def aggregate(self, func=None, axis: Axis=0, *args, **kwargs):
+        from pandas.core.apply import frame_apply
+        axis = self._get_axis_number(axis)
+        op = frame_apply(self, func=func, axis=axis, args=args, kwargs=kwargs)
+        result = op.agg()
+        result = reconstruct_and_relabel_result(result, func, **kwargs)
+        return result
+    agg = aggregate
+
+    @doc(_shared_docs['transform'], klass=_shared_doc_kwargs['klass'], axis=_shared_doc_kwargs['axis'])
+    def transform(self, func: AggFuncType, axis: Axis=0, *args, **kwargs) -> DataFrame:
+        from pandas.core.apply import frame_apply
+        op = frame_apply(self, func=func, axis=axis, args=args, kwargs=kwargs)
+        result = op.transform()
+        assert isinstance(result, DataFrame)
+        return result
+
+    def apply(self, func: AggFuncType, axis: Axis=0, raw: bool=False, result_type: Literal['expand', 'reduce', 'broadcast'] | None=None, args=(), by_row: Literal[False, 'compat']='compat', engine: Literal['python', 'numba']='python', engine_kwargs: dict[str, bool] | None=None, **kwargs):
+        from pandas.core.apply import frame_apply
+        op = frame_apply(self, func=func, axis=axis, raw=raw, result_type=result_type, by_row=by_row, engine=engine, engine_kwargs=engine_kwargs, args=args, kwargs=kwargs)
+        return op.apply().__finalize__(self, method='apply')
+
+    def map(self, func: PythonFuncType, na_action: Literal['ignore'] | None=None, **kwargs) -> DataFrame:
+        if na_action not in {'ignore', None}:
+            raise ValueError(f"na_action must be 'ignore' or None. Got {na_action!r}")
+        if self.empty:
+            return self.copy()
+        func = functools.partial(func, **kwargs)
+
+        def infer(x):
+            return x._map_values(func, na_action=na_action)
+        return self.apply(infer).__finalize__(self, 'map')
+
+    def _append(self, other, ignore_index: bool=False, verify_integrity: bool=False, sort: bool=False) -> DataFrame:
+        if isinstance(other, (Series, dict)):
+            if isinstance(other, dict):
+                if not ignore_index:
+                    raise TypeError('Can only append a dict if ignore_index=True')
+                other = Series(other)
+            if other.name is None and (not ignore_index):
+                raise TypeError('Can only append a Series if ignore_index=True or if the Series has a name')
+            index = Index([other.name], name=self.index.names if isinstance(self.index, MultiIndex) else self.index.name)
+            row_df = other.to_frame().T
+            other = row_df.infer_objects().rename_axis(index.names)
+        elif isinstance(other, list):
+            if not other:
+                pass
+            elif not isinstance(other[0], DataFrame):
+                other = DataFrame(other)
+                if self.index.name is not None and (not ignore_index):
+                    other.index.name = self.index.name
+        from pandas.core.reshape.concat import concat
+        if isinstance(other, (list, tuple)):
+            to_concat = [self, *other]
+        else:
+            to_concat = [self, other]
+        result = concat(to_concat, ignore_index=ignore_index, verify_integrity=verify_integrity, sort=sort)
+        return result.__finalize__(self, method='append')
+
+    def join(self, other: DataFrame | Series | Iterable[DataFrame | Series], on: IndexLabel | None=None, how: MergeHow='left', lsuffix: str='', rsuffix: str='', sort: bool=False, validate: JoinValidate | None=None) -> DataFrame:
+        from pandas.core.reshape.concat import concat
+        from pandas.core.reshape.merge import merge
+        if isinstance(other, Series):
+            if other.name is None:
+                raise ValueError('Other Series must have a name')
+            other = DataFrame({other.name: other})
+        if isinstance(other, DataFrame):
+            if how == 'cross':
+                return merge(self, other, how=how, on=on, suffixes=(lsuffix, rsuffix), sort=sort, validate=validate)
+            return merge(self, other, left_on=on, how=how, left_index=on is None, right_index=True, suffixes=(lsuffix, rsuffix), sort=sort, validate=validate)
+        else:
+            if on is not None:
+                raise ValueError('Joining multiple DataFrames only supported for joining on index')
+            if rsuffix or lsuffix:
+                raise ValueError('Suffixes not supported when joining multiple DataFrames')
+            frames = [cast('DataFrame | Series', self)] + list(other)
+            can_concat = all((df.index.is_unique for df in frames))
+            if can_concat:
+                if how == 'left':
+                    res = concat(frames, axis=1, join='outer', verify_integrity=True, sort=sort)
+                    return res.reindex(self.index)
+                else:
+                    return concat(frames, axis=1, join=how, verify_integrity=True, sort=sort)
+            joined = frames[0]
+            for frame in frames[1:]:
+                joined = merge(joined, frame, how=how, left_index=True, right_index=True, validate=validate)
+            return joined
+
+    @Substitution('')
+    @Appender(_merge_doc, indents=2)
+    def merge(self, right: DataFrame | Series, how: MergeHow='inner', on: IndexLabel | AnyArrayLike | None=None, left_on: IndexLabel | AnyArrayLike | None=None, right_on: IndexLabel | AnyArrayLike | None=None, left_index: bool=False, right_index: bool=False, sort: bool=False, suffixes: Suffixes=('_x', '_y'), copy: bool | lib.NoDefault=lib.no_default, indicator: str | bool=False, validate: MergeValidate | None=None) -> DataFrame:
+        self._check_copy_deprecation(copy)
+        from pandas.core.reshape.merge import merge
+        return merge(self, right, how=how, on=on, left_on=left_on, right_on=right_on, left_index=left_index, right_index=right_index, sort=sort, suffixes=suffixes, indicator=indicator, validate=validate)
+
+    def round(self, decimals: int | dict[IndexLabel, int] | Series=0, *args, **kwargs) -> DataFrame:
+        from pandas.core.reshape.concat import concat
+
+        def _dict_round(df: DataFrame, decimals) -> Iterator[Series]:
+            for (col, vals) in df.items():
+                try:
+                    yield _series_round(vals, decimals[col])
+                except KeyError:
+                    yield vals
+
+        def _series_round(ser: Series, decimals: int) -> Series:
+            if is_integer_dtype(ser.dtype) or is_float_dtype(ser.dtype):
+                return ser.round(decimals)
+            return ser
+        nv.validate_round(args, kwargs)
+        if isinstance(decimals, (dict, Series)):
+            if isinstance(decimals, Series) and (not decimals.index.is_unique):
+                raise ValueError('Index of decimals must be unique')
+            if is_dict_like(decimals) and (not all((is_integer(value) for (_, value) in decimals.items()))):
+                raise TypeError('Values in decimals must be integers')
+            new_cols = list(_dict_round(self, decimals))
+        elif is_integer(decimals):
+            new_mgr = self._mgr.round(decimals=decimals)
+            return self._constructor_from_mgr(new_mgr, axes=new_mgr.axes).__finalize__(self, method='round')
+        else:
+            raise TypeError('decimals must be an integer, a dict-like or a Series')
+        if new_cols is not None and len(new_cols) > 0:
+            return self._constructor(concat(new_cols, axis=1), index=self.index, columns=self.columns).__finalize__(self, method='round')
+        else:
+            return self.copy(deep=False)
+
+    def corr(self, method: CorrelationMethod='pearson', min_periods: int=1, numeric_only: bool=False) -> DataFrame:
+        data = self._get_numeric_data() if numeric_only else self
+        cols = data.columns
+        idx = cols.copy()
+        mat = data.to_numpy(dtype=float, na_value=np.nan, copy=False)
+        if method == 'pearson':
+            correl = libalgos.nancorr(mat, minp=min_periods)
+        elif method == 'spearman':
+            correl = libalgos.nancorr_spearman(mat, minp=min_periods)
+        elif method == 'kendall' or callable(method):
+            if min_periods is None:
+                min_periods = 1
+            mat = mat.T
+            corrf = nanops.get_corr_func(method)
+            K = len(cols)
+            correl = np.empty((K, K), dtype=float)
+            mask = np.isfinite(mat)
+            for (i, ac) in enumerate(mat):
+                for (j, bc) in enumerate(mat):
+                    if i > j:
+                        continue
+                    valid = mask[i] & mask[j]
+                    if valid.sum() < min_periods:
+                        c = np.nan
+                    elif i == j:
+                        c = 1.0
+                    elif not valid.all():
+                        c = corrf(ac[valid], bc[valid])
+                    else:
+                        c = corrf(ac, bc)
+                    correl[i, j] = c
+                    correl[j, i] = c
+        else:
+            raise ValueError(f"method must be either 'pearson', 'spearman', 'kendall', or a callable, '{method}' was supplied")
+        result = self._constructor(correl, index=idx, columns=cols, copy=False)
+        return result.__finalize__(self, method='corr')
+
+    def cov(self, min_periods: int | None=None, ddof: int | None=1, numeric_only: bool=False) -> DataFrame:
+        data = self._get_numeric_data() if numeric_only else self
+        cols = data.columns
+        idx = cols.copy()
+        mat = data.to_numpy(dtype=float, na_value=np.nan, copy=False)
+        if notna(mat).all():
+            if min_periods is not None and min_periods > len(mat):
+                base_cov = np.empty((mat.shape[1], mat.shape[1]))
+                base_cov.fill(np.nan)
+            else:
+                base_cov = np.cov(mat.T, ddof=ddof)
+            base_cov = base_cov.reshape((len(cols), len(cols)))
+        else:
+            base_cov = libalgos.nancorr(mat, cov=True, minp=min_periods)
+        result = self._constructor(base_cov, index=idx, columns=cols, copy=False)
+        return result.__finalize__(self, method='cov')
+
+    def corrwith(self, other: DataFrame | Series, axis: Axis=0, drop: bool=False, method: CorrelationMethod='pearson', numeric_only: bool=False, min_periods: int | None=None) -> Series:
+        axis = self._get_axis_number(axis)
+        this = self._get_numeric_data() if numeric_only else self
+        if isinstance(other, Series):
+            return this.apply(lambda x: other.corr(x, method=method, min_periods=min_periods), axis=axis)
+        if numeric_only:
+            other = other._get_numeric_data()
+        (left, right) = this.align(other, join='inner')
+        if axis == 1:
+            left = left.T
+            right = right.T
+        if method == 'pearson':
+            left = left + right * 0
+            right = right + left * 0
+            ldem = left - left.mean(numeric_only=numeric_only)
+            rdem = right - right.mean(numeric_only=numeric_only)
+            num = (ldem * rdem).sum()
+            dom = (left.count() - 1) * left.std(numeric_only=numeric_only) * right.std(numeric_only=numeric_only)
+            correl = num / dom
+        elif method in ['kendall', 'spearman'] or callable(method):
+
+            def c(x):
+                return nanops.nancorr(x[0], x[1], method=method)
+            correl = self._constructor_sliced(map(c, zip(left.values.T, right.values.T)), index=left.columns, copy=False)
+        else:
+            raise ValueError(f"Invalid method {method} was passed, valid methods are: 'pearson', 'kendall', 'spearman', or callable")
+        if not drop:
+            raxis: AxisInt = 1 if axis == 0 else 0
+            result_index = this._get_axis(raxis).union(other._get_axis(raxis))
+            idx_diff = result_index.difference(correl.index)
+            if len(idx_diff) > 0:
+                correl = correl._append(Series([np.nan] * len(idx_diff), index=idx_diff))
+        return correl
+
+    def count(self, axis: Axis=0, numeric_only: bool=False) -> Series:
+        axis = self._get_axis_number(axis)
+        if numeric_only:
+            frame = self._get_numeric_data()
+        else:
+            frame = self
+        if len(frame._get_axis(axis)) == 0:
+            result = self._constructor_sliced(0, index=frame._get_agg_axis(axis))
+        else:
+            result = notna(frame).sum(axis=axis)
+        return result.astype('int64').__finalize__(self, method='count')
+
+    def _reduce(self, op, name: str, *, axis: Axis=0, skipna: bool=True, numeric_only: bool=False, filter_type=None, **kwds):
+        assert filter_type is None or filter_type == 'bool', filter_type
+        out_dtype = 'bool' if filter_type == 'bool' else None
+        if axis is not None:
+            axis = self._get_axis_number(axis)
+
+        def func(values: np.ndarray):
+            return op(values, axis=axis, skipna=skipna, **kwds)
+
+        def blk_func(values, axis: Axis=1):
+            if isinstance(values, ExtensionArray):
+                if not is_1d_only_ea_dtype(values.dtype):
+                    return values._reduce(name, axis=1, skipna=skipna, **kwds)
+                return values._reduce(name, skipna=skipna, keepdims=True, **kwds)
+            else:
+                return op(values, axis=axis, skipna=skipna, **kwds)
+
+        def _get_data() -> DataFrame:
+            if filter_type is None:
+                data = self._get_numeric_data()
+            else:
+                assert filter_type == 'bool'
+                data = self._get_bool_data()
+            return data
+        df = self
+        if numeric_only:
+            df = _get_data()
+        if axis is None:
+            dtype = find_common_type([block.values.dtype for block in df._mgr.blocks])
+            if isinstance(dtype, ExtensionDtype):
+                df = df.astype(dtype)
+                arr = concat_compat(list(df._iter_column_arrays()))
+                return arr._reduce(name, skipna=skipna, keepdims=False, **kwds)
+            return func(df.values)
+        elif axis == 1:
+            if len(df.index) == 0:
+                result = df._reduce(op, name, axis=0, skipna=skipna, numeric_only=False, filter_type=filter_type, **kwds).iloc[:0]
+                result.index = df.index
+                return result
+            if df.shape[1] and name != 'kurt':
+                dtype = find_common_type([block.values.dtype for block in df._mgr.blocks])
+                if isinstance(dtype, ExtensionDtype):
+                    name = {'argmax': 'idxmax', 'argmin': 'idxmin'}.get(name, name)
+                    df = df.astype(dtype)
+                    arr = concat_compat(list(df._iter_column_arrays()))
+                    (nrows, ncols) = df.shape
+                    row_index = np.tile(np.arange(nrows), ncols)
+                    col_index = np.repeat(np.arange(ncols), nrows)
+                    ser = Series(arr, index=col_index, copy=False)
+                    with rewrite_warning(target_message=f'The behavior of SeriesGroupBy.{name} with all-NA values', target_category=FutureWarning, new_message=f'The behavior of {type(self).__name__}.{name} with all-NA values, or any-NA and skipna=False, is deprecated. In a future version this will raise ValueError'):
+                        result = ser.groupby(row_index).agg(name, **kwds)
+                    result.index = df.index
+                    if not skipna and name not in ('any', 'all'):
+                        mask = df.isna().to_numpy(dtype=np.bool_).any(axis=1)
+                        other = -1 if name in ('idxmax', 'idxmin') else lib.no_default
+                        result = result.mask(mask, other)
+                    return result
+            df = df.T
+        res = df._mgr.reduce(blk_func)
+        out = df._constructor_from_mgr(res, axes=res.axes).iloc[0]
+        if out_dtype is not None and out.dtype != 'boolean':
+            out = out.astype(out_dtype)
+        elif (df._mgr.get_dtypes() == object).any() and name not in ['any', 'all']:
+            out = out.astype(object)
+        elif len(self) == 0 and out.dtype == object and (name in ('sum', 'prod')):
+            out = out.astype(np.float64)
+        return out
+
+    def _reduce_axis1(self, name: str, func, skipna: bool) -> Series:
+        if name == 'all':
+            result = np.ones(len(self), dtype=bool)
+            ufunc = np.logical_and
+        elif name == 'any':
+            result = np.zeros(len(self), dtype=bool)
+            ufunc = np.logical_or
+        else:
+            raise NotImplementedError(name)
+        for blocks in self._mgr.blocks:
+            middle = func(blocks.values, axis=0, skipna=skipna)
+            result = ufunc(result, middle)
+        res_ser = self._constructor_sliced(result, index=self.index, copy=False)
+        return res_ser
+
+    @overload
+    def any(self, *, axis: Axis=..., bool_only: bool=..., skipna: bool=..., **kwargs) -> Series:
+        ...
+
+    @overload
+    def any(self, *, axis: None, bool_only: bool=..., skipna: bool=..., **kwargs) -> bool:
+        ...
+
+    @overload
+    def any(self, *, axis: Axis | None, bool_only: bool=..., skipna: bool=..., **kwargs) -> Series | bool:
+        ...
+
+    @doc(make_doc('any', ndim=1))
+    def any(self, *, axis: Axis | None=0, bool_only: bool=False, skipna: bool=True, **kwargs) -> Series | bool:
+        result = self._logical_func('any', nanops.nanany, axis, bool_only, skipna, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='any')
+        return result
+
+    @overload
+    def all(self, *, axis: Axis=..., bool_only: bool=..., skipna: bool=..., **kwargs) -> Series:
+        ...
+
+    @overload
+    def all(self, *, axis: None, bool_only: bool=..., skipna: bool=..., **kwargs) -> bool:
+        ...
+
+    @overload
+    def all(self, *, axis: Axis | None, bool_only: bool=..., skipna: bool=..., **kwargs) -> Series | bool:
+        ...
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='all')
+    @doc(make_doc('all', ndim=1))
+    def all(self, axis: Axis | None=0, bool_only: bool=False, skipna: bool=True, **kwargs) -> Series | bool:
+        result = self._logical_func('all', nanops.nanall, axis, bool_only, skipna, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='all')
+        return result
+
+    @overload
+    def min(self, *, axis: Axis=..., skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series:
+        ...
+
+    @overload
+    def min(self, *, axis: None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Any:
+        ...
+
+    @overload
+    def min(self, *, axis: Axis | None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series | Any:
+        ...
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='min')
+    @doc(make_doc('min', ndim=2))
+    def min(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Series | Any:
+        result = super().min(axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='min')
+        return result
+
+    @overload
+    def max(self, *, axis: Axis=..., skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series:
+        ...
+
+    @overload
+    def max(self, *, axis: None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Any:
+        ...
+
+    @overload
+    def max(self, *, axis: Axis | None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series | Any:
+        ...
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='max')
+    @doc(make_doc('max', ndim=2))
+    def max(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Series | Any:
+        result = super().max(axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='max')
+        return result
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='sum')
+    def sum(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, min_count: int=0, **kwargs) -> Series:
+        result = super().sum(axis=axis, skipna=skipna, numeric_only=numeric_only, min_count=min_count, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='sum')
+        return result
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='prod')
+    def prod(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, min_count: int=0, **kwargs) -> Series:
+        result = super().prod(axis=axis, skipna=skipna, numeric_only=numeric_only, min_count=min_count, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='prod')
+        return result
+
+    @overload
+    def mean(self, *, axis: Axis=..., skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series:
+        ...
+
+    @overload
+    def mean(self, *, axis: None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Any:
+        ...
+
+    @overload
+    def mean(self, *, axis: Axis | None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series | Any:
+        ...
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='mean')
+    @doc(make_doc('mean', ndim=2))
+    def mean(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Series | Any:
+        result = super().mean(axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='mean')
+        return result
+
+    @overload
+    def median(self, *, axis: Axis=..., skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series:
+        ...
+
+    @overload
+    def median(self, *, axis: None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Any:
+        ...
+
+    @overload
+    def median(self, *, axis: Axis | None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series | Any:
+        ...
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='median')
+    @doc(make_doc('median', ndim=2))
+    def median(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Series | Any:
+        result = super().median(axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='median')
+        return result
+
+    @overload
+    def sem(self, *, axis: Axis=..., skipna: bool=..., ddof: int=..., numeric_only: bool=..., **kwargs) -> Series:
+        ...
+
+    @overload
+    def sem(self, *, axis: None, skipna: bool=..., ddof: int=..., numeric_only: bool=..., **kwargs) -> Any:
+        ...
+
+    @overload
+    def sem(self, *, axis: Axis | None, skipna: bool=..., ddof: int=..., numeric_only: bool=..., **kwargs) -> Series | Any:
+        ...
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='sem')
+    def sem(self, axis: Axis | None=0, skipna: bool=True, ddof: int=1, numeric_only: bool=False, **kwargs) -> Series | Any:
+        result = super().sem(axis=axis, skipna=skipna, ddof=ddof, numeric_only=numeric_only, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='sem')
+        return result
+
+    @overload
+    def var(self, *, axis: Axis=..., skipna: bool=..., ddof: int=..., numeric_only: bool=..., **kwargs) -> Series:
+        ...
+
+    @overload
+    def var(self, *, axis: None, skipna: bool=..., ddof: int=..., numeric_only: bool=..., **kwargs) -> Any:
+        ...
+
+    @overload
+    def var(self, *, axis: Axis | None, skipna: bool=..., ddof: int=..., numeric_only: bool=..., **kwargs) -> Series | Any:
+        ...
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='var')
+    def var(self, axis: Axis | None=0, skipna: bool=True, ddof: int=1, numeric_only: bool=False, **kwargs) -> Series | Any:
+        result = super().var(axis=axis, skipna=skipna, ddof=ddof, numeric_only=numeric_only, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='var')
+        return result
+
+    @overload
+    def std(self, *, axis: Axis=..., skipna: bool=..., ddof: int=..., numeric_only: bool=..., **kwargs) -> Series:
+        ...
+
+    @overload
+    def std(self, *, axis: None, skipna: bool=..., ddof: int=..., numeric_only: bool=..., **kwargs) -> Any:
+        ...
+
+    @overload
+    def std(self, *, axis: Axis | None, skipna: bool=..., ddof: int=..., numeric_only: bool=..., **kwargs) -> Series | Any:
+        ...
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='std')
+    def std(self, axis: Axis | None=0, skipna: bool=True, ddof: int=1, numeric_only: bool=False, **kwargs) -> Series | Any:
+        result = super().std(axis=axis, skipna=skipna, ddof=ddof, numeric_only=numeric_only, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='std')
+        return result
+
+    @overload
+    def skew(self, *, axis: Axis=..., skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series:
+        ...
+
+    @overload
+    def skew(self, *, axis: None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Any:
+        ...
+
+    @overload
+    def skew(self, *, axis: Axis | None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series | Any:
+        ...
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='skew')
+    def skew(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Series | Any:
+        result = super().skew(axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='skew')
+        return result
+
+    @overload
+    def kurt(self, *, axis: Axis=..., skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series:
+        ...
+
+    @overload
+    def kurt(self, *, axis: None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Any:
+        ...
+
+    @overload
+    def kurt(self, *, axis: Axis | None, skipna: bool=..., numeric_only: bool=..., **kwargs) -> Series | Any:
+        ...
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='kurt')
+    def kurt(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Series | Any:
+        result = super().kurt(axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+        if isinstance(result, Series):
+            result = result.__finalize__(self, method='kurt')
+        return result
+    kurtosis = kurt
+    product = prod
+
+    @doc(make_doc('cummin', ndim=2))
+    def cummin(self, axis: Axis=0, skipna: bool=True, numeric_only: bool=False, *args, **kwargs) -> Self:
+        data = self._get_numeric_data() if numeric_only else self
+        return NDFrame.cummin(data, axis, skipna, *args, **kwargs)
+
+    @doc(make_doc('cummax', ndim=2))
+    def cummax(self, axis: Axis=0, skipna: bool=True, numeric_only: bool=False, *args, **kwargs) -> Self:
+        data = self._get_numeric_data() if numeric_only else self
+        return NDFrame.cummax(data, axis, skipna, *args, **kwargs)
+
+    @doc(make_doc('cumsum', ndim=2))
+    def cumsum(self, axis: Axis=0, skipna: bool=True, numeric_only: bool=False, *args, **kwargs) -> Self:
+        data = self._get_numeric_data() if numeric_only else self
+        return NDFrame.cumsum(data, axis, skipna, *args, **kwargs)
+
+    @doc(make_doc('cumprod', 2))
+    def cumprod(self, axis: Axis=0, skipna: bool=True, numeric_only: bool=False, *args, **kwargs) -> Self:
+        data = self._get_numeric_data() if numeric_only else self
+        return NDFrame.cumprod(data, axis, skipna, *args, **kwargs)
+
+    def nunique(self, axis: Axis=0, dropna: bool=True) -> Series:
+        return self.apply(Series.nunique, axis=axis, dropna=dropna)
+
+    def idxmin(self, axis: Axis=0, skipna: bool=True, numeric_only: bool=False) -> Series:
+        axis = self._get_axis_number(axis)
+        if self.empty and len(self.axes[axis]):
+            axis_dtype = self.axes[axis].dtype
+            return self._constructor_sliced(dtype=axis_dtype)
+        if numeric_only:
+            data = self._get_numeric_data()
+        else:
+            data = self
+        res = data._reduce(nanops.nanargmin, 'argmin', axis=axis, skipna=skipna, numeric_only=False)
+        indices = res._values
+        if (indices == -1).any():
+            warnings.warn(f'The behavior of {type(self).__name__}.idxmin with all-NA values, or any-NA and skipna=False, is deprecated. In a future version this will raise ValueError', FutureWarning, stacklevel=find_stack_level())
+        index = data._get_axis(axis)
+        result = algorithms.take(index._values, indices, allow_fill=True, fill_value=index._na_value)
+        final_result = data._constructor_sliced(result, index=data._get_agg_axis(axis))
+        return final_result.__finalize__(self, method='idxmin')
+
+    def idxmax(self, axis: Axis=0, skipna: bool=True, numeric_only: bool=False) -> Series:
+        axis = self._get_axis_number(axis)
+        if self.empty and len(self.axes[axis]):
+            axis_dtype = self.axes[axis].dtype
+            return self._constructor_sliced(dtype=axis_dtype)
+        if numeric_only:
+            data = self._get_numeric_data()
+        else:
+            data = self
+        res = data._reduce(nanops.nanargmax, 'argmax', axis=axis, skipna=skipna, numeric_only=False)
+        indices = res._values
+        if (indices == -1).any():
+            warnings.warn(f'The behavior of {type(self).__name__}.idxmax with all-NA values, or any-NA and skipna=False, is deprecated. In a future version this will raise ValueError', FutureWarning, stacklevel=find_stack_level())
+        index = data._get_axis(axis)
+        result = algorithms.take(index._values, indices, allow_fill=True, fill_value=index._na_value)
+        final_result = data._constructor_sliced(result, index=data._get_agg_axis(axis))
+        return final_result.__finalize__(self, method='idxmax')
+
+    def _get_agg_axis(self, axis_num: int) -> Index:
+        if axis_num == 0:
+            return self.columns
+        elif axis_num == 1:
+            return self.index
+        else:
+            raise ValueError(f'Axis must be 0 or 1 (got {axis_num!r})')
+
+    def mode(self, axis: Axis=0, numeric_only: bool=False, dropna: bool=True) -> DataFrame:
+        data = self if not numeric_only else self._get_numeric_data()
+
+        def f(s):
+            return s.mode(dropna=dropna)
+        data = data.apply(f, axis=axis)
+        if data.empty:
+            data.index = default_index(0)
+        return data
+
+    @overload
+    def quantile(self, q: float=..., axis: Axis=..., numeric_only: bool=..., interpolation: QuantileInterpolation=..., method: Literal['single', 'table']=...) -> Series:
+        ...
+
+    @overload
+    def quantile(self, q: AnyArrayLike | Sequence[float], axis: Axis=..., numeric_only: bool=..., interpolation: QuantileInterpolation=..., method: Literal['single', 'table']=...) -> Series | DataFrame:
+        ...
+
+    @overload
+    def quantile(self, q: float | AnyArrayLike | Sequence[float]=..., axis: Axis=..., numeric_only: bool=..., interpolation: QuantileInterpolation=..., method: Literal['single', 'table']=...) -> Series | DataFrame:
+        ...
+
+    def quantile(self, q: float | AnyArrayLike | Sequence[float]=0.5, axis: Axis=0, numeric_only: bool=False, interpolation: QuantileInterpolation='linear', method: Literal['single', 'table']='single') -> Series | DataFrame:
+        validate_percentile(q)
+        axis = self._get_axis_number(axis)
+        if not is_list_like(q):
+            res_df = self.quantile([q], axis=axis, numeric_only=numeric_only, interpolation=interpolation, method=method)
+            if method == 'single':
+                res = res_df.iloc[0]
+            else:
+                res = res_df.T.iloc[:, 0]
+            if axis == 1 and len(self) == 0:
+                dtype = find_common_type(list(self.dtypes))
+                if needs_i8_conversion(dtype):
+                    return res.astype(dtype)
+            return res
+        q = Index(q, dtype=np.float64)
+        data = self._get_numeric_data() if numeric_only else self
+        if axis == 1:
+            data = data.T
+        if len(data.columns) == 0:
+            cols = self.columns[:0]
+            dtype = np.float64
+            if axis == 1:
+                cdtype = find_common_type(list(self.dtypes))
+                if needs_i8_conversion(cdtype):
+                    dtype = cdtype
+            res = self._constructor([], index=q, columns=cols, dtype=dtype)
+            return res.__finalize__(self, method='quantile')
+        valid_method = {'single', 'table'}
+        if method not in valid_method:
+            raise ValueError(f'Invalid method: {method}. Method must be in {valid_method}.')
+        if method == 'single':
+            res = data._mgr.quantile(qs=q, interpolation=interpolation)
+        elif method == 'table':
+            valid_interpolation = {'nearest', 'lower', 'higher'}
+            if interpolation not in valid_interpolation:
+                raise ValueError(f'Invalid interpolation: {interpolation}. Interpolation must be in {valid_interpolation}')
+            if len(data) == 0:
+                if data.ndim == 2:
+                    dtype = find_common_type(list(self.dtypes))
+                else:
+                    dtype = self.dtype
+                return self._constructor([], index=q, columns=data.columns, dtype=dtype)
+            q_idx = np.quantile(np.arange(len(data)), q, method=interpolation)
+            by = data.columns
+            if len(by) > 1:
+                keys = [data._get_label_or_level_values(x) for x in by]
+                indexer = lexsort_indexer(keys)
+            else:
+                k = data._get_label_or_level_values(by[0])
+                indexer = nargsort(k)
+            res = data._mgr.take(indexer[q_idx], verify=False)
+            res.axes[1] = q
+        result = self._constructor_from_mgr(res, axes=res.axes)
+        return result.__finalize__(self, method='quantile')
+
+    def to_timestamp(self, freq: Frequency | None=None, how: ToTimestampHow='start', axis: Axis=0, copy: bool | lib.NoDefault=lib.no_default) -> DataFrame:
+        self._check_copy_deprecation(copy)
+        new_obj = self.copy(deep=False)
+        axis_name = self._get_axis_name(axis)
+        old_ax = getattr(self, axis_name)
+        if not isinstance(old_ax, PeriodIndex):
+            raise TypeError(f'unsupported Type {type(old_ax).__name__}')
+        new_ax = old_ax.to_timestamp(freq=freq, how=how)
+        setattr(new_obj, axis_name, new_ax)
+        return new_obj
+
+    def to_period(self, freq: Frequency | None=None, axis: Axis=0, copy: bool | lib.NoDefault=lib.no_default) -> DataFrame:
+        self._check_copy_deprecation(copy)
+        new_obj = self.copy(deep=False)
+        axis_name = self._get_axis_name(axis)
+        old_ax = getattr(self, axis_name)
+        if not isinstance(old_ax, DatetimeIndex):
+            raise TypeError(f'unsupported Type {type(old_ax).__name__}')
+        new_ax = old_ax.to_period(freq=freq)
+        setattr(new_obj, axis_name, new_ax)
+        return new_obj
+
+    def isin(self, values: Series | DataFrame | Sequence | Mapping) -> DataFrame:
+        if isinstance(values, dict):
+            from pandas.core.reshape.concat import concat
+            values = collections.defaultdict(list, values)
+            result = concat((self.iloc[:, [i]].isin(values[col]) for (i, col) in enumerate(self.columns)), axis=1)
+        elif isinstance(values, Series):
+            if not values.index.is_unique:
+                raise ValueError('cannot compute isin with a duplicate axis.')
+            result = self.eq(values.reindex_like(self), axis='index')
+        elif isinstance(values, DataFrame):
+            if not (values.columns.is_unique and values.index.is_unique):
+                raise ValueError('cannot compute isin with a duplicate axis.')
+            result = self.eq(values.reindex_like(self))
+        else:
+            if not is_list_like(values):
+                raise TypeError(f"only list-like or dict-like objects are allowed to be passed to DataFrame.isin(), you passed a '{type(values).__name__}'")
+
+            def isin_(x):
+                result = algorithms.isin(x.ravel(), values)
+                return result.reshape(x.shape)
+            res_mgr = self._mgr.apply(isin_)
+            result = self._constructor_from_mgr(res_mgr, axes=res_mgr.axes)
+        return result.__finalize__(self, method='isin')
+    _AXIS_ORDERS: list[Literal['index', 'columns']] = ['index', 'columns']
+    _AXIS_TO_AXIS_NUMBER: dict[Axis, int] = {**NDFrame._AXIS_TO_AXIS_NUMBER, 1: 1, 'columns': 1}
+    _AXIS_LEN = len(_AXIS_ORDERS)
+    _info_axis_number: Literal[1] = 1
+    _info_axis_name: Literal['columns'] = 'columns'
+    index = properties.AxisProperty(axis=1, doc="\n        The index (row labels) of the DataFrame.\n\n        The index of a DataFrame is a series of labels that identify each row.\n        The labels can be integers, strings, or any other hashable type. The index\n        is used for label-based access and alignment, and can be accessed or\n        modified using this attribute.\n\n        Returns\n        -------\n        pandas.Index\n            The index labels of the DataFrame.\n\n        See Also\n        --------\n        DataFrame.columns : The column labels of the DataFrame.\n        DataFrame.to_numpy : Convert the DataFrame to a NumPy array.\n\n        Examples\n        --------\n        >>> df = pd.DataFrame({'Name': ['Alice', 'Bob', 'Aritra'],\n        ...                    'Age': [25, 30, 35],\n        ...                    'Location': ['Seattle', 'New York', 'Kona']},\n        ...                   index=([10, 20, 30]))\n        >>> df.index\n        Index([10, 20, 30], dtype='int64')\n\n        In this example, we create a DataFrame with 3 rows and 3 columns,\n        including Name, Age, and Location information. We set the index labels to\n        be the integers 10, 20, and 30. We then access the `index` attribute of the\n        DataFrame, which returns an `Index` object containing the index labels.\n\n        >>> df.index = [100, 200, 300]\n        >>> df\n            Name  Age Location\n        100  Alice   25  Seattle\n        200    Bob   30 New York\n        300  Aritra  35    Kona\n\n        In this example, we modify the index labels of the DataFrame by assigning\n        a new list of labels to the `index` attribute. The DataFrame is then\n        updated with the new labels, and the output shows the modified DataFrame.\n        ")
+    columns = properties.AxisProperty(axis=0, doc="\n        The column labels of the DataFrame.\n\n        Returns\n        -------\n        pandas.Index\n            The column labels of the DataFrame.\n\n        See Also\n        --------\n        DataFrame.index: The index (row labels) of the DataFrame.\n        DataFrame.axes: Return a list representing the axes of the DataFrame.\n\n        Examples\n        --------\n        >>> df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})\n        >>> df\n                A  B\n        0    1  3\n        1    2  4\n        >>> df.columns\n        Index(['A', 'B'], dtype='object')\n        ")
+    plot = Accessor('plot', pandas.plotting.PlotAccessor)
+    hist = pandas.plotting.hist_frame
+    boxplot = pandas.plotting.boxplot_frame
+    sparse = Accessor('sparse', SparseFrameAccessor)
+
+    def _to_dict_of_blocks(self):
+        mgr = self._mgr
+        return {k: self._constructor_from_mgr(v, axes=v.axes).__finalize__(self) for (k, v) in mgr.to_iter_dict()}
+
+    @property
+    def values(self) -> np.ndarray:
+        return self._mgr.as_array()
+
+def _from_nested_dict(data: Mapping[HashableT, Mapping[HashableT2, T]]) -> collections.defaultdict[HashableT2, dict[HashableT, T]]:
+    new_data: collections.defaultdict[HashableT2, dict[HashableT, T]] = collections.defaultdict(dict)
+    for (index, s) in data.items():
+        for (col, v) in s.items():
+            new_data[col][index] = v
+    return new_data
+
+def _reindex_for_setitem(value: DataFrame | Series, index: Index) -> tuple[ArrayLike, BlockValuesRefs | None]:
+    if value.index.equals(index) or not len(index):
+        if isinstance(value, Series):
+            return (value._values, value._references)
+        return (value._values.copy(), None)
+    try:
+        reindexed_value = value.reindex(index)._values
+    except ValueError as err:
+        if not value.index.is_unique:
+            raise err
+        raise TypeError('incompatible index of inserted column with frame index') from err
+    return (reindexed_value, None)
+
+# File: pandas-main/pandas/core/generic.py
+from __future__ import annotations
+import collections
+from copy import deepcopy
+import datetime as dt
+from functools import partial
+from json import loads
+import operator
+import pickle
+import re
+import sys
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, NoReturn, cast, final, overload
+import warnings
+import numpy as np
+from pandas._config import config
+from pandas._libs import lib
+from pandas._libs.lib import is_range_indexer
+from pandas._libs.tslibs import Period, Timestamp, to_offset
+from pandas._typing import AlignJoin, AnyArrayLike, ArrayLike, Axes, Axis, AxisInt, CompressionOptions, Concatenate, DtypeArg, DtypeBackend, DtypeObj, FilePath, FillnaOptions, FloatFormatType, FormattersType, Frequency, IgnoreRaise, IndexKeyFunc, IndexLabel, InterpolateOptions, IntervalClosedType, JSONSerializable, Level, ListLike, Manager, NaPosition, NDFrameT, OpenFileErrors, RandomState, ReindexMethod, Renamer, Scalar, Self, SequenceNotStr, SortKind, StorageOptions, Suffixes, T, TimeAmbiguous, TimedeltaConvertibleTypes, TimeNonexistent, TimestampConvertibleTypes, TimeUnit, ValueKeyFunc, WriteBuffer, WriteExcelBuffer, npt
+from pandas.compat import PYPY
+from pandas.compat._constants import REF_COUNT
+from pandas.compat._optional import import_optional_dependency
+from pandas.compat.numpy import function as nv
+from pandas.errors import AbstractMethodError, ChainedAssignmentError, InvalidIndexError
+from pandas.errors.cow import _chained_assignment_method_msg
+from pandas.util._decorators import deprecate_kwarg, doc
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import check_dtype_backend, validate_ascending, validate_bool_kwarg, validate_inclusive
+from pandas.core.dtypes.astype import astype_is_view
+from pandas.core.dtypes.common import ensure_object, ensure_platform_int, ensure_str, is_bool, is_bool_dtype, is_dict_like, is_extension_array_dtype, is_list_like, is_number, is_numeric_dtype, is_re_compilable, is_scalar, pandas_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype, ExtensionDtype, PeriodDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.dtypes.inference import is_hashable, is_nested_list_like
+from pandas.core.dtypes.missing import isna, notna
+from pandas.core import algorithms as algos, arraylike, common, indexing, missing, nanops, sample
+from pandas.core.array_algos.replace import should_use_regex
+from pandas.core.arrays import ExtensionArray
+from pandas.core.base import PandasObject
+from pandas.core.construction import extract_array
+from pandas.core.flags import Flags
+from pandas.core.indexes.api import DatetimeIndex, Index, MultiIndex, PeriodIndex, default_index, ensure_index
+from pandas.core.internals import BlockManager
+from pandas.core.methods.describe import describe_ndframe
+from pandas.core.missing import clean_fill_method, clean_reindex_fill_method, find_valid_index
+from pandas.core.reshape.concat import concat
+from pandas.core.shared_docs import _shared_docs
+from pandas.core.sorting import get_indexer_indexer
+from pandas.core.window import Expanding, ExponentialMovingWindow, Rolling, Window
+from pandas.io.formats.format import DataFrameFormatter, DataFrameRenderer
+from pandas.io.formats.printing import pprint_thing
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Hashable, Iterator, Mapping, Sequence
+    from pandas._libs.tslibs import BaseOffset
+    from pandas._typing import P
+    from pandas import DataFrame, ExcelWriter, HDFStore, Series
+    from pandas.core.indexers.objects import BaseIndexer
+    from pandas.core.resample import Resampler
+import textwrap
+_shared_docs = {**_shared_docs}
+_shared_doc_kwargs = {'axes': 'keywords for axes', 'klass': 'Series/DataFrame', 'axes_single_arg': "{0 or 'index'} for Series, {0 or 'index', 1 or 'columns'} for DataFrame", 'inplace': '\n    inplace : bool, default False\n        If True, performs operation inplace and returns None.', 'optional_by': '\n        by : str or list of str\n            Name or list of names to sort by'}
+
+class NDFrame(PandasObject, indexing.IndexingMixin):
+    _internal_names: list[str] = ['_mgr', '_item_cache', '_cache', '_name', '_metadata', '_flags']
+    _internal_names_set: set[str] = set(_internal_names)
+    _accessors: set[str] = set()
+    _hidden_attrs: frozenset[str] = frozenset([])
+    _metadata: list[str] = []
+    _mgr: Manager
+    _attrs: dict[Hashable, Any]
+    _typ: str
+
+    def __init__(self, data: Manager) -> None:
+        object.__setattr__(self, '_mgr', data)
+        object.__setattr__(self, '_attrs', {})
+        object.__setattr__(self, '_flags', Flags(self, allows_duplicate_labels=True))
+
+    @final
+    @classmethod
+    def _init_mgr(cls, mgr: Manager, axes: dict[Literal['index', 'columns'], Axes | None], dtype: DtypeObj | None=None, copy: bool=False) -> Manager:
+        for (a, axe) in axes.items():
+            if axe is not None:
+                axe = ensure_index(axe)
+                bm_axis = cls._get_block_manager_axis(a)
+                mgr = mgr.reindex_axis(axe, axis=bm_axis)
+        if copy:
+            mgr = mgr.copy()
+        if dtype is not None:
+            if isinstance(mgr, BlockManager) and len(mgr.blocks) == 1 and (mgr.blocks[0].values.dtype == dtype):
+                pass
+            else:
+                mgr = mgr.astype(dtype=dtype)
+        return mgr
+
+    @final
+    @classmethod
+    def _from_mgr(cls, mgr: Manager, axes: list[Index]) -> Self:
+        obj = cls.__new__(cls)
+        NDFrame.__init__(obj, mgr)
+        return obj
+
+    @property
+    def attrs(self) -> dict[Hashable, Any]:
+        return self._attrs
+
+    @attrs.setter
+    def attrs(self, value: Mapping[Hashable, Any]) -> None:
+        self._attrs = dict(value)
+
+    @final
+    @property
+    def flags(self) -> Flags:
+        return self._flags
+
+    @final
+    def set_flags(self, *, copy: bool | lib.NoDefault=lib.no_default, allows_duplicate_labels: bool | None=None) -> Self:
+        self._check_copy_deprecation(copy)
+        df = self.copy(deep=False)
+        if allows_duplicate_labels is not None:
+            df.flags['allows_duplicate_labels'] = allows_duplicate_labels
+        return df
+
+    @final
+    @classmethod
+    def _validate_dtype(cls, dtype) -> DtypeObj | None:
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+            if dtype.kind == 'V':
+                raise NotImplementedError(f'compound dtypes are not implemented in the {cls.__name__} constructor')
+        return dtype
+
+    @property
+    def _constructor(self) -> Callable[..., Self]:
+        raise AbstractMethodError(self)
+    _AXIS_ORDERS: list[Literal['index', 'columns']]
+    _AXIS_TO_AXIS_NUMBER: dict[Axis, AxisInt] = {0: 0, 'index': 0, 'rows': 0}
+    _info_axis_number: int
+    _info_axis_name: Literal['index', 'columns']
+    _AXIS_LEN: int
+
+    @final
+    def _construct_axes_dict(self, axes: Sequence[Axis] | None=None, **kwargs: AxisInt) -> dict:
+        d = {a: self._get_axis(a) for a in axes or self._AXIS_ORDERS}
+        d.update(kwargs)
+        return d
+
+    @final
+    @classmethod
+    def _get_axis_number(cls, axis: Axis) -> AxisInt:
+        try:
+            return cls._AXIS_TO_AXIS_NUMBER[axis]
+        except KeyError as err:
+            raise ValueError(f'No axis named {axis} for object type {cls.__name__}') from err
+
+    @final
+    @classmethod
+    def _get_axis_name(cls, axis: Axis) -> Literal['index', 'columns']:
+        axis_number = cls._get_axis_number(axis)
+        return cls._AXIS_ORDERS[axis_number]
+
+    @final
+    def _get_axis(self, axis: Axis) -> Index:
+        axis_number = self._get_axis_number(axis)
+        assert axis_number in {0, 1}
+        return self.index if axis_number == 0 else self.columns
+
+    @final
+    @classmethod
+    def _get_block_manager_axis(cls, axis: Axis) -> AxisInt:
+        axis = cls._get_axis_number(axis)
+        ndim = cls._AXIS_LEN
+        if ndim == 2:
+            return 1 - axis
+        return axis
+
+    @final
+    def _get_axis_resolvers(self, axis: str) -> dict[str, Series | MultiIndex]:
+        axis_index = getattr(self, axis)
+        d = {}
+        prefix = axis[0]
+        for (i, name) in enumerate(axis_index.names):
+            if name is not None:
+                key = level = name
+            else:
+                key = f'{prefix}level_{i}'
+                level = i
+            level_values = axis_index.get_level_values(level)
+            s = level_values.to_series()
+            s.index = axis_index
+            d[key] = s
+        if isinstance(axis_index, MultiIndex):
+            dindex = axis_index
+        else:
+            dindex = axis_index.to_series()
+        d[axis] = dindex
+        return d
+
+    @final
+    def _get_index_resolvers(self) -> dict[Hashable, Series | MultiIndex]:
+        from pandas.core.computation.parsing import clean_column_name
+        d: dict[str, Series | MultiIndex] = {}
+        for axis_name in self._AXIS_ORDERS:
+            d.update(self._get_axis_resolvers(axis_name))
+        return {clean_column_name(k): v for (k, v) in d.items() if not isinstance(k, int)}
+
+    @final
+    def _get_cleaned_column_resolvers(self) -> dict[Hashable, Series]:
+        from pandas.core.computation.parsing import clean_column_name
+        from pandas.core.series import Series
+        if isinstance(self, ABCSeries):
+            return {clean_column_name(self.name): self}
+        dtypes = self.dtypes
+        return {clean_column_name(k): Series(v, copy=False, index=self.index, name=k, dtype=dtypes[k]).__finalize__(self) for (k, v) in zip(self.columns, self._iter_column_arrays()) if not isinstance(k, int)}
+
+    @final
+    @property
+    def _info_axis(self) -> Index:
+        return getattr(self, self._info_axis_name)
+
+    @property
+    def shape(self) -> tuple[int, ...]:
+        return tuple((len(self._get_axis(a)) for a in self._AXIS_ORDERS))
+
+    @property
+    def axes(self) -> list[Index]:
+        return [self._get_axis(a) for a in self._AXIS_ORDERS]
+
+    @final
+    @property
+    def ndim(self) -> int:
+        return self._mgr.ndim
+
+    @final
+    @property
+    def size(self) -> int:
+        return int(np.prod(self.shape))
+
+    def set_axis(self, labels, *, axis: Axis=0, copy: bool | lib.NoDefault=lib.no_default) -> Self:
+        self._check_copy_deprecation(copy)
+        return self._set_axis_nocheck(labels, axis, inplace=False)
+
+    @overload
+    def _set_axis_nocheck(self, labels, axis: Axis, inplace: Literal[False]) -> Self:
+        ...
+
+    @overload
+    def _set_axis_nocheck(self, labels, axis: Axis, inplace: Literal[True]) -> None:
+        ...
+
+    @overload
+    def _set_axis_nocheck(self, labels, axis: Axis, inplace: bool) -> Self | None:
+        ...
+
+    @final
+    def _set_axis_nocheck(self, labels, axis: Axis, inplace: bool) -> Self | None:
+        if inplace:
+            setattr(self, self._get_axis_name(axis), labels)
+            return None
+        obj = self.copy(deep=False)
+        setattr(obj, obj._get_axis_name(axis), labels)
+        return obj
+
+    @final
+    def _set_axis(self, axis: AxisInt, labels: AnyArrayLike | list) -> None:
+        labels = ensure_index(labels)
+        self._mgr.set_axis(axis, labels)
+
+    @final
+    @doc(klass=_shared_doc_kwargs['klass'])
+    def droplevel(self, level: IndexLabel, axis: Axis=0) -> Self:
+        labels = self._get_axis(axis)
+        new_labels = labels.droplevel(level)
+        return self.set_axis(new_labels, axis=axis)
+
+    def pop(self, item: Hashable) -> Series | Any:
+        result = self[item]
+        del self[item]
+        return result
+
+    @final
+    def squeeze(self, axis: Axis | None=None):
+        axes = range(self._AXIS_LEN) if axis is None else (self._get_axis_number(axis),)
+        result = self.iloc[tuple((0 if i in axes and len(a) == 1 else slice(None) for (i, a) in enumerate(self.axes)))]
+        if isinstance(result, NDFrame):
+            result = result.__finalize__(self, method='squeeze')
+        return result
+
+    @overload
+    def _rename(self, mapper: Renamer | None=..., *, index: Renamer | None=..., columns: Renamer | None=..., axis: Axis | None=..., inplace: Literal[False]=..., level: Level | None=..., errors: str=...) -> Self:
+        ...
+
+    @overload
+    def _rename(self, mapper: Renamer | None=..., *, index: Renamer | None=..., columns: Renamer | None=..., axis: Axis | None=..., inplace: Literal[True], level: Level | None=..., errors: str=...) -> None:
+        ...
+
+    @overload
+    def _rename(self, mapper: Renamer | None=..., *, index: Renamer | None=..., columns: Renamer | None=..., axis: Axis | None=..., inplace: bool, level: Level | None=..., errors: str=...) -> Self | None:
+        ...
+
+    @final
+    def _rename(self, mapper: Renamer | None=None, *, index: Renamer | None=None, columns: Renamer | None=None, axis: Axis | None=None, inplace: bool=False, level: Level | None=None, errors: str='ignore') -> Self | None:
+        if mapper is None and index is None and (columns is None):
+            raise TypeError('must pass an index to rename')
+        if index is not None or columns is not None:
+            if axis is not None:
+                raise TypeError("Cannot specify both 'axis' and any of 'index' or 'columns'")
+            if mapper is not None:
+                raise TypeError("Cannot specify both 'mapper' and any of 'index' or 'columns'")
+        elif axis and self._get_axis_number(axis) == 1:
+            columns = mapper
+        else:
+            index = mapper
+        self._check_inplace_and_allows_duplicate_labels(inplace)
+        result = self if inplace else self.copy(deep=False)
+        for (axis_no, replacements) in enumerate((index, columns)):
+            if replacements is None:
+                continue
+            ax = self._get_axis(axis_no)
+            f = common.get_rename_function(replacements)
+            if level is not None:
+                level = ax._get_level_number(level)
+            if not callable(replacements):
+                if ax._is_multi and level is not None:
+                    indexer = ax.get_level_values(level).get_indexer_for(replacements)
+                else:
+                    indexer = ax.get_indexer_for(replacements)
+                if errors == 'raise' and len(indexer[indexer == -1]):
+                    missing_labels = [label for (index, label) in enumerate(replacements) if indexer[index] == -1]
+                    raise KeyError(f'{missing_labels} not found in axis')
+            new_index = ax._transform_index(f, level=level)
+            result._set_axis_nocheck(new_index, axis=axis_no, inplace=True)
+        if inplace:
+            self._update_inplace(result)
+            return None
+        else:
+            return result.__finalize__(self, method='rename')
+
+    @overload
+    def rename_axis(self, mapper: IndexLabel | lib.NoDefault=..., *, index=..., columns=..., axis: Axis=..., copy: bool | lib.NoDefault=lib.no_default, inplace: Literal[False]=...) -> Self:
+        ...
+
+    @overload
+    def rename_axis(self, mapper: IndexLabel | lib.NoDefault=..., *, index=..., columns=..., axis: Axis=..., copy: bool | lib.NoDefault=lib.no_default, inplace: Literal[True]) -> None:
+        ...
+
+    @overload
+    def rename_axis(self, mapper: IndexLabel | lib.NoDefault=..., *, index=..., columns=..., axis: Axis=..., copy: bool | lib.NoDefault=lib.no_default, inplace: bool=...) -> Self | None:
+        ...
+
+    def rename_axis(self, mapper: IndexLabel | lib.NoDefault=lib.no_default, *, index=lib.no_default, columns=lib.no_default, axis: Axis=0, copy: bool | lib.NoDefault=lib.no_default, inplace: bool=False) -> Self | None:
+        self._check_copy_deprecation(copy)
+        axes = {'index': index, 'columns': columns}
+        if axis is not None:
+            axis = self._get_axis_number(axis)
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if mapper is not lib.no_default:
+            non_mapper = is_scalar(mapper) or (is_list_like(mapper) and (not is_dict_like(mapper)))
+            if non_mapper:
+                return self._set_axis_name(mapper, axis=axis, inplace=inplace)
+            else:
+                raise ValueError('Use `.rename` to alter labels with a mapper.')
+        else:
+            result = self if inplace else self.copy(deep=False)
+            for axis in range(self._AXIS_LEN):
+                v = axes.get(self._get_axis_name(axis))
+                if v is lib.no_default:
+                    continue
+                non_mapper = is_scalar(v) or (is_list_like(v) and (not is_dict_like(v)))
+                if non_mapper:
+                    newnames = v
+                else:
+                    f = common.get_rename_function(v)
+                    curnames = self._get_axis(axis).names
+                    newnames = [f(name) for name in curnames]
+                result._set_axis_name(newnames, axis=axis, inplace=True)
+            if not inplace:
+                return result
+            return None
+
+    @overload
+    def _set_axis_name(self, name, axis: Axis=..., *, inplace: Literal[False]=...) -> Self:
+        ...
+
+    @overload
+    def _set_axis_name(self, name, axis: Axis=..., *, inplace: Literal[True]) -> None:
+        ...
+
+    @overload
+    def _set_axis_name(self, name, axis: Axis=..., *, inplace: bool) -> Self | None:
+        ...
+
+    @final
+    def _set_axis_name(self, name, axis: Axis=0, *, inplace: bool=False) -> Self | None:
+        axis = self._get_axis_number(axis)
+        idx = self._get_axis(axis).set_names(name)
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        renamed = self if inplace else self.copy(deep=False)
+        if axis == 0:
+            renamed.index = idx
+        else:
+            renamed.columns = idx
+        if not inplace:
+            return renamed
+        return None
+
+    @final
+    def _indexed_same(self, other) -> bool:
+        return all((self._get_axis(a).equals(other._get_axis(a)) for a in self._AXIS_ORDERS))
+
+    @final
+    def equals(self, other: object) -> bool:
+        if not (isinstance(other, type(self)) or isinstance(self, type(other))):
+            return False
+        other = cast(NDFrame, other)
+        return self._mgr.equals(other._mgr)
+
+    @final
+    def __neg__(self) -> Self:
+
+        def blk_func(values: ArrayLike):
+            if is_bool_dtype(values.dtype):
+                return operator.inv(values)
+            else:
+                return operator.neg(values)
+        new_data = self._mgr.apply(blk_func)
+        res = self._constructor_from_mgr(new_data, axes=new_data.axes)
+        return res.__finalize__(self, method='__neg__')
+
+    @final
+    def __pos__(self) -> Self:
+
+        def blk_func(values: ArrayLike):
+            if is_bool_dtype(values.dtype):
+                return values.copy()
+            else:
+                return operator.pos(values)
+        new_data = self._mgr.apply(blk_func)
+        res = self._constructor_from_mgr(new_data, axes=new_data.axes)
+        return res.__finalize__(self, method='__pos__')
+
+    @final
+    def __invert__(self) -> Self:
+        if not self.size:
+            return self.copy(deep=False)
+        new_data = self._mgr.apply(operator.invert)
+        res = self._constructor_from_mgr(new_data, axes=new_data.axes)
+        return res.__finalize__(self, method='__invert__')
+
+    @final
+    def __bool__(self) -> NoReturn:
+        raise ValueError(f'The truth value of a {type(self).__name__} is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().')
+
+    @final
+    def abs(self) -> Self:
+        res_mgr = self._mgr.apply(np.abs)
+        return self._constructor_from_mgr(res_mgr, axes=res_mgr.axes).__finalize__(self, name='abs')
+
+    @final
+    def __abs__(self) -> Self:
+        return self.abs()
+
+    @final
+    def __round__(self, decimals: int=0) -> Self:
+        return self.round(decimals).__finalize__(self, method='__round__')
+
+    @final
+    def _is_level_reference(self, key: Level, axis: Axis=0) -> bool:
+        axis_int = self._get_axis_number(axis)
+        return key is not None and is_hashable(key) and (key in self.axes[axis_int].names) and (not self._is_label_reference(key, axis=axis_int))
+
+    @final
+    def _is_label_reference(self, key: Level, axis: Axis=0) -> bool:
+        axis_int = self._get_axis_number(axis)
+        other_axes = (ax for ax in range(self._AXIS_LEN) if ax != axis_int)
+        return key is not None and is_hashable(key) and any((key in self.axes[ax] for ax in other_axes))
+
+    @final
+    def _is_label_or_level_reference(self, key: Level, axis: AxisInt=0) -> bool:
+        return self._is_level_reference(key, axis=axis) or self._is_label_reference(key, axis=axis)
+
+    @final
+    def _check_label_or_level_ambiguity(self, key: Level, axis: Axis=0) -> None:
+        axis_int = self._get_axis_number(axis)
+        other_axes = (ax for ax in range(self._AXIS_LEN) if ax != axis_int)
+        if key is not None and is_hashable(key) and (key in self.axes[axis_int].names) and any((key in self.axes[ax] for ax in other_axes)):
+            (level_article, level_type) = ('an', 'index') if axis_int == 0 else ('a', 'column')
+            (label_article, label_type) = ('a', 'column') if axis_int == 0 else ('an', 'index')
+            msg = f"'{key}' is both {level_article} {level_type} level and {label_article} {label_type} label, which is ambiguous."
+            raise ValueError(msg)
+
+    @final
+    def _get_label_or_level_values(self, key: Level, axis: AxisInt=0) -> ArrayLike:
+        axis = self._get_axis_number(axis)
+        first_other_axes = next((ax for ax in range(self._AXIS_LEN) if ax != axis), None)
+        if self._is_label_reference(key, axis=axis):
+            self._check_label_or_level_ambiguity(key, axis=axis)
+            if first_other_axes is None:
+                raise ValueError('axis matched all axes')
+            values = self.xs(key, axis=first_other_axes)._values
+        elif self._is_level_reference(key, axis=axis):
+            values = self.axes[axis].get_level_values(key)._values
+        else:
+            raise KeyError(key)
+        if values.ndim > 1:
+            if first_other_axes is not None and isinstance(self._get_axis(first_other_axes), MultiIndex):
+                multi_message = '\nFor a multi-index, the label must be a tuple with elements corresponding to each level.'
+            else:
+                multi_message = ''
+            label_axis_name = 'column' if axis == 0 else 'index'
+            raise ValueError(f"The {label_axis_name} label '{key}' is not unique.{multi_message}")
+        return values
+
+    @final
+    def _drop_labels_or_levels(self, keys, axis: AxisInt=0):
+        axis = self._get_axis_number(axis)
+        keys = common.maybe_make_list(keys)
+        invalid_keys = [k for k in keys if not self._is_label_or_level_reference(k, axis=axis)]
+        if invalid_keys:
+            raise ValueError(f'The following keys are not valid labels or levels for axis {axis}: {invalid_keys}')
+        levels_to_drop = [k for k in keys if self._is_level_reference(k, axis=axis)]
+        labels_to_drop = [k for k in keys if not self._is_level_reference(k, axis=axis)]
+        dropped = self.copy(deep=False)
+        if axis == 0:
+            if levels_to_drop:
+                dropped.reset_index(levels_to_drop, drop=True, inplace=True)
+            if labels_to_drop:
+                dropped.drop(labels_to_drop, axis=1, inplace=True)
+        else:
+            if levels_to_drop:
+                if isinstance(dropped.columns, MultiIndex):
+                    dropped.columns = dropped.columns.droplevel(levels_to_drop)
+                else:
+                    dropped.columns = default_index(dropped.columns.size)
+            if labels_to_drop:
+                dropped.drop(labels_to_drop, axis=0, inplace=True)
+        return dropped
+    __hash__: ClassVar[None]
+
+    def __iter__(self) -> Iterator:
+        return iter(self._info_axis)
+
+    def keys(self) -> Index:
+        return self._info_axis
+
+    def items(self):
+        for h in self._info_axis:
+            yield (h, self[h])
+
+    def __len__(self) -> int:
+        return len(self._info_axis)
+
+    @final
+    def __contains__(self, key) -> bool:
+        return key in self._info_axis
+
+    @property
+    def empty(self) -> bool:
+        return any((len(self._get_axis(a)) == 0 for a in self._AXIS_ORDERS))
+    __array_priority__: int = 1000
+
+    def __array__(self, dtype: npt.DTypeLike | None=None, copy: bool | None=None) -> np.ndarray:
+        values = self._values
+        arr = np.asarray(values, dtype=dtype)
+        if astype_is_view(values.dtype, arr.dtype) and self._mgr.is_single_block:
+            if astype_is_view(self.dtypes.iloc[0], values.dtype) and astype_is_view(values.dtype, arr.dtype):
+                arr = arr.view()
+                arr.flags.writeable = False
+        return arr
+
+    @final
+    def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs: Any, **kwargs: Any):
+        return arraylike.array_ufunc(self, ufunc, method, *inputs, **kwargs)
+
+    @final
+    def __getstate__(self) -> dict[str, Any]:
+        meta = {k: getattr(self, k, None) for k in self._metadata}
+        return {'_mgr': self._mgr, '_typ': self._typ, '_metadata': self._metadata, 'attrs': self.attrs, '_flags': {k: self.flags[k] for k in self.flags._keys}, **meta}
+
+    @final
+    def __setstate__(self, state) -> None:
+        if isinstance(state, BlockManager):
+            self._mgr = state
+        elif isinstance(state, dict):
+            if '_data' in state and '_mgr' not in state:
+                state['_mgr'] = state.pop('_data')
+            typ = state.get('_typ')
+            if typ is not None:
+                attrs = state.get('_attrs', {})
+                if attrs is None:
+                    attrs = {}
+                object.__setattr__(self, '_attrs', attrs)
+                flags = state.get('_flags', {'allows_duplicate_labels': True})
+                object.__setattr__(self, '_flags', Flags(self, **flags))
+                meta = set(self._internal_names + self._metadata)
+                for k in meta:
+                    if k in state and k != '_flags':
+                        v = state[k]
+                        object.__setattr__(self, k, v)
+                for (k, v) in state.items():
+                    if k not in meta:
+                        object.__setattr__(self, k, v)
+            else:
+                raise NotImplementedError('Pre-0.12 pickles are no longer supported')
+        elif len(state) == 2:
+            raise NotImplementedError('Pre-0.12 pickles are no longer supported')
+
+    def __repr__(self) -> str:
+        prepr = f"[{','.join(map(pprint_thing, self))}]"
+        return f'{type(self).__name__}({prepr})'
+
+    @final
+    def _repr_latex_(self):
+        if config.get_option('styler.render.repr') == 'latex':
+            return self.to_latex()
+        else:
+            return None
+
+    @final
+    def _repr_data_resource_(self):
+        if config.get_option('display.html.table_schema'):
+            data = self.head(config.get_option('display.max_rows'))
+            as_json = data.to_json(orient='table')
+            as_json = cast(str, as_json)
+            return loads(as_json, object_pairs_hook=collections.OrderedDict)
+
+    @final
+    @doc(klass='object', storage_options=_shared_docs['storage_options'], storage_options_versionadded='1.2.0', encoding_parameter='', verbose_parameter='', extra_parameters=textwrap.dedent('        engine_kwargs : dict, optional\n            Arbitrary keyword arguments passed to excel engine.\n        '))
+    def to_excel(self, excel_writer: FilePath | WriteExcelBuffer | ExcelWriter, *, sheet_name: str='Sheet1', na_rep: str='', float_format: str | None=None, columns: Sequence[Hashable] | None=None, header: Sequence[Hashable] | bool=True, index: bool=True, index_label: IndexLabel | None=None, startrow: int=0, startcol: int=0, engine: Literal['openpyxl', 'xlsxwriter'] | None=None, merge_cells: bool=True, inf_rep: str='inf', freeze_panes: tuple[int, int] | None=None, storage_options: StorageOptions | None=None, engine_kwargs: dict[str, Any] | None=None) -> None:
+        if engine_kwargs is None:
+            engine_kwargs = {}
+        df = self if isinstance(self, ABCDataFrame) else self.to_frame()
+        from pandas.io.formats.excel import ExcelFormatter
+        formatter = ExcelFormatter(df, na_rep=na_rep, cols=columns, header=header, float_format=float_format, index=index, index_label=index_label, merge_cells=merge_cells, inf_rep=inf_rep)
+        formatter.write(excel_writer, sheet_name=sheet_name, startrow=startrow, startcol=startcol, freeze_panes=freeze_panes, engine=engine, storage_options=storage_options, engine_kwargs=engine_kwargs)
+
+    @final
+    @doc(storage_options=_shared_docs['storage_options'], compression_options=_shared_docs['compression_options'] % 'path_or_buf')
+    def to_json(self, path_or_buf: FilePath | WriteBuffer[bytes] | WriteBuffer[str] | None=None, *, orient: Literal['split', 'records', 'index', 'table', 'columns', 'values'] | None=None, date_format: str | None=None, double_precision: int=10, force_ascii: bool=True, date_unit: TimeUnit='ms', default_handler: Callable[[Any], JSONSerializable] | None=None, lines: bool=False, compression: CompressionOptions='infer', index: bool | None=None, indent: int | None=None, storage_options: StorageOptions | None=None, mode: Literal['a', 'w']='w') -> str | None:
+        from pandas.io import json
+        if date_format is None and orient == 'table':
+            date_format = 'iso'
+        elif date_format is None:
+            date_format = 'epoch'
+            dtypes = self.dtypes if self.ndim == 2 else [self.dtype]
+            if any((lib.is_np_dtype(dtype, 'mM') for dtype in dtypes)):
+                warnings.warn("The default 'epoch' date format is deprecated and will be removed in a future version, please use 'iso' date format instead.", FutureWarning, stacklevel=find_stack_level())
+        elif date_format == 'epoch':
+            warnings.warn("'epoch' date format is deprecated and will be removed in a future version, please use 'iso' date format instead.", FutureWarning, stacklevel=find_stack_level())
+        config.is_nonnegative_int(indent)
+        indent = indent or 0
+        return json.to_json(path_or_buf=path_or_buf, obj=self, orient=orient, date_format=date_format, double_precision=double_precision, force_ascii=force_ascii, date_unit=date_unit, default_handler=default_handler, lines=lines, compression=compression, index=index, indent=indent, storage_options=storage_options, mode=mode)
+
+    @final
+    def to_hdf(self, path_or_buf: FilePath | HDFStore, *, key: str, mode: Literal['a', 'w', 'r+']='a', complevel: int | None=None, complib: Literal['zlib', 'lzo', 'bzip2', 'blosc'] | None=None, append: bool=False, format: Literal['fixed', 'table'] | None=None, index: bool=True, min_itemsize: int | dict[str, int] | None=None, nan_rep=None, dropna: bool | None=None, data_columns: Literal[True] | list[str] | None=None, errors: OpenFileErrors='strict', encoding: str='UTF-8') -> None:
+        from pandas.io import pytables
+        pytables.to_hdf(path_or_buf, key, self, mode=mode, complevel=complevel, complib=complib, append=append, format=format, index=index, min_itemsize=min_itemsize, nan_rep=nan_rep, dropna=dropna, data_columns=data_columns, errors=errors, encoding=encoding)
+
+    @final
+    def to_sql(self, name: str, con, *, schema: str | None=None, if_exists: Literal['fail', 'replace', 'append']='fail', index: bool=True, index_label: IndexLabel | None=None, chunksize: int | None=None, dtype: DtypeArg | None=None, method: Literal['multi'] | Callable | None=None) -> int | None:
+        from pandas.io import sql
+        return sql.to_sql(self, name, con, schema=schema, if_exists=if_exists, index=index, index_label=index_label, chunksize=chunksize, dtype=dtype, method=method)
+
+    @final
+    @doc(storage_options=_shared_docs['storage_options'], compression_options=_shared_docs['compression_options'] % 'path')
+    def to_pickle(self, path: FilePath | WriteBuffer[bytes], *, compression: CompressionOptions='infer', protocol: int=pickle.HIGHEST_PROTOCOL, storage_options: StorageOptions | None=None) -> None:
+        from pandas.io.pickle import to_pickle
+        to_pickle(self, path, compression=compression, protocol=protocol, storage_options=storage_options)
+
+    @final
+    def to_clipboard(self, *, excel: bool=True, sep: str | None=None, **kwargs) -> None:
+        from pandas.io import clipboards
+        clipboards.to_clipboard(self, excel=excel, sep=sep, **kwargs)
+
+    @final
+    def to_xarray(self):
+        xarray = import_optional_dependency('xarray')
+        if self.ndim == 1:
+            return xarray.DataArray.from_series(self)
+        else:
+            return xarray.Dataset.from_dataframe(self)
+
+    @overload
+    def to_latex(self, buf: None=..., *, columns: Sequence[Hashable] | None=..., header: bool | SequenceNotStr[str]=..., index: bool=..., na_rep: str=..., formatters: FormattersType | None=..., float_format: FloatFormatType | None=..., sparsify: bool | None=..., index_names: bool=..., bold_rows: bool=..., column_format: str | None=..., longtable: bool | None=..., escape: bool | None=..., encoding: str | None=..., decimal: str=..., multicolumn: bool | None=..., multicolumn_format: str | None=..., multirow: bool | None=..., caption: str | tuple[str, str] | None=..., label: str | None=..., position: str | None=...) -> str:
+        ...
+
+    @overload
+    def to_latex(self, buf: FilePath | WriteBuffer[str], *, columns: Sequence[Hashable] | None=..., header: bool | SequenceNotStr[str]=..., index: bool=..., na_rep: str=..., formatters: FormattersType | None=..., float_format: FloatFormatType | None=..., sparsify: bool | None=..., index_names: bool=..., bold_rows: bool=..., column_format: str | None=..., longtable: bool | None=..., escape: bool | None=..., encoding: str | None=..., decimal: str=..., multicolumn: bool | None=..., multicolumn_format: str | None=..., multirow: bool | None=..., caption: str | tuple[str, str] | None=..., label: str | None=..., position: str | None=...) -> None:
+        ...
+
+    @final
+    def to_latex(self, buf: FilePath | WriteBuffer[str] | None=None, *, columns: Sequence[Hashable] | None=None, header: bool | SequenceNotStr[str]=True, index: bool=True, na_rep: str='NaN', formatters: FormattersType | None=None, float_format: FloatFormatType | None=None, sparsify: bool | None=None, index_names: bool=True, bold_rows: bool=False, column_format: str | None=None, longtable: bool | None=None, escape: bool | None=None, encoding: str | None=None, decimal: str='.', multicolumn: bool | None=None, multicolumn_format: str | None=None, multirow: bool | None=None, caption: str | tuple[str, str] | None=None, label: str | None=None, position: str | None=None) -> str | None:
+        if self.ndim == 1:
+            self = self.to_frame()
+        if longtable is None:
+            longtable = config.get_option('styler.latex.environment') == 'longtable'
+        if escape is None:
+            escape = config.get_option('styler.format.escape') == 'latex'
+        if multicolumn is None:
+            multicolumn = config.get_option('styler.sparse.columns')
+        if multicolumn_format is None:
+            multicolumn_format = config.get_option('styler.latex.multicol_align')
+        if multirow is None:
+            multirow = config.get_option('styler.sparse.index')
+        if column_format is not None and (not isinstance(column_format, str)):
+            raise ValueError('`column_format` must be str or unicode')
+        length = len(self.columns) if columns is None else len(columns)
+        if isinstance(header, (list, tuple)) and len(header) != length:
+            raise ValueError(f'Writing {length} cols but got {len(header)} aliases')
+        base_format_ = {'na_rep': na_rep, 'escape': 'latex' if escape else None, 'decimal': decimal}
+        index_format_: dict[str, Any] = {'axis': 0, **base_format_}
+        column_format_: dict[str, Any] = {'axis': 1, **base_format_}
+        if isinstance(float_format, str):
+            float_format_: Callable | None = lambda x: float_format % x
+        else:
+            float_format_ = float_format
+
+        def _wrap(x, alt_format_):
+            if isinstance(x, (float, complex)) and float_format_ is not None:
+                return float_format_(x)
+            else:
+                return alt_format_(x)
+        formatters_: list | tuple | dict | Callable | None = None
+        if isinstance(formatters, list):
+            formatters_ = {c: partial(_wrap, alt_format_=formatters[i]) for (i, c) in enumerate(self.columns)}
+        elif isinstance(formatters, dict):
+            index_formatter = formatters.pop('__index__', None)
+            column_formatter = formatters.pop('__columns__', None)
+            if index_formatter is not None:
+                index_format_.update({'formatter': index_formatter})
+            if column_formatter is not None:
+                column_format_.update({'formatter': column_formatter})
+            formatters_ = formatters
+            float_columns = self.select_dtypes(include='float').columns
+            for col in float_columns:
+                if col not in formatters.keys():
+                    formatters_.update({col: float_format_})
+        elif formatters is None and float_format is not None:
+            formatters_ = partial(_wrap, alt_format_=lambda v: v)
+        format_index_ = [index_format_, column_format_]
+        hide_: list[dict] = []
+        relabel_index_: list[dict] = []
+        if columns:
+            hide_.append({'subset': [c for c in self.columns if c not in columns], 'axis': 'columns'})
+        if header is False:
+            hide_.append({'axis': 'columns'})
+        elif isinstance(header, (list, tuple)):
+            relabel_index_.append({'labels': header, 'axis': 'columns'})
+            format_index_ = [index_format_]
+        if index is False:
+            hide_.append({'axis': 'index'})
+        if index_names is False:
+            hide_.append({'names': True, 'axis': 'index'})
+        render_kwargs_ = {'hrules': True, 'sparse_index': sparsify, 'sparse_columns': sparsify, 'environment': 'longtable' if longtable else None, 'multicol_align': multicolumn_format if multicolumn else f'naive-{multicolumn_format}', 'multirow_align': 't' if multirow else 'naive', 'encoding': encoding, 'caption': caption, 'label': label, 'position': position, 'column_format': column_format, 'clines': 'skip-last;data' if multirow and isinstance(self.index, MultiIndex) else None, 'bold_rows': bold_rows}
+        return self._to_latex_via_styler(buf, hide=hide_, relabel_index=relabel_index_, format={'formatter': formatters_, **base_format_}, format_index=format_index_, render_kwargs=render_kwargs_)
+
+    @final
+    def _to_latex_via_styler(self, buf=None, *, hide: dict | list[dict] | None=None, relabel_index: dict | list[dict] | None=None, format: dict | list[dict] | None=None, format_index: dict | list[dict] | None=None, render_kwargs: dict | None=None):
+        from pandas.io.formats.style import Styler
+        self = cast('DataFrame', self)
+        styler = Styler(self, uuid='')
+        for kw_name in ['hide', 'relabel_index', 'format', 'format_index']:
+            kw = vars()[kw_name]
+            if isinstance(kw, dict):
+                getattr(styler, kw_name)(**kw)
+            elif isinstance(kw, list):
+                for sub_kw in kw:
+                    getattr(styler, kw_name)(**sub_kw)
+        render_kwargs = {} if render_kwargs is None else render_kwargs
+        if render_kwargs.pop('bold_rows'):
+            styler.map_index(lambda v: 'textbf:--rwrap;')
+        return styler.to_latex(buf=buf, **render_kwargs)
+
+    @overload
+    def to_csv(self, path_or_buf: None=..., *, sep: str=..., na_rep: str=..., float_format: str | Callable | None=..., columns: Sequence[Hashable] | None=..., header: bool | list[str]=..., index: bool=..., index_label: IndexLabel | None=..., mode: str=..., encoding: str | None=..., compression: CompressionOptions=..., quoting: int | None=..., quotechar: str=..., lineterminator: str | None=..., chunksize: int | None=..., date_format: str | None=..., doublequote: bool=..., escapechar: str | None=..., decimal: str=..., errors: OpenFileErrors=..., storage_options: StorageOptions=...) -> str:
+        ...
+
+    @overload
+    def to_csv(self, path_or_buf: FilePath | WriteBuffer[bytes] | WriteBuffer[str], *, sep: str=..., na_rep: str=..., float_format: str | Callable | None=..., columns: Sequence[Hashable] | None=..., header: bool | list[str]=..., index: bool=..., index_label: IndexLabel | None=..., mode: str=..., encoding: str | None=..., compression: CompressionOptions=..., quoting: int | None=..., quotechar: str=..., lineterminator: str | None=..., chunksize: int | None=..., date_format: str | None=..., doublequote: bool=..., escapechar: str | None=..., decimal: str=..., errors: OpenFileErrors=..., storage_options: StorageOptions=...) -> None:
+        ...
+
+    @final
+    @doc(storage_options=_shared_docs['storage_options'], compression_options=_shared_docs['compression_options'] % 'path_or_buf')
+    def to_csv(self, path_or_buf: FilePath | WriteBuffer[bytes] | WriteBuffer[str] | None=None, *, sep: str=',', na_rep: str='', float_format: str | Callable | None=None, columns: Sequence[Hashable] | None=None, header: bool | list[str]=True, index: bool=True, index_label: IndexLabel | None=None, mode: str='w', encoding: str | None=None, compression: CompressionOptions='infer', quoting: int | None=None, quotechar: str='"', lineterminator: str | None=None, chunksize: int | None=None, date_format: str | None=None, doublequote: bool=True, escapechar: str | None=None, decimal: str='.', errors: OpenFileErrors='strict', storage_options: StorageOptions | None=None) -> str | None:
+        df = self if isinstance(self, ABCDataFrame) else self.to_frame()
+        formatter = DataFrameFormatter(frame=df, header=header, index=index, na_rep=na_rep, float_format=float_format, decimal=decimal)
+        return DataFrameRenderer(formatter).to_csv(path_or_buf, lineterminator=lineterminator, sep=sep, encoding=encoding, errors=errors, compression=compression, quoting=quoting, columns=columns, index_label=index_label, mode=mode, chunksize=chunksize, quotechar=quotechar, date_format=date_format, doublequote=doublequote, escapechar=escapechar, storage_options=storage_options)
+
+    @final
+    def take(self, indices, axis: Axis=0, **kwargs) -> Self:
+        nv.validate_take((), kwargs)
+        if isinstance(indices, slice):
+            raise TypeError(f'{type(self).__name__}.take requires a sequence of integers, not slice.')
+        indices = np.asarray(indices, dtype=np.intp)
+        if axis == 0 and indices.ndim == 1 and is_range_indexer(indices, len(self)):
+            return self.copy(deep=False)
+        new_data = self._mgr.take(indices, axis=self._get_block_manager_axis(axis), verify=True)
+        return self._constructor_from_mgr(new_data, axes=new_data.axes).__finalize__(self, method='take')
+
+    @final
+    def xs(self, key: IndexLabel, axis: Axis=0, level: IndexLabel | None=None, drop_level: bool=True) -> Self:
+        axis = self._get_axis_number(axis)
+        labels = self._get_axis(axis)
+        if isinstance(key, list):
+            raise TypeError('list keys are not supported in xs, pass a tuple instead')
+        if level is not None:
+            if not isinstance(labels, MultiIndex):
+                raise TypeError('Index must be a MultiIndex')
+            (loc, new_ax) = labels.get_loc_level(key, level=level, drop_level=drop_level)
+            _indexer = [slice(None)] * self.ndim
+            _indexer[axis] = loc
+            indexer = tuple(_indexer)
+            result = self.iloc[indexer]
+            setattr(result, result._get_axis_name(axis), new_ax)
+            return result
+        if axis == 1:
+            if drop_level:
+                return self[key]
+            index = self.columns
+        else:
+            index = self.index
+        if isinstance(index, MultiIndex):
+            (loc, new_index) = index._get_loc_level(key, level=0)
+            if not drop_level:
+                if lib.is_integer(loc):
+                    new_index = index[loc:loc + 1]
+                else:
+                    new_index = index[loc]
+        else:
+            loc = index.get_loc(key)
+            if isinstance(loc, np.ndarray):
+                if loc.dtype == np.bool_:
+                    (inds,) = loc.nonzero()
+                    return self.take(inds, axis=axis)
+                else:
+                    return self.take(loc, axis=axis)
+            if not is_scalar(loc):
+                new_index = index[loc]
+        if is_scalar(loc) and axis == 0:
+            if self.ndim == 1:
+                return self._values[loc]
+            new_mgr = self._mgr.fast_xs(loc)
+            result = self._constructor_sliced_from_mgr(new_mgr, axes=new_mgr.axes)
+            result._name = self.index[loc]
+            result = result.__finalize__(self)
+        elif is_scalar(loc):
+            result = self.iloc[:, slice(loc, loc + 1)]
+        elif axis == 1:
+            result = self.iloc[:, loc]
+        else:
+            result = self.iloc[loc]
+            result.index = new_index
+        return result
+
+    def __getitem__(self, item):
+        raise AbstractMethodError(self)
+
+    @final
+    def _getitem_slice(self, key: slice) -> Self:
+        slobj = self.index._convert_slice_indexer(key, kind='getitem')
+        if isinstance(slobj, np.ndarray):
+            indexer = lib.maybe_indices_to_slice(slobj.astype(np.intp), len(self))
+            if isinstance(indexer, np.ndarray):
+                return self.take(indexer, axis=0)
+            slobj = indexer
+        return self._slice(slobj)
+
+    def _slice(self, slobj: slice, axis: AxisInt=0) -> Self:
+        assert isinstance(slobj, slice), type(slobj)
+        axis = self._get_block_manager_axis(axis)
+        new_mgr = self._mgr.get_slice(slobj, axis=axis)
+        result = self._constructor_from_mgr(new_mgr, axes=new_mgr.axes)
+        result = result.__finalize__(self)
+        return result
+
+    @final
+    def __delitem__(self, key) -> None:
+        deleted = False
+        maybe_shortcut = False
+        if self.ndim == 2 and isinstance(self.columns, MultiIndex):
+            try:
+                maybe_shortcut = key not in self.columns._engine
+            except TypeError:
+                pass
+        if maybe_shortcut:
+            if not isinstance(key, tuple):
+                key = (key,)
+            for col in self.columns:
+                if isinstance(col, tuple) and col[:len(key)] == key:
+                    del self[col]
+                    deleted = True
+        if not deleted:
+            loc = self.axes[-1].get_loc(key)
+            self._mgr = self._mgr.idelete(loc)
+
+    @final
+    def _check_inplace_and_allows_duplicate_labels(self, inplace: bool) -> None:
+        if inplace and (not self.flags.allows_duplicate_labels):
+            raise ValueError("Cannot specify 'inplace=True' when 'self.flags.allows_duplicate_labels' is False.")
+
+    @final
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except (KeyError, ValueError, IndexError):
+            return default
+
+    @staticmethod
+    def _check_copy_deprecation(copy):
+        if copy is not lib.no_default:
+            warnings.warn('The copy keyword is deprecated and will be removed in a future version. Copy-on-Write is active in pandas since 3.0 which utilizes a lazy copy mechanism that defers copies until necessary. Use .copy() to make an eager copy if necessary.', DeprecationWarning, stacklevel=find_stack_level())
+
+    @deprecate_kwarg('method', None)
+    @final
+    def reindex_like(self, other, method: Literal['backfill', 'bfill', 'pad', 'ffill', 'nearest'] | None=None, copy: bool | lib.NoDefault=lib.no_default, limit: int | None=None, tolerance=None) -> Self:
+        self._check_copy_deprecation(copy)
+        d = other._construct_axes_dict(axes=self._AXIS_ORDERS, method=method, limit=limit, tolerance=tolerance)
+        return self.reindex(**d)
+
+    @overload
+    def drop(self, labels: IndexLabel | ListLike=..., *, axis: Axis=..., index: IndexLabel | ListLike=..., columns: IndexLabel | ListLike=..., level: Level | None=..., inplace: Literal[True], errors: IgnoreRaise=...) -> None:
+        ...
+
+    @overload
+    def drop(self, labels: IndexLabel | ListLike=..., *, axis: Axis=..., index: IndexLabel | ListLike=..., columns: IndexLabel | ListLike=..., level: Level | None=..., inplace: Literal[False]=..., errors: IgnoreRaise=...) -> Self:
+        ...
+
+    @overload
+    def drop(self, labels: IndexLabel | ListLike=..., *, axis: Axis=..., index: IndexLabel | ListLike=..., columns: IndexLabel | ListLike=..., level: Level | None=..., inplace: bool=..., errors: IgnoreRaise=...) -> Self | None:
+        ...
+
+    def drop(self, labels: IndexLabel | ListLike=None, *, axis: Axis=0, index: IndexLabel | ListLike=None, columns: IndexLabel | ListLike=None, level: Level | None=None, inplace: bool=False, errors: IgnoreRaise='raise') -> Self | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if labels is not None:
+            if index is not None or columns is not None:
+                raise ValueError("Cannot specify both 'labels' and 'index'/'columns'")
+            axis_name = self._get_axis_name(axis)
+            axes = {axis_name: labels}
+        elif index is not None or columns is not None:
+            axes = {'index': index}
+            if self.ndim == 2:
+                axes['columns'] = columns
+        else:
+            raise ValueError("Need to specify at least one of 'labels', 'index' or 'columns'")
+        obj = self
+        for (axis, labels) in axes.items():
+            if labels is not None:
+                obj = obj._drop_axis(labels, axis, level=level, errors=errors)
+        if inplace:
+            self._update_inplace(obj)
+            return None
+        else:
+            return obj
+
+    @final
+    def _drop_axis(self, labels, axis, level=None, errors: IgnoreRaise='raise', only_slice: bool=False) -> Self:
+        axis_num = self._get_axis_number(axis)
+        axis = self._get_axis(axis)
+        if axis.is_unique:
+            if level is not None:
+                if not isinstance(axis, MultiIndex):
+                    raise AssertionError('axis must be a MultiIndex')
+                new_axis = axis.drop(labels, level=level, errors=errors)
+            else:
+                new_axis = axis.drop(labels, errors=errors)
+            indexer = axis.get_indexer(new_axis)
+        else:
+            is_tuple_labels = is_nested_list_like(labels) or isinstance(labels, tuple)
+            labels = ensure_object(common.index_labels_to_array(labels))
+            if level is not None:
+                if not isinstance(axis, MultiIndex):
+                    raise AssertionError('axis must be a MultiIndex')
+                mask = ~axis.get_level_values(level).isin(labels)
+                if errors == 'raise' and mask.all():
+                    raise KeyError(f'{labels} not found in axis')
+            elif isinstance(axis, MultiIndex) and labels.dtype == 'object' and (not is_tuple_labels):
+                mask = ~axis.get_level_values(0).isin(labels)
+            else:
+                mask = ~axis.isin(labels)
+                labels_missing = (axis.get_indexer_for(labels) == -1).any()
+                if errors == 'raise' and labels_missing:
+                    raise KeyError(f'{labels} not found in axis')
+            if isinstance(mask.dtype, ExtensionDtype):
+                mask = mask.to_numpy(dtype=bool)
+            indexer = mask.nonzero()[0]
+            new_axis = axis.take(indexer)
+        bm_axis = self.ndim - axis_num - 1
+        new_mgr = self._mgr.reindex_indexer(new_axis, indexer, axis=bm_axis, allow_dups=True, only_slice=only_slice)
+        result = self._constructor_from_mgr(new_mgr, axes=new_mgr.axes)
+        if self.ndim == 1:
+            result._name = self.name
+        return result.__finalize__(self)
+
+    @final
+    def _update_inplace(self, result) -> None:
+        self._mgr = result._mgr
+
+    @final
+    def add_prefix(self, prefix: str, axis: Axis | None=None) -> Self:
+        f = lambda x: f'{prefix}{x}'
+        axis_name = self._info_axis_name
+        if axis is not None:
+            axis_name = self._get_axis_name(axis)
+        mapper = {axis_name: f}
+        return self._rename(**mapper)
+
+    @final
+    def add_suffix(self, suffix: str, axis: Axis | None=None) -> Self:
+        f = lambda x: f'{x}{suffix}'
+        axis_name = self._info_axis_name
+        if axis is not None:
+            axis_name = self._get_axis_name(axis)
+        mapper = {axis_name: f}
+        return self._rename(**mapper)
+
+    @overload
+    def sort_values(self, *, axis: Axis=..., ascending: bool | Sequence[bool]=..., inplace: Literal[False]=..., kind: SortKind=..., na_position: NaPosition=..., ignore_index: bool=..., key: ValueKeyFunc=...) -> Self:
+        ...
+
+    @overload
+    def sort_values(self, *, axis: Axis=..., ascending: bool | Sequence[bool]=..., inplace: Literal[True], kind: SortKind=..., na_position: NaPosition=..., ignore_index: bool=..., key: ValueKeyFunc=...) -> None:
+        ...
+
+    @overload
+    def sort_values(self, *, axis: Axis=..., ascending: bool | Sequence[bool]=..., inplace: bool=..., kind: SortKind=..., na_position: NaPosition=..., ignore_index: bool=..., key: ValueKeyFunc=...) -> Self | None:
+        ...
+
+    def sort_values(self, *, axis: Axis=0, ascending: bool | Sequence[bool]=True, inplace: bool=False, kind: SortKind='quicksort', na_position: NaPosition='last', ignore_index: bool=False, key: ValueKeyFunc | None=None) -> Self | None:
+        raise AbstractMethodError(self)
+
+    @overload
+    def sort_index(self, *, axis: Axis=..., level: IndexLabel=..., ascending: bool | Sequence[bool]=..., inplace: Literal[True], kind: SortKind=..., na_position: NaPosition=..., sort_remaining: bool=..., ignore_index: bool=..., key: IndexKeyFunc=...) -> None:
+        ...
+
+    @overload
+    def sort_index(self, *, axis: Axis=..., level: IndexLabel=..., ascending: bool | Sequence[bool]=..., inplace: Literal[False]=..., kind: SortKind=..., na_position: NaPosition=..., sort_remaining: bool=..., ignore_index: bool=..., key: IndexKeyFunc=...) -> Self:
+        ...
+
+    @overload
+    def sort_index(self, *, axis: Axis=..., level: IndexLabel=..., ascending: bool | Sequence[bool]=..., inplace: bool=..., kind: SortKind=..., na_position: NaPosition=..., sort_remaining: bool=..., ignore_index: bool=..., key: IndexKeyFunc=...) -> Self | None:
+        ...
+
+    def sort_index(self, *, axis: Axis=0, level: IndexLabel | None=None, ascending: bool | Sequence[bool]=True, inplace: bool=False, kind: SortKind='quicksort', na_position: NaPosition='last', sort_remaining: bool=True, ignore_index: bool=False, key: IndexKeyFunc | None=None) -> Self | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        axis = self._get_axis_number(axis)
+        ascending = validate_ascending(ascending)
+        target = self._get_axis(axis)
+        indexer = get_indexer_indexer(target, level, ascending, kind, na_position, sort_remaining, key)
+        if indexer is None:
+            if inplace:
+                result = self
+            else:
+                result = self.copy(deep=False)
+            if ignore_index:
+                if axis == 1:
+                    result.columns = default_index(len(self.columns))
+                else:
+                    result.index = default_index(len(self))
+            if inplace:
+                return None
+            else:
+                return result
+        baxis = self._get_block_manager_axis(axis)
+        new_data = self._mgr.take(indexer, axis=baxis, verify=False)
+        if not ignore_index:
+            new_axis = new_data.axes[baxis]._sort_levels_monotonic()
+        else:
+            new_axis = default_index(len(indexer))
+        new_data.set_axis(baxis, new_axis)
+        result = self._constructor_from_mgr(new_data, axes=new_data.axes)
+        if inplace:
+            return self._update_inplace(result)
+        else:
+            return result.__finalize__(self, method='sort_index')
+
+    @doc(klass=_shared_doc_kwargs['klass'], optional_reindex='')
+    def reindex(self, labels=None, *, index=None, columns=None, axis: Axis | None=None, method: ReindexMethod | None=None, copy: bool | lib.NoDefault=lib.no_default, level: Level | None=None, fill_value: Scalar | None=np.nan, limit: int | None=None, tolerance=None) -> Self:
+        self._check_copy_deprecation(copy)
+        if index is not None and columns is not None and (labels is not None):
+            raise TypeError("Cannot specify all of 'labels', 'index', 'columns'.")
+        elif index is not None or columns is not None:
+            if axis is not None:
+                raise TypeError("Cannot specify both 'axis' and any of 'index' or 'columns'")
+            if labels is not None:
+                if index is not None:
+                    columns = labels
+                else:
+                    index = labels
+        elif axis and self._get_axis_number(axis) == 1:
+            columns = labels
+        else:
+            index = labels
+        axes: dict[Literal['index', 'columns'], Any] = {'index': index, 'columns': columns}
+        method = clean_reindex_fill_method(method)
+        if all((self._get_axis(axis_name).identical(ax) for (axis_name, ax) in axes.items() if ax is not None)):
+            return self.copy(deep=False)
+        if self._needs_reindex_multi(axes, method, level):
+            return self._reindex_multi(axes, fill_value)
+        return self._reindex_axes(axes, level, limit, tolerance, method, fill_value).__finalize__(self, method='reindex')
+
+    @final
+    def _reindex_axes(self, axes, level: Level | None, limit: int | None, tolerance, method, fill_value: Scalar | None) -> Self:
+        obj = self
+        for a in self._AXIS_ORDERS:
+            labels = axes[a]
+            if labels is None:
+                continue
+            ax = self._get_axis(a)
+            (new_index, indexer) = ax.reindex(labels, level=level, limit=limit, tolerance=tolerance, method=method)
+            axis = self._get_axis_number(a)
+            obj = obj._reindex_with_indexers({axis: [new_index, indexer]}, fill_value=fill_value, allow_dups=False)
+        return obj
+
+    def _needs_reindex_multi(self, axes, method, level: Level | None) -> bool:
+        return common.count_not_none(*axes.values()) == self._AXIS_LEN and method is None and (level is None) and self._can_fast_transpose
+
+    def _reindex_multi(self, axes, fill_value):
+        raise AbstractMethodError(self)
+
+    @final
+    def _reindex_with_indexers(self, reindexers, fill_value=None, allow_dups: bool=False) -> Self:
+        new_data = self._mgr
+        for axis in sorted(reindexers.keys()):
+            (index, indexer) = reindexers[axis]
+            baxis = self._get_block_manager_axis(axis)
+            if index is None:
+                continue
+            index = ensure_index(index)
+            if indexer is not None:
+                indexer = ensure_platform_int(indexer)
+            new_data = new_data.reindex_indexer(index, indexer, axis=baxis, fill_value=fill_value, allow_dups=allow_dups)
+        if new_data is self._mgr:
+            new_data = new_data.copy(deep=False)
+        return self._constructor_from_mgr(new_data, axes=new_data.axes).__finalize__(self)
+
+    def filter(self, items=None, like: str | None=None, regex: str | None=None, axis: Axis | None=None) -> Self:
+        nkw = common.count_not_none(items, like, regex)
+        if nkw > 1:
+            raise TypeError('Keyword arguments `items`, `like`, or `regex` are mutually exclusive')
+        if axis is None:
+            axis = self._info_axis_name
+        labels = self._get_axis(axis)
+        if items is not None:
+            name = self._get_axis_name(axis)
+            items = Index(items).intersection(labels)
+            if len(items) == 0:
+                items = items.astype(labels.dtype)
+            return self.reindex(**{name: items})
+        elif like:
+
+            def f(x) -> bool:
+                assert like is not None
+                return like in ensure_str(x)
+            values = labels.map(f)
+            return self.loc(axis=axis)[values]
+        elif regex:
+
+            def f(x) -> bool:
+                return matcher.search(ensure_str(x)) is not None
+            matcher = re.compile(regex)
+            values = labels.map(f)
+            return self.loc(axis=axis)[values]
+        else:
+            raise TypeError('Must pass either `items`, `like`, or `regex`')
+
+    @final
+    def head(self, n: int=5) -> Self:
+        return self.iloc[:n].copy()
+
+    @final
+    def tail(self, n: int=5) -> Self:
+        if n == 0:
+            return self.iloc[0:0].copy()
+        return self.iloc[-n:].copy()
+
+    @final
+    def sample(self, n: int | None=None, frac: float | None=None, replace: bool=False, weights=None, random_state: RandomState | None=None, axis: Axis | None=None, ignore_index: bool=False) -> Self:
+        if axis is None:
+            axis = 0
+        axis = self._get_axis_number(axis)
+        obj_len = self.shape[axis]
+        rs = common.random_state(random_state)
+        size = sample.process_sampling_size(n, frac, replace)
+        if size is None:
+            assert frac is not None
+            size = round(frac * obj_len)
+        if weights is not None:
+            weights = sample.preprocess_weights(self, weights, axis)
+        sampled_indices = sample.sample(obj_len, size, replace, weights, rs)
+        result = self.take(sampled_indices, axis=axis)
+        if ignore_index:
+            result.index = default_index(len(result))
+        return result
+
+    @overload
+    def pipe(self, func: Callable[Concatenate[Self, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+        ...
+
+    @overload
+    def pipe(self, func: tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T:
+        ...
+
+    @final
+    @doc(klass=_shared_doc_kwargs['klass'])
+    def pipe(self, func: Callable[Concatenate[Self, P], T] | tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T:
+        return common.pipe(self.copy(deep=False), func, *args, **kwargs)
+
+    @final
+    def __finalize__(self, other, method: str | None=None, **kwargs) -> Self:
+        if isinstance(other, NDFrame):
+            if other.attrs:
+                self.attrs = deepcopy(other.attrs)
+            self.flags.allows_duplicate_labels = other.flags.allows_duplicate_labels
+            for name in set(self._metadata) & set(other._metadata):
+                assert isinstance(name, str)
+                object.__setattr__(self, name, getattr(other, name, None))
+        if method == 'concat':
+            objs = other.objs
+            if all((bool(obj.attrs) for obj in objs)):
+                attrs = objs[0].attrs
+                have_same_attrs = all((obj.attrs == attrs for obj in objs[1:]))
+                if have_same_attrs:
+                    self.attrs = deepcopy(attrs)
+            allows_duplicate_labels = all((x.flags.allows_duplicate_labels for x in objs))
+            self.flags.allows_duplicate_labels = allows_duplicate_labels
+        return self
+
+    @final
+    def __getattr__(self, name: str):
+        if name not in self._internal_names_set and name not in self._metadata and (name not in self._accessors) and self._info_axis._can_hold_identifiers_and_holds_name(name):
+            return self[name]
+        return object.__getattribute__(self, name)
+
+    @final
+    def __setattr__(self, name: str, value) -> None:
+        try:
+            object.__getattribute__(self, name)
+            return object.__setattr__(self, name, value)
+        except AttributeError:
+            pass
+        if name in self._internal_names_set:
+            object.__setattr__(self, name, value)
+        elif name in self._metadata:
+            object.__setattr__(self, name, value)
+        else:
+            try:
+                existing = getattr(self, name)
+                if isinstance(existing, Index):
+                    object.__setattr__(self, name, value)
+                elif name in self._info_axis:
+                    self[name] = value
+                else:
+                    object.__setattr__(self, name, value)
+            except (AttributeError, TypeError):
+                if isinstance(self, ABCDataFrame) and is_list_like(value):
+                    warnings.warn("Pandas doesn't allow columns to be created via a new attribute name - see https://pandas.pydata.org/pandas-docs/stable/indexing.html#attribute-access", stacklevel=find_stack_level())
+                object.__setattr__(self, name, value)
+
+    @final
+    def _dir_additions(self) -> set[str]:
+        additions = super()._dir_additions()
+        if self._info_axis._can_hold_strings:
+            additions.update(self._info_axis._dir_additions_for_owner)
+        return additions
+
+    @final
+    def _consolidate_inplace(self) -> None:
+        self._mgr = self._mgr.consolidate()
+
+    @final
+    def _consolidate(self):
+        cons_data = self._mgr.consolidate()
+        return self._constructor_from_mgr(cons_data, axes=cons_data.axes).__finalize__(self)
+
+    @final
+    @property
+    def _is_mixed_type(self) -> bool:
+        if self._mgr.is_single_block:
+            return False
+        if self._mgr.any_extension_types:
+            return True
+        return self.dtypes.nunique() > 1
+
+    @final
+    def _get_numeric_data(self) -> Self:
+        new_mgr = self._mgr.get_numeric_data()
+        return self._constructor_from_mgr(new_mgr, axes=new_mgr.axes).__finalize__(self)
+
+    @final
+    def _get_bool_data(self):
+        new_mgr = self._mgr.get_bool_data()
+        return self._constructor_from_mgr(new_mgr, axes=new_mgr.axes).__finalize__(self)
+
+    @property
+    def values(self):
+        raise AbstractMethodError(self)
+
+    @property
+    def _values(self) -> ArrayLike:
+        raise AbstractMethodError(self)
+
+    @property
+    def dtypes(self):
+        data = self._mgr.get_dtypes()
+        return self._constructor_sliced(data, index=self._info_axis, dtype=np.object_)
+
+    @final
+    def astype(self, dtype, copy: bool | lib.NoDefault=lib.no_default, errors: IgnoreRaise='raise') -> Self:
+        self._check_copy_deprecation(copy)
+        if is_dict_like(dtype):
+            if self.ndim == 1:
+                if len(dtype) > 1 or self.name not in dtype:
+                    raise KeyError('Only the Series name can be used for the key in Series dtype mappings.')
+                new_type = dtype[self.name]
+                return self.astype(new_type, errors=errors)
+            from pandas import Series
+            dtype_ser = Series(dtype, dtype=object)
+            for col_name in dtype_ser.index:
+                if col_name not in self:
+                    raise KeyError(f"Only a column name can be used for the key in a dtype mappings argument. '{col_name}' not found in columns.")
+            dtype_ser = dtype_ser.reindex(self.columns, fill_value=None)
+            results = []
+            for (i, (col_name, col)) in enumerate(self.items()):
+                cdt = dtype_ser.iat[i]
+                if isna(cdt):
+                    res_col = col.copy(deep=False)
+                else:
+                    try:
+                        res_col = col.astype(dtype=cdt, errors=errors)
+                    except ValueError as ex:
+                        ex.args = (f"{ex}: Error while type casting for column '{col_name}'",)
+                        raise
+                results.append(res_col)
+        elif is_extension_array_dtype(dtype) and self.ndim > 1:
+            dtype = pandas_dtype(dtype)
+            if isinstance(dtype, ExtensionDtype) and all((block.values.dtype == dtype for block in self._mgr.blocks)):
+                return self.copy(deep=False)
+            results = [ser.astype(dtype, errors=errors) for (_, ser) in self.items()]
+        else:
+            new_data = self._mgr.astype(dtype=dtype, errors=errors)
+            res = self._constructor_from_mgr(new_data, axes=new_data.axes)
+            return res.__finalize__(self, method='astype')
+        if not results:
+            return self.copy(deep=False)
+        result = concat(results, axis=1)
+        result = self._constructor(result)
+        result.columns = self.columns
+        result = result.__finalize__(self, method='astype')
+        return cast(Self, result)
+
+    @final
+    def copy(self, deep: bool=True) -> Self:
+        data = self._mgr.copy(deep=deep)
+        return self._constructor_from_mgr(data, axes=data.axes).__finalize__(self, method='copy')
+
+    @final
+    def __copy__(self, deep: bool=True) -> Self:
+        return self.copy(deep=deep)
+
+    @final
+    def __deepcopy__(self, memo=None) -> Self:
+        return self.copy(deep=True)
+
+    @final
+    def infer_objects(self, copy: bool | lib.NoDefault=lib.no_default) -> Self:
+        self._check_copy_deprecation(copy)
+        new_mgr = self._mgr.convert()
+        res = self._constructor_from_mgr(new_mgr, axes=new_mgr.axes)
+        return res.__finalize__(self, method='infer_objects')
+
+    @final
+    def convert_dtypes(self, infer_objects: bool=True, convert_string: bool=True, convert_integer: bool=True, convert_boolean: bool=True, convert_floating: bool=True, dtype_backend: DtypeBackend='numpy_nullable') -> Self:
+        check_dtype_backend(dtype_backend)
+        new_mgr = self._mgr.convert_dtypes(infer_objects=infer_objects, convert_string=convert_string, convert_integer=convert_integer, convert_boolean=convert_boolean, convert_floating=convert_floating, dtype_backend=dtype_backend)
+        res = self._constructor_from_mgr(new_mgr, axes=new_mgr.axes)
+        return res.__finalize__(self, method='convert_dtypes')
+
+    @final
+    def _pad_or_backfill(self, method: Literal['ffill', 'bfill', 'pad', 'backfill'], *, axis: None | Axis=None, inplace: bool=False, limit: None | int=None, limit_area: Literal['inside', 'outside'] | None=None):
+        if axis is None:
+            axis = 0
+        axis = self._get_axis_number(axis)
+        method = clean_fill_method(method)
+        if axis == 1:
+            if not self._mgr.is_single_block and inplace:
+                raise NotImplementedError
+            result = self.T._pad_or_backfill(method=method, limit=limit, limit_area=limit_area).T
+            return result
+        new_mgr = self._mgr.pad_or_backfill(method=method, limit=limit, limit_area=limit_area, inplace=inplace)
+        result = self._constructor_from_mgr(new_mgr, axes=new_mgr.axes)
+        if inplace:
+            return self._update_inplace(result)
+        else:
+            return result.__finalize__(self, method='fillna')
+
+    @overload
+    def fillna(self, value: Hashable | Mapping | Series | DataFrame, *, axis: Axis | None=..., inplace: Literal[False]=..., limit: int | None=...) -> Self:
+        ...
+
+    @overload
+    def fillna(self, value: Hashable | Mapping | Series | DataFrame, *, axis: Axis | None=..., inplace: Literal[True], limit: int | None=...) -> None:
+        ...
+
+    @overload
+    def fillna(self, value: Hashable | Mapping | Series | DataFrame, *, axis: Axis | None=..., inplace: bool=..., limit: int | None=...) -> Self | None:
+        ...
+
+    @final
+    @doc(klass=_shared_doc_kwargs['klass'], axes_single_arg=_shared_doc_kwargs['axes_single_arg'])
+    def fillna(self, value: Hashable | Mapping | Series | DataFrame, *, axis: Axis | None=None, inplace: bool=False, limit: int | None=None) -> Self | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if inplace:
+            if not PYPY:
+                if sys.getrefcount(self) <= REF_COUNT:
+                    warnings.warn(_chained_assignment_method_msg, ChainedAssignmentError, stacklevel=2)
+        if isinstance(value, (list, tuple)):
+            raise TypeError(f'"value" parameter must be a scalar or dict, but you passed a "{type(value).__name__}"')
+        if axis is None:
+            axis = 0
+        axis = self._get_axis_number(axis)
+        if self.ndim == 1:
+            if isinstance(value, (dict, ABCSeries)):
+                if not len(value):
+                    if inplace:
+                        return None
+                    return self.copy(deep=False)
+                from pandas import Series
+                value = Series(value)
+                value = value.reindex(self.index)
+                value = value._values
+            elif not is_list_like(value):
+                pass
+            else:
+                raise TypeError(f'"value" parameter must be a scalar, dict or Series, but you passed a "{type(value).__name__}"')
+            new_data = self._mgr.fillna(value=value, limit=limit, inplace=inplace)
+        elif isinstance(value, (dict, ABCSeries)):
+            if axis == 1:
+                raise NotImplementedError('Currently only can fill with dict/Series column by column')
+            result = self if inplace else self.copy(deep=False)
+            for (k, v) in value.items():
+                if k not in result:
+                    continue
+                res_k = result[k].fillna(v, limit=limit)
+                if not inplace:
+                    result[k] = res_k
+                elif isinstance(res_k, ABCSeries):
+                    if res_k.dtype == result[k].dtype:
+                        result.loc[:, k] = res_k
+                    else:
+                        result[k] = res_k
+                else:
+                    locs = result.columns.get_loc(k)
+                    if isinstance(locs, slice):
+                        locs = range(self.shape[1])[locs]
+                    elif isinstance(locs, np.ndarray) and locs.dtype.kind == 'b':
+                        locs = locs.nonzero()[0]
+                    elif not (isinstance(locs, np.ndarray) and locs.dtype.kind == 'i'):
+                        raise NotImplementedError('Unexpected get_loc result, please report a bug at https://github.com/pandas-dev/pandas')
+                    for (i, loc) in enumerate(locs):
+                        res_loc = res_k.iloc[:, i]
+                        target = self.iloc[:, loc]
+                        if res_loc.dtype == target.dtype:
+                            result.iloc[:, loc] = res_loc
+                        else:
+                            result.isetitem(loc, res_loc)
+            if inplace:
+                return self._update_inplace(result)
+            else:
+                return result
+        elif not is_list_like(value):
+            if axis == 1:
+                result = self.T.fillna(value=value, limit=limit).T
+                new_data = result._mgr
+            else:
+                new_data = self._mgr.fillna(value=value, limit=limit, inplace=inplace)
+        elif isinstance(value, ABCDataFrame) and self.ndim == 2:
+            new_data = self.where(self.notna(), value)._mgr
+        else:
+            raise ValueError(f'invalid fill value with a {type(value)}')
+        result = self._constructor_from_mgr(new_data, axes=new_data.axes)
+        if inplace:
+            return self._update_inplace(result)
+        else:
+            return result.__finalize__(self, method='fillna')
+
+    @overload
+    def ffill(self, *, axis: None | Axis=..., inplace: Literal[False]=..., limit: None | int=..., limit_area: Literal['inside', 'outside'] | None=...) -> Self:
+        ...
+
+    @overload
+    def ffill(self, *, axis: None | Axis=..., inplace: Literal[True], limit: None | int=..., limit_area: Literal['inside', 'outside'] | None=...) -> None:
+        ...
+
+    @overload
+    def ffill(self, *, axis: None | Axis=..., inplace: bool=..., limit: None | int=..., limit_area: Literal['inside', 'outside'] | None=...) -> Self | None:
+        ...
+
+    @final
+    @doc(klass=_shared_doc_kwargs['klass'], axes_single_arg=_shared_doc_kwargs['axes_single_arg'])
+    def ffill(self, *, axis: None | Axis=None, inplace: bool=False, limit: None | int=None, limit_area: Literal['inside', 'outside'] | None=None) -> Self | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if inplace:
+            if not PYPY:
+                if sys.getrefcount(self) <= REF_COUNT:
+                    warnings.warn(_chained_assignment_method_msg, ChainedAssignmentError, stacklevel=2)
+        return self._pad_or_backfill('ffill', axis=axis, inplace=inplace, limit=limit, limit_area=limit_area)
+
+    @overload
+    def bfill(self, *, axis: None | Axis=..., inplace: Literal[False]=..., limit: None | int=..., limit_area: Literal['inside', 'outside'] | None=...) -> Self:
+        ...
+
+    @overload
+    def bfill(self, *, axis: None | Axis=..., inplace: Literal[True], limit: None | int=...) -> None:
+        ...
+
+    @overload
+    def bfill(self, *, axis: None | Axis=..., inplace: bool=..., limit: None | int=..., limit_area: Literal['inside', 'outside'] | None=...) -> Self | None:
+        ...
+
+    @final
+    @doc(klass=_shared_doc_kwargs['klass'], axes_single_arg=_shared_doc_kwargs['axes_single_arg'])
+    def bfill(self, *, axis: None | Axis=None, inplace: bool=False, limit: None | int=None, limit_area: Literal['inside', 'outside'] | None=None) -> Self | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if inplace:
+            if not PYPY:
+                if sys.getrefcount(self) <= REF_COUNT:
+                    warnings.warn(_chained_assignment_method_msg, ChainedAssignmentError, stacklevel=2)
+        return self._pad_or_backfill('bfill', axis=axis, inplace=inplace, limit=limit, limit_area=limit_area)
+
+    @overload
+    def replace(self, to_replace=..., value=..., *, inplace: Literal[False]=..., regex: bool=...) -> Self:
+        ...
+
+    @overload
+    def replace(self, to_replace=..., value=..., *, inplace: Literal[True], regex: bool=...) -> None:
+        ...
+
+    @overload
+    def replace(self, to_replace=..., value=..., *, inplace: bool=..., regex: bool=...) -> Self | None:
+        ...
+
+    @final
+    @doc(_shared_docs['replace'], klass=_shared_doc_kwargs['klass'], inplace=_shared_doc_kwargs['inplace'])
+    def replace(self, to_replace=None, value=lib.no_default, *, inplace: bool=False, regex: bool=False) -> Self | None:
+        if not is_bool(regex) and to_replace is not None:
+            raise ValueError("'to_replace' must be 'None' if 'regex' is not a bool")
+        if not (is_scalar(to_replace) or is_re_compilable(to_replace) or is_list_like(to_replace)):
+            raise TypeError(f"Expecting 'to_replace' to be either a scalar, array-like, dict or None, got invalid type {type(to_replace).__name__!r}")
+        if value is lib.no_default and (not (is_dict_like(to_replace) or is_dict_like(regex))):
+            raise ValueError(f"{type(self).__name__}.replace must specify either 'value', a dict-like 'to_replace', or dict-like 'regex'.")
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if inplace:
+            if not PYPY:
+                if sys.getrefcount(self) <= REF_COUNT:
+                    warnings.warn(_chained_assignment_method_msg, ChainedAssignmentError, stacklevel=2)
+        if value is lib.no_default:
+            if not is_dict_like(to_replace):
+                to_replace = regex
+                regex = True
+            items = list(to_replace.items())
+            if items:
+                (keys, values) = zip(*items)
+            else:
+                (keys, values) = ([], [])
+            are_mappings = [is_dict_like(v) for v in values]
+            if any(are_mappings):
+                if not all(are_mappings):
+                    raise TypeError('If a nested mapping is passed, all values of the top level mapping must be mappings')
+                to_rep_dict = {}
+                value_dict = {}
+                for (k, v) in items:
+                    (keys, values) = list(zip(*v.items())) or ([], [])
+                    to_rep_dict[k] = list(keys)
+                    value_dict[k] = list(values)
+                (to_replace, value) = (to_rep_dict, value_dict)
+            else:
+                (to_replace, value) = (keys, values)
+            return self.replace(to_replace, value, inplace=inplace, regex=regex)
+        else:
+            if not self.size:
+                if inplace:
+                    return None
+                return self.copy(deep=False)
+            if is_dict_like(to_replace):
+                if is_dict_like(value):
+                    if isinstance(self, ABCSeries):
+                        raise ValueError('to_replace and value cannot be dict-like for Series.replace')
+                    mapping = {col: (to_replace[col], value[col]) for col in to_replace.keys() if col in value.keys() and col in self}
+                    return self._replace_columnwise(mapping, inplace, regex)
+                elif not is_list_like(value):
+                    if self.ndim == 1:
+                        raise ValueError('Series.replace cannot use dict-like to_replace and non-None value')
+                    mapping = {col: (to_rep, value) for (col, to_rep) in to_replace.items()}
+                    return self._replace_columnwise(mapping, inplace, regex)
+                else:
+                    raise TypeError('value argument must be scalar, dict, or Series')
+            elif is_list_like(to_replace):
+                if not is_list_like(value):
+                    value = [value] * len(to_replace)
+                if len(to_replace) != len(value):
+                    raise ValueError(f'Replacement lists must match in length. Expecting {len(to_replace)} got {len(value)} ')
+                new_data = self._mgr.replace_list(src_list=to_replace, dest_list=value, inplace=inplace, regex=regex)
+            elif to_replace is None:
+                if not (is_re_compilable(regex) or is_list_like(regex) or is_dict_like(regex)):
+                    raise TypeError(f"'regex' must be a string or a compiled regular expression or a list or dict of strings or regular expressions, you passed a {type(regex).__name__!r}")
+                return self.replace(regex, value, inplace=inplace, regex=True)
+            elif is_dict_like(value):
+                if self.ndim == 1:
+                    raise ValueError('Series.replace cannot use dict-value and non-None to_replace')
+                mapping = {col: (to_replace, val) for (col, val) in value.items()}
+                return self._replace_columnwise(mapping, inplace, regex)
+            elif not is_list_like(value):
+                regex = should_use_regex(regex, to_replace)
+                if regex:
+                    new_data = self._mgr.replace_regex(to_replace=to_replace, value=value, inplace=inplace)
+                else:
+                    new_data = self._mgr.replace(to_replace=to_replace, value=value, inplace=inplace)
+            else:
+                raise TypeError(f'Invalid "to_replace" type: {type(to_replace).__name__!r}')
+        result = self._constructor_from_mgr(new_data, axes=new_data.axes)
+        if inplace:
+            return self._update_inplace(result)
+        else:
+            return result.__finalize__(self, method='replace')
+
+    @overload
+    def interpolate(self, method: InterpolateOptions=..., *, axis: Axis=..., limit: int | None=..., inplace: Literal[False]=..., limit_direction: Literal['forward', 'backward', 'both'] | None=..., limit_area: Literal['inside', 'outside'] | None=..., **kwargs) -> Self:
+        ...
+
+    @overload
+    def interpolate(self, method: InterpolateOptions=..., *, axis: Axis=..., limit: int | None=..., inplace: Literal[True], limit_direction: Literal['forward', 'backward', 'both'] | None=..., limit_area: Literal['inside', 'outside'] | None=..., **kwargs) -> None:
+        ...
+
+    @overload
+    def interpolate(self, method: InterpolateOptions=..., *, axis: Axis=..., limit: int | None=..., inplace: bool=..., limit_direction: Literal['forward', 'backward', 'both'] | None=..., limit_area: Literal['inside', 'outside'] | None=..., **kwargs) -> Self | None:
+        ...
+
+    @final
+    def interpolate(self, method: InterpolateOptions='linear', *, axis: Axis=0, limit: int | None=None, inplace: bool=False, limit_direction: Literal['forward', 'backward', 'both'] | None=None, limit_area: Literal['inside', 'outside'] | None=None, **kwargs) -> Self | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if inplace:
+            if not PYPY:
+                if sys.getrefcount(self) <= REF_COUNT:
+                    warnings.warn(_chained_assignment_method_msg, ChainedAssignmentError, stacklevel=2)
+        axis = self._get_axis_number(axis)
+        if self.empty:
+            if inplace:
+                return None
+            return self.copy()
+        if not isinstance(method, str):
+            raise ValueError("'method' should be a string, not None.")
+        (obj, should_transpose) = (self.T, True) if axis == 1 else (self, False)
+        if isinstance(obj.index, MultiIndex) and method != 'linear':
+            raise ValueError('Only `method=linear` interpolation is supported on MultiIndexes.')
+        limit_direction = missing.infer_limit_direction(limit_direction, method)
+        index = missing.get_interp_index(method, obj.index)
+        new_data = obj._mgr.interpolate(method=method, index=index, limit=limit, limit_direction=limit_direction, limit_area=limit_area, inplace=inplace, **kwargs)
+        result = self._constructor_from_mgr(new_data, axes=new_data.axes)
+        if should_transpose:
+            result = result.T
+        if inplace:
+            return self._update_inplace(result)
+        else:
+            return result.__finalize__(self, method='interpolate')
+
+    @final
+    def asof(self, where, subset=None):
+        if isinstance(where, str):
+            where = Timestamp(where)
+        if not self.index.is_monotonic_increasing:
+            raise ValueError('asof requires a sorted index')
+        is_series = isinstance(self, ABCSeries)
+        if is_series:
+            if subset is not None:
+                raise ValueError('subset is not valid for Series')
+        else:
+            if subset is None:
+                subset = self.columns
+            if not is_list_like(subset):
+                subset = [subset]
+        is_list = is_list_like(where)
+        if not is_list:
+            start = self.index[0]
+            if isinstance(self.index, PeriodIndex):
+                where = Period(where, freq=self.index.freq)
+            if where < start:
+                if not is_series:
+                    return self._constructor_sliced(index=self.columns, name=where, dtype=np.float64)
+                return np.nan
+            if is_series:
+                loc = self.index.searchsorted(where, side='right')
+                if loc > 0:
+                    loc -= 1
+                values = self._values
+                while loc > 0 and isna(values[loc]):
+                    loc -= 1
+                return values[loc]
+        if not isinstance(where, Index):
+            where = Index(where) if is_list else Index([where])
+        nulls = self.isna() if is_series else self[subset].isna().any(axis=1)
+        if nulls.all():
+            if is_series:
+                self = cast('Series', self)
+                return self._constructor(np.nan, index=where, name=self.name)
+            elif is_list:
+                self = cast('DataFrame', self)
+                return self._constructor(np.nan, index=where, columns=self.columns)
+            else:
+                self = cast('DataFrame', self)
+                return self._constructor_sliced(np.nan, index=self.columns, name=where[0])
+        locs = self.index.asof_locs(where, ~nulls._values)
+        mask = locs == -1
+        data = self.take(locs)
+        data.index = where
+        if mask.any():
+            data.loc[mask] = np.nan
+        return data if is_list else data.iloc[-1]
+
+    @doc(klass=_shared_doc_kwargs['klass'])
+    def isna(self) -> Self:
+        return isna(self).__finalize__(self, method='isna')
+
+    @doc(isna, klass=_shared_doc_kwargs['klass'])
+    def isnull(self) -> Self:
+        return isna(self).__finalize__(self, method='isnull')
+
+    @doc(klass=_shared_doc_kwargs['klass'])
+    def notna(self) -> Self:
+        return notna(self).__finalize__(self, method='notna')
+
+    @doc(notna, klass=_shared_doc_kwargs['klass'])
+    def notnull(self) -> Self:
+        return notna(self).__finalize__(self, method='notnull')
+
+    @final
+    def _clip_with_scalar(self, lower, upper, inplace: bool=False):
+        if lower is not None and np.any(isna(lower)) or (upper is not None and np.any(isna(upper))):
+            raise ValueError('Cannot use an NA value as a clip threshold')
+        result = self
+        mask = self.isna()
+        if lower is not None:
+            cond = mask | (self >= lower)
+            result = result.where(cond, lower, inplace=inplace)
+        if upper is not None:
+            cond = mask | (self <= upper)
+            result = self if inplace else result
+            result = result.where(cond, upper, inplace=inplace)
+        return result
+
+    @final
+    def _clip_with_one_bound(self, threshold, method, axis, inplace):
+        if axis is not None:
+            axis = self._get_axis_number(axis)
+        if is_scalar(threshold) and is_number(threshold):
+            if method.__name__ == 'le':
+                return self._clip_with_scalar(None, threshold, inplace=inplace)
+            return self._clip_with_scalar(threshold, None, inplace=inplace)
+        if not isinstance(threshold, ABCSeries) and is_list_like(threshold):
+            if isinstance(self, ABCSeries):
+                threshold = self._constructor(threshold, index=self.index)
+            else:
+                threshold = self._align_for_op(threshold, axis, flex=None)[1]
+        if is_list_like(threshold):
+            fill_value = np.inf if method.__name__ == 'le' else -np.inf
+            threshold_inf = threshold.fillna(fill_value)
+        else:
+            threshold_inf = threshold
+        subset = method(threshold_inf, axis=axis) | isna(self)
+        return self.where(subset, threshold, axis=axis, inplace=inplace)
+
+    @overload
+    def clip(self, lower=..., upper=..., *, axis: Axis | None=..., inplace: Literal[False]=..., **kwargs) -> Self:
+        ...
+
+    @overload
+    def clip(self, lower=..., upper=..., *, axis: Axis | None=..., inplace: Literal[True], **kwargs) -> None:
+        ...
+
+    @overload
+    def clip(self, lower=..., upper=..., *, axis: Axis | None=..., inplace: bool=..., **kwargs) -> Self | None:
+        ...
+
+    @final
+    def clip(self, lower=None, upper=None, *, axis: Axis | None=None, inplace: bool=False, **kwargs) -> Self | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if inplace:
+            if not PYPY:
+                if sys.getrefcount(self) <= REF_COUNT:
+                    warnings.warn(_chained_assignment_method_msg, ChainedAssignmentError, stacklevel=2)
+        axis = nv.validate_clip_with_axis(axis, (), kwargs)
+        if axis is not None:
+            axis = self._get_axis_number(axis)
+        isna_lower = isna(lower)
+        if not is_list_like(lower):
+            if np.any(isna_lower):
+                lower = None
+        elif np.all(isna_lower):
+            lower = None
+        isna_upper = isna(upper)
+        if not is_list_like(upper):
+            if np.any(isna_upper):
+                upper = None
+        elif np.all(isna_upper):
+            upper = None
+        if lower is not None and upper is not None and is_scalar(lower) and is_scalar(upper):
+            (lower, upper) = (min(lower, upper), max(lower, upper))
+        if (lower is None or is_number(lower)) and (upper is None or is_number(upper)):
+            return self._clip_with_scalar(lower, upper, inplace=inplace)
+        result = self
+        if lower is not None:
+            result = result._clip_with_one_bound(lower, method=self.ge, axis=axis, inplace=inplace)
+        if upper is not None:
+            if inplace:
+                result = self
+            result = result._clip_with_one_bound(upper, method=self.le, axis=axis, inplace=inplace)
+        return result
+
+    @final
+    @doc(klass=_shared_doc_kwargs['klass'])
+    def asfreq(self, freq: Frequency, method: FillnaOptions | None=None, how: Literal['start', 'end'] | None=None, normalize: bool=False, fill_value: Hashable | None=None) -> Self:
+        from pandas.core.resample import asfreq
+        return asfreq(self, freq, method=method, how=how, normalize=normalize, fill_value=fill_value)
+
+    @final
+    def at_time(self, time, asof: bool=False, axis: Axis | None=None) -> Self:
+        if axis is None:
+            axis = 0
+        axis = self._get_axis_number(axis)
+        index = self._get_axis(axis)
+        if not isinstance(index, DatetimeIndex):
+            raise TypeError('Index must be DatetimeIndex')
+        indexer = index.indexer_at_time(time, asof=asof)
+        return self.take(indexer, axis=axis)
+
+    @final
+    def between_time(self, start_time, end_time, inclusive: IntervalClosedType='both', axis: Axis | None=None) -> Self:
+        if axis is None:
+            axis = 0
+        axis = self._get_axis_number(axis)
+        index = self._get_axis(axis)
+        if not isinstance(index, DatetimeIndex):
+            raise TypeError('Index must be DatetimeIndex')
+        (left_inclusive, right_inclusive) = validate_inclusive(inclusive)
+        indexer = index.indexer_between_time(start_time, end_time, include_start=left_inclusive, include_end=right_inclusive)
+        return self.take(indexer, axis=axis)
+
+    @final
+    @doc(klass=_shared_doc_kwargs['klass'])
+    def resample(self, rule, closed: Literal['right', 'left'] | None=None, label: Literal['right', 'left'] | None=None, convention: Literal['start', 'end', 's', 'e'] | lib.NoDefault=lib.no_default, on: Level | None=None, level: Level | None=None, origin: str | TimestampConvertibleTypes='start_day', offset: TimedeltaConvertibleTypes | None=None, group_keys: bool=False) -> Resampler:
+        from pandas.core.resample import get_resampler
+        if convention is not lib.no_default:
+            warnings.warn(f"The 'convention' keyword in {type(self).__name__}.resample is deprecated and will be removed in a future version. Explicitly cast PeriodIndex to DatetimeIndex before resampling instead.", FutureWarning, stacklevel=find_stack_level())
+        else:
+            convention = 'start'
+        return get_resampler(cast('Series | DataFrame', self), freq=rule, label=label, closed=closed, convention=convention, key=on, level=level, origin=origin, offset=offset, group_keys=group_keys)
+
+    @final
+    def rank(self, axis: Axis=0, method: Literal['average', 'min', 'max', 'first', 'dense']='average', numeric_only: bool=False, na_option: Literal['keep', 'top', 'bottom']='keep', ascending: bool=True, pct: bool=False) -> Self:
+        axis_int = self._get_axis_number(axis)
+        if na_option not in {'keep', 'top', 'bottom'}:
+            msg = "na_option must be one of 'keep', 'top', or 'bottom'"
+            raise ValueError(msg)
+
+        def ranker(data):
+            if data.ndim == 2:
+                values = data.values
+            else:
+                values = data._values
+            if isinstance(values, ExtensionArray):
+                ranks = values._rank(axis=axis_int, method=method, ascending=ascending, na_option=na_option, pct=pct)
+            else:
+                ranks = algos.rank(values, axis=axis_int, method=method, ascending=ascending, na_option=na_option, pct=pct)
+            ranks_obj = self._constructor(ranks, **data._construct_axes_dict())
+            return ranks_obj.__finalize__(self, method='rank')
+        if numeric_only:
+            if self.ndim == 1 and (not is_numeric_dtype(self.dtype)):
+                raise TypeError('Series.rank does not allow numeric_only=True with non-numeric dtype.')
+            data = self._get_numeric_data()
+        else:
+            data = self
+        return ranker(data)
+
+    @doc(_shared_docs['compare'], klass=_shared_doc_kwargs['klass'])
+    def compare(self, other: Self, align_axis: Axis=1, keep_shape: bool=False, keep_equal: bool=False, result_names: Suffixes=('self', 'other')):
+        if type(self) is not type(other):
+            (cls_self, cls_other) = (type(self).__name__, type(other).__name__)
+            raise TypeError(f"can only compare '{cls_self}' (not '{cls_other}') with '{cls_self}'")
+        mask = ~((self == other) | self.isna() & other.isna())
+        mask.fillna(True, inplace=True)
+        if not keep_equal:
+            self = self.where(mask)
+            other = other.where(mask)
+        if not keep_shape:
+            if isinstance(self, ABCDataFrame):
+                cmask = mask.any()
+                rmask = mask.any(axis=1)
+                self = self.loc[rmask, cmask]
+                other = other.loc[rmask, cmask]
+            else:
+                self = self[mask]
+                other = other[mask]
+        if not isinstance(result_names, tuple):
+            raise TypeError(f"Passing 'result_names' as a {type(result_names)} is not supported. Provide 'result_names' as a tuple instead.")
+        if align_axis in (1, 'columns'):
+            axis = 1
+        else:
+            axis = self._get_axis_number(align_axis)
+        diff = concat([self, other], axis=axis, keys=result_names)
+        if axis >= self.ndim:
+            return diff
+        ax = diff._get_axis(axis)
+        ax_names = np.array(ax.names)
+        ax.names = np.arange(len(ax_names))
+        order = list(range(1, ax.nlevels)) + [0]
+        if isinstance(diff, ABCDataFrame):
+            diff = diff.reorder_levels(order, axis=axis)
+        else:
+            diff = diff.reorder_levels(order)
+        diff._get_axis(axis=axis).names = ax_names[order]
+        indices = np.arange(diff.shape[axis]).reshape([2, diff.shape[axis] // 2]).T.reshape(-1)
+        diff = diff.take(indices, axis=axis)
+        return diff
+
+    @final
+    @doc(klass=_shared_doc_kwargs['klass'], axes_single_arg=_shared_doc_kwargs['axes_single_arg'])
+    def align(self, other: NDFrameT, join: AlignJoin='outer', axis: Axis | None=None, level: Level | None=None, copy: bool | lib.NoDefault=lib.no_default, fill_value: Hashable | None=None) -> tuple[Self, NDFrameT]:
+        self._check_copy_deprecation(copy)
+        _right: DataFrame | Series
+        if axis is not None:
+            axis = self._get_axis_number(axis)
+        if isinstance(other, ABCDataFrame):
+            (left, _right, join_index) = self._align_frame(other, join=join, axis=axis, level=level, fill_value=fill_value)
+        elif isinstance(other, ABCSeries):
+            (left, _right, join_index) = self._align_series(other, join=join, axis=axis, level=level, fill_value=fill_value)
+        else:
+            raise TypeError(f'unsupported type: {type(other)}')
+        right = cast(NDFrameT, _right)
+        if self.ndim == 1 or axis == 0:
+            if isinstance(left.index.dtype, DatetimeTZDtype):
+                if left.index.tz != right.index.tz:
+                    if join_index is not None:
+                        left = left.copy(deep=False)
+                        right = right.copy(deep=False)
+                        left.index = join_index
+                        right.index = join_index
+        left = left.__finalize__(self)
+        right = right.__finalize__(other)
+        return (left, right)
+
+    @final
+    def _align_frame(self, other: DataFrame, join: AlignJoin='outer', axis: Axis | None=None, level=None, fill_value=None) -> tuple[Self, DataFrame, Index | None]:
+        (join_index, join_columns) = (None, None)
+        (ilidx, iridx) = (None, None)
+        (clidx, cridx) = (None, None)
+        is_series = isinstance(self, ABCSeries)
+        if (axis is None or axis == 0) and (not self.index.equals(other.index)):
+            (join_index, ilidx, iridx) = self.index.join(other.index, how=join, level=level, return_indexers=True)
+        if (axis is None or axis == 1) and (not is_series) and (not self.columns.equals(other.columns)):
+            (join_columns, clidx, cridx) = self.columns.join(other.columns, how=join, level=level, return_indexers=True)
+        if is_series:
+            reindexers = {0: [join_index, ilidx]}
+        else:
+            reindexers = {0: [join_index, ilidx], 1: [join_columns, clidx]}
+        left = self._reindex_with_indexers(reindexers, fill_value=fill_value, allow_dups=True)
+        right = other._reindex_with_indexers({0: [join_index, iridx], 1: [join_columns, cridx]}, fill_value=fill_value, allow_dups=True)
+        return (left, right, join_index)
+
+    @final
+    def _align_series(self, other: Series, join: AlignJoin='outer', axis: Axis | None=None, level=None, fill_value=None) -> tuple[Self, Series, Index | None]:
+        is_series = isinstance(self, ABCSeries)
+        if not is_series and axis is None or axis not in [None, 0, 1]:
+            raise ValueError('Must specify axis=0 or 1')
+        if is_series and axis == 1:
+            raise ValueError('cannot align series to a series other than axis 0')
+        if not axis:
+            if self.index.equals(other.index):
+                (join_index, lidx, ridx) = (None, None, None)
+            else:
+                (join_index, lidx, ridx) = self.index.join(other.index, how=join, level=level, return_indexers=True)
+            if is_series:
+                left = self._reindex_indexer(join_index, lidx)
+            elif lidx is None or join_index is None:
+                left = self.copy(deep=False)
+            else:
+                new_mgr = self._mgr.reindex_indexer(join_index, lidx, axis=1)
+                left = self._constructor_from_mgr(new_mgr, axes=new_mgr.axes)
+            right = other._reindex_indexer(join_index, ridx)
+        else:
+            fdata = self._mgr
+            join_index = self.axes[1]
+            (lidx, ridx) = (None, None)
+            if not join_index.equals(other.index):
+                (join_index, lidx, ridx) = join_index.join(other.index, how=join, level=level, return_indexers=True)
+            if lidx is not None:
+                bm_axis = self._get_block_manager_axis(1)
+                fdata = fdata.reindex_indexer(join_index, lidx, axis=bm_axis)
+            left = self._constructor_from_mgr(fdata, axes=fdata.axes)
+            if ridx is None:
+                right = other.copy(deep=False)
+            else:
+                right = other.reindex(join_index, level=level)
+        fill_na = notna(fill_value)
+        if fill_na:
+            left = left.fillna(fill_value)
+            right = right.fillna(fill_value)
+        return (left, right, join_index)
+
+    @overload
+    def _where(self, cond, other=..., *, inplace: Literal[False]=..., axis: Axis | None=..., level=...) -> Self:
+        ...
+
+    @overload
+    def _where(self, cond, other=..., *, inplace: Literal[True], axis: Axis | None=..., level=...) -> None:
+        ...
+
+    @overload
+    def _where(self, cond, other=..., *, inplace: bool, axis: Axis | None=..., level=...) -> Self | None:
+        ...
+
+    @final
+    def _where(self, cond, other=lib.no_default, *, inplace: bool=False, axis: Axis | None=None, level=None) -> Self | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if axis is not None:
+            axis = self._get_axis_number(axis)
+        cond = common.apply_if_callable(cond, self)
+        if isinstance(cond, NDFrame):
+            if cond.ndim == 1 and self.ndim == 2:
+                cond = cond._constructor_expanddim({i: cond for i in range(len(self.columns))}, copy=False)
+                cond.columns = self.columns
+            cond = cond.align(self, join='right')[0]
+        else:
+            if not hasattr(cond, 'shape'):
+                cond = np.asanyarray(cond)
+            if cond.shape != self.shape:
+                raise ValueError('Array conditional must be same shape as self')
+            cond = self._constructor(cond, **self._construct_axes_dict(), copy=False)
+        fill_value = bool(inplace)
+        cond = cond.fillna(fill_value)
+        cond = cond.infer_objects()
+        msg = 'Boolean array expected for the condition, not {dtype}'
+        if not cond.empty:
+            if not isinstance(cond, ABCDataFrame):
+                if not is_bool_dtype(cond):
+                    raise TypeError(msg.format(dtype=cond.dtype))
+            else:
+                for _dt in cond.dtypes:
+                    if not is_bool_dtype(_dt):
+                        raise TypeError(msg.format(dtype=_dt))
+                if cond._mgr.any_extension_types:
+                    cond = cond._constructor(cond.to_numpy(dtype=bool, na_value=fill_value), **cond._construct_axes_dict())
+        else:
+            cond = cond.astype(bool)
+        cond = -cond if inplace else cond
+        cond = cond.reindex(self._info_axis, axis=self._info_axis_number)
+        if isinstance(other, NDFrame):
+            if other.ndim <= self.ndim:
+                other = self.align(other, join='left', axis=axis, level=level, fill_value=None)[1]
+                if axis is None and (not other._indexed_same(self)):
+                    raise InvalidIndexError
+                if other.ndim < self.ndim:
+                    other = other._values
+                    if axis == 0:
+                        other = np.reshape(other, (-1, 1))
+                    elif axis == 1:
+                        other = np.reshape(other, (1, -1))
+                    other = np.broadcast_to(other, self.shape)
+            else:
+                raise NotImplementedError('cannot align with a higher dimensional NDFrame')
+        elif not isinstance(other, (MultiIndex, NDFrame)):
+            other = extract_array(other, extract_numpy=True)
+        if isinstance(other, (np.ndarray, ExtensionArray)):
+            if other.shape != self.shape:
+                if self.ndim != 1:
+                    raise ValueError('other must be the same shape as self when an ndarray')
+            else:
+                other = self._constructor(other, **self._construct_axes_dict(), copy=False)
+        if axis is None:
+            axis = 0
+        if self.ndim == getattr(other, 'ndim', 0):
+            align = True
+        else:
+            align = self._get_axis_number(axis) == 1
+        if inplace:
+            new_data = self._mgr.putmask(mask=cond, new=other, align=align)
+            result = self._constructor_from_mgr(new_data, axes=new_data.axes)
+            return self._update_inplace(result)
+        else:
+            new_data = self._mgr.where(other=other, cond=cond, align=align)
+            result = self._constructor_from_mgr(new_data, axes=new_data.axes)
+            return result.__finalize__(self)
+
+    @overload
+    def where(self, cond, other=..., *, inplace: Literal[False]=..., axis: Axis | None=..., level: Level=...) -> Self:
+        ...
+
+    @overload
+    def where(self, cond, other=..., *, inplace: Literal[True], axis: Axis | None=..., level: Level=...) -> None:
+        ...
+
+    @overload
+    def where(self, cond, other=..., *, inplace: bool=..., axis: Axis | None=..., level: Level=...) -> Self | None:
+        ...
+
+    @final
+    @doc(klass=_shared_doc_kwargs['klass'], cond='True', cond_rev='False', name='where', name_other='mask')
+    def where(self, cond, other=np.nan, *, inplace: bool=False, axis: Axis | None=None, level: Level | None=None) -> Self | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if inplace:
+            if not PYPY:
+                if sys.getrefcount(self) <= REF_COUNT:
+                    warnings.warn(_chained_assignment_method_msg, ChainedAssignmentError, stacklevel=2)
+        other = common.apply_if_callable(other, self)
+        return self._where(cond, other, inplace=inplace, axis=axis, level=level)
+
+    @overload
+    def mask(self, cond, other=..., *, inplace: Literal[False]=..., axis: Axis | None=..., level: Level=...) -> Self:
+        ...
+
+    @overload
+    def mask(self, cond, other=..., *, inplace: Literal[True], axis: Axis | None=..., level: Level=...) -> None:
+        ...
+
+    @overload
+    def mask(self, cond, other=..., *, inplace: bool=..., axis: Axis | None=..., level: Level=...) -> Self | None:
+        ...
+
+    @final
+    @doc(where, klass=_shared_doc_kwargs['klass'], cond='False', cond_rev='True', name='mask', name_other='where')
+    def mask(self, cond, other=lib.no_default, *, inplace: bool=False, axis: Axis | None=None, level: Level | None=None) -> Self | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if inplace:
+            if not PYPY:
+                if sys.getrefcount(self) <= REF_COUNT:
+                    warnings.warn(_chained_assignment_method_msg, ChainedAssignmentError, stacklevel=2)
+        cond = common.apply_if_callable(cond, self)
+        other = common.apply_if_callable(other, self)
+        if not hasattr(cond, '__invert__'):
+            cond = np.array(cond)
+        return self._where(~cond, other=other, inplace=inplace, axis=axis, level=level)
+
+    @doc(klass=_shared_doc_kwargs['klass'])
+    def shift(self, periods: int | Sequence[int]=1, freq=None, axis: Axis=0, fill_value: Hashable=lib.no_default, suffix: str | None=None) -> Self | DataFrame:
+        axis = self._get_axis_number(axis)
+        if freq is not None and fill_value is not lib.no_default:
+            raise ValueError("Passing a 'freq' together with a 'fill_value' is not allowed.")
+        if periods == 0:
+            return self.copy(deep=False)
+        if is_list_like(periods) and isinstance(self, ABCSeries):
+            return self.to_frame().shift(periods=periods, freq=freq, axis=axis, fill_value=fill_value)
+        periods = cast(int, periods)
+        if freq is None:
+            axis = self._get_axis_number(axis)
+            assert axis == 0
+            new_data = self._mgr.shift(periods=periods, fill_value=fill_value)
+            return self._constructor_from_mgr(new_data, axes=new_data.axes).__finalize__(self, method='shift')
+        return self._shift_with_freq(periods, axis, freq)
+
+    @final
+    def _shift_with_freq(self, periods: int, axis: int, freq) -> Self:
+        index = self._get_axis(axis)
+        if freq == 'infer':
+            freq = getattr(index, 'freq', None)
+            if freq is None:
+                freq = getattr(index, 'inferred_freq', None)
+            if freq is None:
+                msg = 'Freq was not set in the index hence cannot be inferred'
+                raise ValueError(msg)
+        elif isinstance(freq, str):
+            is_period = isinstance(index, PeriodIndex)
+            freq = to_offset(freq, is_period=is_period)
+        if isinstance(index, PeriodIndex):
+            orig_freq = to_offset(index.freq)
+            if freq != orig_freq:
+                assert orig_freq is not None
+                raise ValueError(f'Given freq {PeriodDtype(freq)._freqstr} does not match PeriodIndex freq {PeriodDtype(orig_freq)._freqstr}')
+            new_ax: Index = index.shift(periods)
+        else:
+            new_ax = index.shift(periods, freq)
+        result = self.set_axis(new_ax, axis=axis)
+        return result.__finalize__(self, method='shift')
+
+    @final
+    def truncate(self, before=None, after=None, axis: Axis | None=None, copy: bool | lib.NoDefault=lib.no_default) -> Self:
+        self._check_copy_deprecation(copy)
+        if axis is None:
+            axis = 0
+        axis = self._get_axis_number(axis)
+        ax = self._get_axis(axis)
+        if not ax.is_monotonic_increasing and (not ax.is_monotonic_decreasing):
+            raise ValueError('truncate requires a sorted index')
+        if ax._is_all_dates:
+            from pandas.core.tools.datetimes import to_datetime
+            before = to_datetime(before)
+            after = to_datetime(after)
+        if before is not None and after is not None and (before > after):
+            raise ValueError(f'Truncate: {after} must be after {before}')
+        if len(ax) > 1 and ax.is_monotonic_decreasing and (ax.nunique() > 1):
+            (before, after) = (after, before)
+        slicer = [slice(None, None)] * self._AXIS_LEN
+        slicer[axis] = slice(before, after)
+        result = self.loc[tuple(slicer)]
+        if isinstance(ax, MultiIndex):
+            setattr(result, self._get_axis_name(axis), ax.truncate(before, after))
+        result = result.copy(deep=False)
+        return result
+
+    @final
+    @doc(klass=_shared_doc_kwargs['klass'])
+    def tz_convert(self, tz, axis: Axis=0, level=None, copy: bool | lib.NoDefault=lib.no_default) -> Self:
+        self._check_copy_deprecation(copy)
+        axis = self._get_axis_number(axis)
+        ax = self._get_axis(axis)
+
+        def _tz_convert(ax, tz):
+            if not hasattr(ax, 'tz_convert'):
+                if len(ax) > 0:
+                    ax_name = self._get_axis_name(axis)
+                    raise TypeError(f'{ax_name} is not a valid DatetimeIndex or PeriodIndex')
+                ax = DatetimeIndex([], tz=tz)
+            else:
+                ax = ax.tz_convert(tz)
+            return ax
+        if isinstance(ax, MultiIndex):
+            level = ax._get_level_number(level)
+            new_level = _tz_convert(ax.levels[level], tz)
+            ax = ax.set_levels(new_level, level=level)
+        else:
+            if level not in (None, 0, ax.name):
+                raise ValueError(f'The level {level} is not valid')
+            ax = _tz_convert(ax, tz)
+        result = self.copy(deep=False)
+        result = result.set_axis(ax, axis=axis)
+        return result.__finalize__(self, method='tz_convert')
+
+    @final
+    @doc(klass=_shared_doc_kwargs['klass'])
+    def tz_localize(self, tz, axis: Axis=0, level=None, copy: bool | lib.NoDefault=lib.no_default, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise') -> Self:
+        self._check_copy_deprecation(copy)
+        nonexistent_options = ('raise', 'NaT', 'shift_forward', 'shift_backward')
+        if nonexistent not in nonexistent_options and (not isinstance(nonexistent, dt.timedelta)):
+            raise ValueError("The nonexistent argument must be one of 'raise', 'NaT', 'shift_forward', 'shift_backward' or a timedelta object")
+        axis = self._get_axis_number(axis)
+        ax = self._get_axis(axis)
+
+        def _tz_localize(ax, tz, ambiguous, nonexistent):
+            if not hasattr(ax, 'tz_localize'):
+                if len(ax) > 0:
+                    ax_name = self._get_axis_name(axis)
+                    raise TypeError(f'{ax_name} is not a valid DatetimeIndex or PeriodIndex')
+                ax = DatetimeIndex([], tz=tz)
+            else:
+                ax = ax.tz_localize(tz, ambiguous=ambiguous, nonexistent=nonexistent)
+            return ax
+        if isinstance(ax, MultiIndex):
+            level = ax._get_level_number(level)
+            new_level = _tz_localize(ax.levels[level], tz, ambiguous, nonexistent)
+            ax = ax.set_levels(new_level, level=level)
+        else:
+            if level not in (None, 0, ax.name):
+                raise ValueError(f'The level {level} is not valid')
+            ax = _tz_localize(ax, tz, ambiguous, nonexistent)
+        result = self.copy(deep=False)
+        result = result.set_axis(ax, axis=axis)
+        return result.__finalize__(self, method='tz_localize')
+
+    @final
+    def describe(self, percentiles=None, include=None, exclude=None) -> Self:
+        return describe_ndframe(obj=self, include=include, exclude=exclude, percentiles=percentiles).__finalize__(self, method='describe')
+
+    @final
+    def pct_change(self, periods: int=1, fill_method: None=None, freq=None, **kwargs) -> Self:
+        if fill_method is not None:
+            raise ValueError(f'fill_method must be None; got fill_method={fill_method!r}.')
+        axis = self._get_axis_number(kwargs.pop('axis', 'index'))
+        shifted = self.shift(periods=periods, freq=freq, axis=axis, **kwargs)
+        rs = self / shifted - 1
+        if freq is not None:
+            rs = rs.loc[~rs.index.duplicated()]
+            rs = rs.reindex_like(self)
+        return rs.__finalize__(self, method='pct_change')
+
+    @final
+    def _logical_func(self, name: str, func, axis: Axis | None=0, bool_only: bool=False, skipna: bool=True, **kwargs) -> Series | bool:
+        nv.validate_logical_func((), kwargs, fname=name)
+        validate_bool_kwarg(skipna, 'skipna', none_allowed=False)
+        if self.ndim > 1 and axis is None:
+            res = self._logical_func(name, func, axis=0, bool_only=bool_only, skipna=skipna, **kwargs)
+            return res._logical_func(name, func, skipna=skipna, **kwargs)
+        elif axis is None:
+            axis = 0
+        if self.ndim > 1 and axis == 1 and (len(self._mgr.blocks) > 1) and all((block.values.ndim == 2 for block in self._mgr.blocks)) and (not kwargs):
+            obj = self
+            if bool_only:
+                obj = self._get_bool_data()
+            return obj._reduce_axis1(name, func, skipna=skipna)
+        return self._reduce(func, name=name, axis=axis, skipna=skipna, numeric_only=bool_only, filter_type='bool')
+
+    def any(self, *, axis: Axis | None=0, bool_only: bool=False, skipna: bool=True, **kwargs) -> Series | bool:
+        return self._logical_func('any', nanops.nanany, axis, bool_only, skipna, **kwargs)
+
+    def all(self, *, axis: Axis=0, bool_only: bool=False, skipna: bool=True, **kwargs) -> Series | bool:
+        return self._logical_func('all', nanops.nanall, axis, bool_only, skipna, **kwargs)
+
+    @final
+    def _accum_func(self, name: str, func, axis: Axis | None=None, skipna: bool=True, *args, **kwargs):
+        skipna = nv.validate_cum_func_with_skipna(skipna, args, kwargs, name)
+        if axis is None:
+            axis = 0
+        else:
+            axis = self._get_axis_number(axis)
+        if axis == 1:
+            return self.T._accum_func(name, func, *args, axis=0, skipna=skipna, **kwargs).T
+
+        def block_accum_func(blk_values):
+            values = blk_values.T if hasattr(blk_values, 'T') else blk_values
+            result: np.ndarray | ExtensionArray
+            if isinstance(values, ExtensionArray):
+                result = values._accumulate(name, skipna=skipna, **kwargs)
+            else:
+                result = nanops.na_accum_func(values, func, skipna=skipna)
+            result = result.T if hasattr(result, 'T') else result
+            return result
+        result = self._mgr.apply(block_accum_func)
+        return self._constructor_from_mgr(result, axes=result.axes).__finalize__(self, method=name)
+
+    def cummax(self, axis: Axis=0, skipna: bool=True, *args, **kwargs) -> Self:
+        return self._accum_func('cummax', np.maximum.accumulate, axis, skipna, *args, **kwargs)
+
+    def cummin(self, axis: Axis=0, skipna: bool=True, *args, **kwargs) -> Self:
+        return self._accum_func('cummin', np.minimum.accumulate, axis, skipna, *args, **kwargs)
+
+    def cumsum(self, axis: Axis=0, skipna: bool=True, *args, **kwargs) -> Self:
+        return self._accum_func('cumsum', np.cumsum, axis, skipna, *args, **kwargs)
+
+    def cumprod(self, axis: Axis=0, skipna: bool=True, *args, **kwargs) -> Self:
+        return self._accum_func('cumprod', np.cumprod, axis, skipna, *args, **kwargs)
+
+    @final
+    def _stat_function_ddof(self, name: str, func, axis: Axis | None=0, skipna: bool=True, ddof: int=1, numeric_only: bool=False, **kwargs) -> Series | float:
+        nv.validate_stat_ddof_func((), kwargs, fname=name)
+        validate_bool_kwarg(skipna, 'skipna', none_allowed=False)
+        return self._reduce(func, name, axis=axis, numeric_only=numeric_only, skipna=skipna, ddof=ddof)
+
+    def sem(self, *, axis: Axis | None=0, skipna: bool=True, ddof: int=1, numeric_only: bool=False, **kwargs) -> Series | float:
+        return self._stat_function_ddof('sem', nanops.nansem, axis, skipna, ddof, numeric_only, **kwargs)
+
+    def var(self, *, axis: Axis | None=0, skipna: bool=True, ddof: int=1, numeric_only: bool=False, **kwargs) -> Series | float:
+        return self._stat_function_ddof('var', nanops.nanvar, axis, skipna, ddof, numeric_only, **kwargs)
+
+    def std(self, *, axis: Axis | None=0, skipna: bool=True, ddof: int=1, numeric_only: bool=False, **kwargs) -> Series | float:
+        return self._stat_function_ddof('std', nanops.nanstd, axis, skipna, ddof, numeric_only, **kwargs)
+
+    @final
+    def _stat_function(self, name: str, func, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs):
+        assert name in ['median', 'mean', 'min', 'max', 'kurt', 'skew'], name
+        nv.validate_func(name, (), kwargs)
+        validate_bool_kwarg(skipna, 'skipna', none_allowed=False)
+        return self._reduce(func, name=name, axis=axis, skipna=skipna, numeric_only=numeric_only)
+
+    def min(self, *, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs):
+        return self._stat_function('min', nanops.nanmin, axis, skipna, numeric_only, **kwargs)
+
+    def max(self, *, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs):
+        return self._stat_function('max', nanops.nanmax, axis, skipna, numeric_only, **kwargs)
+
+    def mean(self, *, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Series | float:
+        return self._stat_function('mean', nanops.nanmean, axis, skipna, numeric_only, **kwargs)
+
+    def median(self, *, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Series | float:
+        return self._stat_function('median', nanops.nanmedian, axis, skipna, numeric_only, **kwargs)
+
+    def skew(self, *, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Series | float:
+        return self._stat_function('skew', nanops.nanskew, axis, skipna, numeric_only, **kwargs)
+
+    def kurt(self, *, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Series | float:
+        return self._stat_function('kurt', nanops.nankurt, axis, skipna, numeric_only, **kwargs)
+    kurtosis = kurt
+
+    @final
+    def _min_count_stat_function(self, name: str, func, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, min_count: int=0, **kwargs):
+        assert name in ['sum', 'prod'], name
+        nv.validate_func(name, (), kwargs)
+        validate_bool_kwarg(skipna, 'skipna', none_allowed=False)
+        return self._reduce(func, name=name, axis=axis, skipna=skipna, numeric_only=numeric_only, min_count=min_count)
+
+    def sum(self, *, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, min_count: int=0, **kwargs):
+        return self._min_count_stat_function('sum', nanops.nansum, axis, skipna, numeric_only, min_count, **kwargs)
+
+    def prod(self, *, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, min_count: int=0, **kwargs):
+        return self._min_count_stat_function('prod', nanops.nanprod, axis, skipna, numeric_only, min_count, **kwargs)
+    product = prod
+
+    @final
+    @doc(Rolling)
+    def rolling(self, window: int | dt.timedelta | str | BaseOffset | BaseIndexer, min_periods: int | None=None, center: bool=False, win_type: str | None=None, on: str | None=None, closed: IntervalClosedType | None=None, step: int | None=None, method: str='single') -> Window | Rolling:
+        if win_type is not None:
+            return Window(self, window=window, min_periods=min_periods, center=center, win_type=win_type, on=on, closed=closed, step=step, method=method)
+        return Rolling(self, window=window, min_periods=min_periods, center=center, win_type=win_type, on=on, closed=closed, step=step, method=method)
+
+    @final
+    @doc(Expanding)
+    def expanding(self, min_periods: int=1, method: Literal['single', 'table']='single') -> Expanding:
+        return Expanding(self, min_periods=min_periods, method=method)
+
+    @final
+    @doc(ExponentialMovingWindow)
+    def ewm(self, com: float | None=None, span: float | None=None, halflife: float | TimedeltaConvertibleTypes | None=None, alpha: float | None=None, min_periods: int | None=0, adjust: bool=True, ignore_na: bool=False, times: np.ndarray | DataFrame | Series | None=None, method: Literal['single', 'table']='single') -> ExponentialMovingWindow:
+        return ExponentialMovingWindow(self, com=com, span=span, halflife=halflife, alpha=alpha, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na, times=times, method=method)
+
+    @final
+    def _inplace_method(self, other, op) -> Self:
+        result = op(self, other)
+        self._update_inplace(result.reindex_like(self))
+        return self
+
+    @final
+    def __iadd__(self, other) -> Self:
+        return self._inplace_method(other, type(self).__add__)
+
+    @final
+    def __isub__(self, other) -> Self:
+        return self._inplace_method(other, type(self).__sub__)
+
+    @final
+    def __imul__(self, other) -> Self:
+        return self._inplace_method(other, type(self).__mul__)
+
+    @final
+    def __itruediv__(self, other) -> Self:
+        return self._inplace_method(other, type(self).__truediv__)
+
+    @final
+    def __ifloordiv__(self, other) -> Self:
+        return self._inplace_method(other, type(self).__floordiv__)
+
+    @final
+    def __imod__(self, other) -> Self:
+        return self._inplace_method(other, type(self).__mod__)
+
+    @final
+    def __ipow__(self, other) -> Self:
+        return self._inplace_method(other, type(self).__pow__)
+
+    @final
+    def __iand__(self, other) -> Self:
+        return self._inplace_method(other, type(self).__and__)
+
+    @final
+    def __ior__(self, other) -> Self:
+        return self._inplace_method(other, type(self).__or__)
+
+    @final
+    def __ixor__(self, other) -> Self:
+        return self._inplace_method(other, type(self).__xor__)
+
+    @final
+    def _find_valid_index(self, *, how: str) -> Hashable:
+        is_valid = self.notna().values
+        idxpos = find_valid_index(how=how, is_valid=is_valid)
+        if idxpos is None:
+            return None
+        return self.index[idxpos]
+
+    @final
+    @doc(position='first', klass=_shared_doc_kwargs['klass'])
+    def first_valid_index(self) -> Hashable:
+        return self._find_valid_index(how='first')
+
+    @final
+    @doc(first_valid_index, position='last', klass=_shared_doc_kwargs['klass'])
+    def last_valid_index(self) -> Hashable:
+        return self._find_valid_index(how='last')
+_num_doc = '\n{desc}\n\nParameters\n----------\naxis : {axis_descr}\n    Axis for the function to be applied on.\n    For `Series` this parameter is unused and defaults to 0.\n\n    For DataFrames, specifying ``axis=None`` will apply the aggregation\n    across both axes.\n\n    .. versionadded:: 2.0.0\n\nskipna : bool, default True\n    Exclude NA/null values when computing the result.\nnumeric_only : bool, default False\n    Include only float, int, boolean columns.\n\n{min_count}**kwargs\n    Additional keyword arguments to be passed to the function.\n\nReturns\n-------\n{name1} or scalar\n    Value containing the calculation referenced in the description.{see_also}{examples}\n'
+_sum_prod_doc = '\n{desc}\n\nParameters\n----------\naxis : {axis_descr}\n    Axis for the function to be applied on.\n    For `Series` this parameter is unused and defaults to 0.\n\n    .. warning::\n\n        The behavior of DataFrame.{name} with ``axis=None`` is deprecated,\n        in a future version this will reduce over both axes and return a scalar\n        To retain the old behavior, pass axis=0 (or do not pass axis).\n\n    .. versionadded:: 2.0.0\n\nskipna : bool, default True\n    Exclude NA/null values when computing the result.\nnumeric_only : bool, default False\n    Include only float, int, boolean columns. Not implemented for Series.\n\n{min_count}**kwargs\n    Additional keyword arguments to be passed to the function.\n\nReturns\n-------\n{name1} or scalar\n    Value containing the calculation referenced in the description.{see_also}{examples}\n'
+_num_ddof_doc = '\n{desc}\n\nParameters\n----------\naxis : {axis_descr}\n    For `Series` this parameter is unused and defaults to 0.\n\n    .. warning::\n\n        The behavior of DataFrame.{name} with ``axis=None`` is deprecated,\n        in a future version this will reduce over both axes and return a scalar\n        To retain the old behavior, pass axis=0 (or do not pass axis).\n\nskipna : bool, default True\n    Exclude NA/null values. If an entire row/column is NA, the result\n    will be NA.\nddof : int, default 1\n    Delta Degrees of Freedom. The divisor used in calculations is N - ddof,\n    where N represents the number of elements.\nnumeric_only : bool, default False\n    Include only float, int, boolean columns. Not implemented for Series.\n**kwargs :\n    Additional keywords have no effect but might be accepted\n    for compatibility with NumPy.\n\nReturns\n-------\n{name1} or {name2} (if level specified)\n    {return_desc}\n\nSee Also\n--------\n{see_also}{notes}{examples}\n'
+_sem_see_also = 'scipy.stats.sem : Compute standard error of the mean.\n{name2}.std : Return sample standard deviation over requested axis.\n{name2}.var : Return unbiased variance over requested axis.\n{name2}.mean : Return the mean of the values over the requested axis.\n{name2}.median : Return the median of the values over the requested axis.\n{name2}.mode : Return the mode(s) of the Series.'
+_sem_return_desc = 'Unbiased standard error of the mean over requested axis.'
+_std_see_also = 'numpy.std : Compute the standard deviation along the specified axis.\n{name2}.var : Return unbiased variance over requested axis.\n{name2}.sem : Return unbiased standard error of the mean over requested axis.\n{name2}.mean : Return the mean of the values over the requested axis.\n{name2}.median : Return the median of the values over the requested axis.\n{name2}.mode : Return the mode(s) of the Series.'
+_std_return_desc = 'Standard deviation over requested axis.'
+_std_notes = '\n\nNotes\n-----\nTo have the same behaviour as `numpy.std`, use `ddof=0` (instead of the\ndefault `ddof=1`)'
+_std_examples = "\n\nExamples\n--------\n>>> df = pd.DataFrame({'person_id': [0, 1, 2, 3],\n...                    'age': [21, 25, 62, 43],\n...                    'height': [1.61, 1.87, 1.49, 2.01]}\n...                   ).set_index('person_id')\n>>> df\n           age  height\nperson_id\n0           21    1.61\n1           25    1.87\n2           62    1.49\n3           43    2.01\n\nThe standard deviation of the columns can be found as follows:\n\n>>> df.std()\nage       18.786076\nheight     0.237417\ndtype: float64\n\nAlternatively, `ddof=0` can be set to normalize by N instead of N-1:\n\n>>> df.std(ddof=0)\nage       16.269219\nheight     0.205609\ndtype: float64"
+_var_examples = "\n\nExamples\n--------\n>>> df = pd.DataFrame({'person_id': [0, 1, 2, 3],\n...                    'age': [21, 25, 62, 43],\n...                    'height': [1.61, 1.87, 1.49, 2.01]}\n...                   ).set_index('person_id')\n>>> df\n           age  height\nperson_id\n0           21    1.61\n1           25    1.87\n2           62    1.49\n3           43    2.01\n\n>>> df.var()\nage       352.916667\nheight      0.056367\ndtype: float64\n\nAlternatively, ``ddof=0`` can be set to normalize by N instead of N-1:\n\n>>> df.var(ddof=0)\nage       264.687500\nheight      0.042275\ndtype: float64"
+_bool_doc = "\n{desc}\n\nParameters\n----------\naxis : {{0 or 'index', 1 or 'columns', None}}, default 0\n    Indicate which axis or axes should be reduced. For `Series` this parameter\n    is unused and defaults to 0.\n\n    * 0 / 'index' : reduce the index, return a Series whose index is the\n      original column labels.\n    * 1 / 'columns' : reduce the columns, return a Series whose index is the\n      original index.\n    * None : reduce all axes, return a scalar.\n\nbool_only : bool, default False\n    Include only boolean columns. Not implemented for Series.\nskipna : bool, default True\n    Exclude NA/null values. If the entire row/column is NA and skipna is\n    True, then the result will be {empty_value}, as for an empty row/column.\n    If skipna is False, then NA are treated as True, because these are not\n    equal to zero.\n**kwargs : any, default None\n    Additional keywords have no effect but might be accepted for\n    compatibility with NumPy.\n\nReturns\n-------\n{name2} or {name1}\n    If axis=None, then a scalar boolean is returned.\n    Otherwise a Series is returned with index matching the index argument.\n\n{see_also}\n{examples}"
+_all_desc = 'Return whether all elements are True, potentially over an axis.\n\nReturns True unless there at least one element within a series or\nalong a Dataframe axis that is False or equivalent (e.g. zero or\nempty).'
+_all_examples = 'Examples\n--------\n**Series**\n\n>>> pd.Series([True, True]).all()\nTrue\n>>> pd.Series([True, False]).all()\nFalse\n>>> pd.Series([], dtype="float64").all()\nTrue\n>>> pd.Series([np.nan]).all()\nTrue\n>>> pd.Series([np.nan]).all(skipna=False)\nTrue\n\n**DataFrames**\n\nCreate a DataFrame from a dictionary.\n\n>>> df = pd.DataFrame({\'col1\': [True, True], \'col2\': [True, False]})\n>>> df\n   col1   col2\n0  True   True\n1  True  False\n\nDefault behaviour checks if values in each column all return True.\n\n>>> df.all()\ncol1     True\ncol2    False\ndtype: bool\n\nSpecify ``axis=\'columns\'`` to check if values in each row all return True.\n\n>>> df.all(axis=\'columns\')\n0     True\n1    False\ndtype: bool\n\nOr ``axis=None`` for whether every value is True.\n\n>>> df.all(axis=None)\nFalse\n'
+_all_see_also = 'See Also\n--------\nSeries.all : Return True if all elements are True.\nDataFrame.any : Return True if one (or more) elements are True.\n'
+_cnum_pd_doc = "\nReturn cumulative {desc} over a DataFrame or Series axis.\n\nReturns a DataFrame or Series of the same size containing the cumulative\n{desc}.\n\nParameters\n----------\naxis : {{0 or 'index', 1 or 'columns'}}, default 0\n    The index or the name of the axis. 0 is equivalent to None or 'index'.\n    For `Series` this parameter is unused and defaults to 0.\nskipna : bool, default True\n    Exclude NA/null values. If an entire row/column is NA, the result\n    will be NA.\nnumeric_only : bool, default False\n    Include only float, int, boolean columns.\n*args, **kwargs\n    Additional keywords have no effect but might be accepted for\n    compatibility with NumPy.\n\nReturns\n-------\n{name1} or {name2}\n    Return cumulative {desc} of {name1} or {name2}.\n\nSee Also\n--------\ncore.window.expanding.Expanding.{accum_func_name} : Similar functionality\n    but ignores ``NaN`` values.\n{name2}.{accum_func_name} : Return the {desc} over\n    {name2} axis.\n{name2}.cummax : Return cumulative maximum over {name2} axis.\n{name2}.cummin : Return cumulative minimum over {name2} axis.\n{name2}.cumsum : Return cumulative sum over {name2} axis.\n{name2}.cumprod : Return cumulative product over {name2} axis.\n\n{examples}"
+_cnum_series_doc = "\nReturn cumulative {desc} over a DataFrame or Series axis.\n\nReturns a DataFrame or Series of the same size containing the cumulative\n{desc}.\n\nParameters\n----------\naxis : {{0 or 'index', 1 or 'columns'}}, default 0\n    The index or the name of the axis. 0 is equivalent to None or 'index'.\n    For `Series` this parameter is unused and defaults to 0.\nskipna : bool, default True\n    Exclude NA/null values. If an entire row/column is NA, the result\n    will be NA.\n*args, **kwargs\n    Additional keywords have no effect but might be accepted for\n    compatibility with NumPy.\n\nReturns\n-------\n{name1} or {name2}\n    Return cumulative {desc} of {name1} or {name2}.\n\nSee Also\n--------\ncore.window.expanding.Expanding.{accum_func_name} : Similar functionality\n    but ignores ``NaN`` values.\n{name2}.{accum_func_name} : Return the {desc} over\n    {name2} axis.\n{name2}.cummax : Return cumulative maximum over {name2} axis.\n{name2}.cummin : Return cumulative minimum over {name2} axis.\n{name2}.cumsum : Return cumulative sum over {name2} axis.\n{name2}.cumprod : Return cumulative product over {name2} axis.\n\n{examples}"
+_cummin_examples = "Examples\n--------\n**Series**\n\n>>> s = pd.Series([2, np.nan, 5, -1, 0])\n>>> s\n0    2.0\n1    NaN\n2    5.0\n3   -1.0\n4    0.0\ndtype: float64\n\nBy default, NA values are ignored.\n\n>>> s.cummin()\n0    2.0\n1    NaN\n2    2.0\n3   -1.0\n4   -1.0\ndtype: float64\n\nTo include NA values in the operation, use ``skipna=False``\n\n>>> s.cummin(skipna=False)\n0    2.0\n1    NaN\n2    NaN\n3    NaN\n4    NaN\ndtype: float64\n\n**DataFrame**\n\n>>> df = pd.DataFrame([[2.0, 1.0],\n...                    [3.0, np.nan],\n...                    [1.0, 0.0]],\n...                   columns=list('AB'))\n>>> df\n     A    B\n0  2.0  1.0\n1  3.0  NaN\n2  1.0  0.0\n\nBy default, iterates over rows and finds the minimum\nin each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n\n>>> df.cummin()\n     A    B\n0  2.0  1.0\n1  2.0  NaN\n2  1.0  0.0\n\nTo iterate over columns and find the minimum in each row,\nuse ``axis=1``\n\n>>> df.cummin(axis=1)\n     A    B\n0  2.0  1.0\n1  3.0  NaN\n2  1.0  0.0\n"
+_cumsum_examples = "Examples\n--------\n**Series**\n\n>>> s = pd.Series([2, np.nan, 5, -1, 0])\n>>> s\n0    2.0\n1    NaN\n2    5.0\n3   -1.0\n4    0.0\ndtype: float64\n\nBy default, NA values are ignored.\n\n>>> s.cumsum()\n0    2.0\n1    NaN\n2    7.0\n3    6.0\n4    6.0\ndtype: float64\n\nTo include NA values in the operation, use ``skipna=False``\n\n>>> s.cumsum(skipna=False)\n0    2.0\n1    NaN\n2    NaN\n3    NaN\n4    NaN\ndtype: float64\n\n**DataFrame**\n\n>>> df = pd.DataFrame([[2.0, 1.0],\n...                    [3.0, np.nan],\n...                    [1.0, 0.0]],\n...                   columns=list('AB'))\n>>> df\n     A    B\n0  2.0  1.0\n1  3.0  NaN\n2  1.0  0.0\n\nBy default, iterates over rows and finds the sum\nin each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n\n>>> df.cumsum()\n     A    B\n0  2.0  1.0\n1  5.0  NaN\n2  6.0  1.0\n\nTo iterate over columns and find the sum in each row,\nuse ``axis=1``\n\n>>> df.cumsum(axis=1)\n     A    B\n0  2.0  3.0\n1  3.0  NaN\n2  1.0  1.0\n"
+_cumprod_examples = "Examples\n--------\n**Series**\n\n>>> s = pd.Series([2, np.nan, 5, -1, 0])\n>>> s\n0    2.0\n1    NaN\n2    5.0\n3   -1.0\n4    0.0\ndtype: float64\n\nBy default, NA values are ignored.\n\n>>> s.cumprod()\n0     2.0\n1     NaN\n2    10.0\n3   -10.0\n4    -0.0\ndtype: float64\n\nTo include NA values in the operation, use ``skipna=False``\n\n>>> s.cumprod(skipna=False)\n0    2.0\n1    NaN\n2    NaN\n3    NaN\n4    NaN\ndtype: float64\n\n**DataFrame**\n\n>>> df = pd.DataFrame([[2.0, 1.0],\n...                    [3.0, np.nan],\n...                    [1.0, 0.0]],\n...                   columns=list('AB'))\n>>> df\n     A    B\n0  2.0  1.0\n1  3.0  NaN\n2  1.0  0.0\n\nBy default, iterates over rows and finds the product\nin each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n\n>>> df.cumprod()\n     A    B\n0  2.0  1.0\n1  6.0  NaN\n2  6.0  0.0\n\nTo iterate over columns and find the product in each row,\nuse ``axis=1``\n\n>>> df.cumprod(axis=1)\n     A    B\n0  2.0  2.0\n1  3.0  NaN\n2  1.0  0.0\n"
+_cummax_examples = "Examples\n--------\n**Series**\n\n>>> s = pd.Series([2, np.nan, 5, -1, 0])\n>>> s\n0    2.0\n1    NaN\n2    5.0\n3   -1.0\n4    0.0\ndtype: float64\n\nBy default, NA values are ignored.\n\n>>> s.cummax()\n0    2.0\n1    NaN\n2    5.0\n3    5.0\n4    5.0\ndtype: float64\n\nTo include NA values in the operation, use ``skipna=False``\n\n>>> s.cummax(skipna=False)\n0    2.0\n1    NaN\n2    NaN\n3    NaN\n4    NaN\ndtype: float64\n\n**DataFrame**\n\n>>> df = pd.DataFrame([[2.0, 1.0],\n...                    [3.0, np.nan],\n...                    [1.0, 0.0]],\n...                   columns=list('AB'))\n>>> df\n     A    B\n0  2.0  1.0\n1  3.0  NaN\n2  1.0  0.0\n\nBy default, iterates over rows and finds the maximum\nin each column. This is equivalent to ``axis=None`` or ``axis='index'``.\n\n>>> df.cummax()\n     A    B\n0  2.0  1.0\n1  3.0  NaN\n2  3.0  1.0\n\nTo iterate over columns and find the maximum in each row,\nuse ``axis=1``\n\n>>> df.cummax(axis=1)\n     A    B\n0  2.0  2.0\n1  3.0  NaN\n2  1.0  1.0\n"
+_any_see_also = 'See Also\n--------\nnumpy.any : Numpy version of this method.\nSeries.any : Return whether any element is True.\nSeries.all : Return whether all elements are True.\nDataFrame.any : Return whether any element is True over requested axis.\nDataFrame.all : Return whether all elements are True over requested axis.\n'
+_any_desc = 'Return whether any element is True, potentially over an axis.\n\nReturns False unless there is at least one element within a series or\nalong a Dataframe axis that is True or equivalent (e.g. non-zero or\nnon-empty).'
+_any_examples = 'Examples\n--------\n**Series**\n\nFor Series input, the output is a scalar indicating whether any element\nis True.\n\n>>> pd.Series([False, False]).any()\nFalse\n>>> pd.Series([True, False]).any()\nTrue\n>>> pd.Series([], dtype="float64").any()\nFalse\n>>> pd.Series([np.nan]).any()\nFalse\n>>> pd.Series([np.nan]).any(skipna=False)\nTrue\n\n**DataFrame**\n\nWhether each column contains at least one True element (the default).\n\n>>> df = pd.DataFrame({"A": [1, 2], "B": [0, 2], "C": [0, 0]})\n>>> df\n   A  B  C\n0  1  0  0\n1  2  2  0\n\n>>> df.any()\nA     True\nB     True\nC    False\ndtype: bool\n\nAggregating over the columns.\n\n>>> df = pd.DataFrame({"A": [True, False], "B": [1, 2]})\n>>> df\n       A  B\n0   True  1\n1  False  2\n\n>>> df.any(axis=\'columns\')\n0    True\n1    True\ndtype: bool\n\n>>> df = pd.DataFrame({"A": [True, False], "B": [1, 0]})\n>>> df\n       A  B\n0   True  1\n1  False  0\n\n>>> df.any(axis=\'columns\')\n0    True\n1    False\ndtype: bool\n\nAggregating over the entire DataFrame with ``axis=None``.\n\n>>> df.any(axis=None)\nTrue\n\n`any` for an empty DataFrame is an empty Series.\n\n>>> pd.DataFrame([]).any()\nSeries([], dtype: bool)\n'
+_shared_docs['stat_func_example'] = "\n\nExamples\n--------\n>>> idx = pd.MultiIndex.from_arrays([\n...     ['warm', 'warm', 'cold', 'cold'],\n...     ['dog', 'falcon', 'fish', 'spider']],\n...     names=['blooded', 'animal'])\n>>> s = pd.Series([4, 2, 0, 8], name='legs', index=idx)\n>>> s\nblooded  animal\nwarm     dog       4\n         falcon    2\ncold     fish      0\n         spider    8\nName: legs, dtype: int64\n\n>>> s.{stat_func}()\n{default_output}"
+_sum_examples = _shared_docs['stat_func_example'].format(stat_func='sum', verb='Sum', default_output=14, level_output_0=6, level_output_1=8)
+_sum_examples += '\n\nBy default, the sum of an empty or all-NA Series is ``0``.\n\n>>> pd.Series([], dtype="float64").sum()  # min_count=0 is the default\n0.0\n\nThis can be controlled with the ``min_count`` parameter. For example, if\nyou\'d like the sum of an empty series to be NaN, pass ``min_count=1``.\n\n>>> pd.Series([], dtype="float64").sum(min_count=1)\nnan\n\nThanks to the ``skipna`` parameter, ``min_count`` handles all-NA and\nempty series identically.\n\n>>> pd.Series([np.nan]).sum()\n0.0\n\n>>> pd.Series([np.nan]).sum(min_count=1)\nnan'
+_max_examples: str = _shared_docs['stat_func_example'].format(stat_func='max', verb='Max', default_output=8, level_output_0=4, level_output_1=8)
+_min_examples: str = _shared_docs['stat_func_example'].format(stat_func='min', verb='Min', default_output=0, level_output_0=2, level_output_1=0)
+_skew_see_also = '\n\nSee Also\n--------\nSeries.skew : Return unbiased skew over requested axis.\nSeries.var : Return unbiased variance over requested axis.\nSeries.std : Return unbiased standard deviation over requested axis.'
+_stat_func_see_also = '\n\nSee Also\n--------\nSeries.sum : Return the sum.\nSeries.min : Return the minimum.\nSeries.max : Return the maximum.\nSeries.idxmin : Return the index of the minimum.\nSeries.idxmax : Return the index of the maximum.\nDataFrame.sum : Return the sum over the requested axis.\nDataFrame.min : Return the minimum over the requested axis.\nDataFrame.max : Return the maximum over the requested axis.\nDataFrame.idxmin : Return the index of the minimum over the requested axis.\nDataFrame.idxmax : Return the index of the maximum over the requested axis.'
+_prod_examples = '\n\nExamples\n--------\nBy default, the product of an empty or all-NA Series is ``1``\n\n>>> pd.Series([], dtype="float64").prod()\n1.0\n\nThis can be controlled with the ``min_count`` parameter\n\n>>> pd.Series([], dtype="float64").prod(min_count=1)\nnan\n\nThanks to the ``skipna`` parameter, ``min_count`` handles all-NA and\nempty series identically.\n\n>>> pd.Series([np.nan]).prod()\n1.0\n\n>>> pd.Series([np.nan]).prod(min_count=1)\nnan'
+_min_count_stub = 'min_count : int, default 0\n    The required number of valid values to perform the operation. If fewer than\n    ``min_count`` non-NA values are present the result will be NA.\n'
+
+def make_doc(name: str, ndim: int) -> str:
+    if ndim == 1:
+        name1 = 'scalar'
+        name2 = 'Series'
+        axis_descr = '{index (0)}'
+    else:
+        name1 = 'Series'
+        name2 = 'DataFrame'
+        axis_descr = '{index (0), columns (1)}'
+    if name == 'any':
+        base_doc = _bool_doc
+        desc = _any_desc
+        see_also = _any_see_also
+        examples = _any_examples
+        kwargs = {'empty_value': 'False'}
+    elif name == 'all':
+        base_doc = _bool_doc
+        desc = _all_desc
+        see_also = _all_see_also
+        examples = _all_examples
+        kwargs = {'empty_value': 'True'}
+    elif name == 'min':
+        base_doc = _num_doc
+        desc = 'Return the minimum of the values over the requested axis.\n\nIf you want the *index* of the minimum, use ``idxmin``. This is the equivalent of the ``numpy.ndarray`` method ``argmin``.'
+        see_also = _stat_func_see_also
+        examples = _min_examples
+        kwargs = {'min_count': ''}
+    elif name == 'max':
+        base_doc = _num_doc
+        desc = 'Return the maximum of the values over the requested axis.\n\nIf you want the *index* of the maximum, use ``idxmax``. This is the equivalent of the ``numpy.ndarray`` method ``argmax``.'
+        see_also = _stat_func_see_also
+        examples = _max_examples
+        kwargs = {'min_count': ''}
+    elif name == 'sum':
+        base_doc = _sum_prod_doc
+        desc = 'Return the sum of the values over the requested axis.\n\nThis is equivalent to the method ``numpy.sum``.'
+        see_also = _stat_func_see_also
+        examples = _sum_examples
+        kwargs = {'min_count': _min_count_stub}
+    elif name == 'prod':
+        base_doc = _sum_prod_doc
+        desc = 'Return the product of the values over the requested axis.'
+        see_also = _stat_func_see_also
+        examples = _prod_examples
+        kwargs = {'min_count': _min_count_stub}
+    elif name == 'median':
+        base_doc = _num_doc
+        desc = 'Return the median of the values over the requested axis.'
+        see_also = _stat_func_see_also
+        examples = "\n\n            Examples\n            --------\n            >>> s = pd.Series([1, 2, 3])\n            >>> s.median()\n            2.0\n\n            With a DataFrame\n\n            >>> df = pd.DataFrame({'a': [1, 2], 'b': [2, 3]}, index=['tiger', 'zebra'])\n            >>> df\n                   a   b\n            tiger  1   2\n            zebra  2   3\n            >>> df.median()\n            a   1.5\n            b   2.5\n            dtype: float64\n\n            Using axis=1\n\n            >>> df.median(axis=1)\n            tiger   1.5\n            zebra   2.5\n            dtype: float64\n\n            In this case, `numeric_only` should be set to `True`\n            to avoid getting an error.\n\n            >>> df = pd.DataFrame({'a': [1, 2], 'b': ['T', 'Z']},\n            ...                   index=['tiger', 'zebra'])\n            >>> df.median(numeric_only=True)\n            a   1.5\n            dtype: float64"
+        kwargs = {'min_count': ''}
+    elif name == 'mean':
+        base_doc = _num_doc
+        desc = 'Return the mean of the values over the requested axis.'
+        see_also = _stat_func_see_also
+        examples = "\n\n            Examples\n            --------\n            >>> s = pd.Series([1, 2, 3])\n            >>> s.mean()\n            2.0\n\n            With a DataFrame\n\n            >>> df = pd.DataFrame({'a': [1, 2], 'b': [2, 3]}, index=['tiger', 'zebra'])\n            >>> df\n                   a   b\n            tiger  1   2\n            zebra  2   3\n            >>> df.mean()\n            a   1.5\n            b   2.5\n            dtype: float64\n\n            Using axis=1\n\n            >>> df.mean(axis=1)\n            tiger   1.5\n            zebra   2.5\n            dtype: float64\n\n            In this case, `numeric_only` should be set to `True` to avoid\n            getting an error.\n\n            >>> df = pd.DataFrame({'a': [1, 2], 'b': ['T', 'Z']},\n            ...                   index=['tiger', 'zebra'])\n            >>> df.mean(numeric_only=True)\n            a   1.5\n            dtype: float64"
+        kwargs = {'min_count': ''}
+    elif name == 'var':
+        base_doc = _num_ddof_doc
+        desc = 'Return unbiased variance over requested axis.\n\nNormalized by N-1 by default. This can be changed using the ddof argument.'
+        examples = _var_examples
+        see_also = ''
+        kwargs = {'notes': ''}
+    elif name == 'std':
+        base_doc = _num_ddof_doc
+        desc = 'Return sample standard deviation over requested axis.\n\nNormalized by N-1 by default. This can be changed using the ddof argument.'
+        examples = _std_examples
+        see_also = _std_see_also.format(name2=name2)
+        kwargs = {'notes': '', 'return_desc': _std_return_desc}
+    elif name == 'sem':
+        base_doc = _num_ddof_doc
+        desc = 'Return unbiased standard error of the mean over requested axis.\n\nNormalized by N-1 by default. This can be changed using the ddof argument'
+        examples = "\n\n            Examples\n            --------\n            >>> s = pd.Series([1, 2, 3])\n            >>> s.sem().round(6)\n            0.57735\n\n            With a DataFrame\n\n            >>> df = pd.DataFrame({'a': [1, 2], 'b': [2, 3]}, index=['tiger', 'zebra'])\n            >>> df\n                   a   b\n            tiger  1   2\n            zebra  2   3\n            >>> df.sem()\n            a   0.5\n            b   0.5\n            dtype: float64\n\n            Using axis=1\n\n            >>> df.sem(axis=1)\n            tiger   0.5\n            zebra   0.5\n            dtype: float64\n\n            In this case, `numeric_only` should be set to `True`\n            to avoid getting an error.\n\n            >>> df = pd.DataFrame({'a': [1, 2], 'b': ['T', 'Z']},\n            ...                   index=['tiger', 'zebra'])\n            >>> df.sem(numeric_only=True)\n            a   0.5\n            dtype: float64"
+        see_also = _sem_see_also.format(name2=name2)
+        kwargs = {'notes': '', 'return_desc': _sem_return_desc}
+    elif name == 'skew':
+        base_doc = _num_doc
+        desc = 'Return unbiased skew over requested axis.\n\nNormalized by N-1.'
+        see_also = _skew_see_also
+        examples = "\n\n            Examples\n            --------\n            >>> s = pd.Series([1, 2, 3])\n            >>> s.skew()\n            0.0\n\n            With a DataFrame\n\n            >>> df = pd.DataFrame({'a': [1, 2, 3], 'b': [2, 3, 4], 'c': [1, 3, 5]},\n            ...                   index=['tiger', 'zebra', 'cow'])\n            >>> df\n                    a   b   c\n            tiger   1   2   1\n            zebra   2   3   3\n            cow     3   4   5\n            >>> df.skew()\n            a   0.0\n            b   0.0\n            c   0.0\n            dtype: float64\n\n            Using axis=1\n\n            >>> df.skew(axis=1)\n            tiger   1.732051\n            zebra  -1.732051\n            cow     0.000000\n            dtype: float64\n\n            In this case, `numeric_only` should be set to `True` to avoid\n            getting an error.\n\n            >>> df = pd.DataFrame({'a': [1, 2, 3], 'b': ['T', 'Z', 'X']},\n            ...                   index=['tiger', 'zebra', 'cow'])\n            >>> df.skew(numeric_only=True)\n            a   0.0\n            dtype: float64"
+        kwargs = {'min_count': ''}
+    elif name == 'kurt':
+        base_doc = _num_doc
+        desc = "Return unbiased kurtosis over requested axis.\n\nKurtosis obtained using Fisher's definition of\nkurtosis (kurtosis of normal == 0.0). Normalized by N-1."
+        see_also = ''
+        examples = "\n\n            Examples\n            --------\n            >>> s = pd.Series([1, 2, 2, 3], index=['cat', 'dog', 'dog', 'mouse'])\n            >>> s\n            cat    1\n            dog    2\n            dog    2\n            mouse  3\n            dtype: int64\n            >>> s.kurt()\n            1.5\n\n            With a DataFrame\n\n            >>> df = pd.DataFrame({'a': [1, 2, 2, 3], 'b': [3, 4, 4, 4]},\n            ...                   index=['cat', 'dog', 'dog', 'mouse'])\n            >>> df\n                   a   b\n              cat  1   3\n              dog  2   4\n              dog  2   4\n            mouse  3   4\n            >>> df.kurt()\n            a   1.5\n            b   4.0\n            dtype: float64\n\n            With axis=None\n\n            >>> df.kurt(axis=None).round(6)\n            -0.988693\n\n            Using axis=1\n\n            >>> df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [3, 4], 'd': [1, 2]},\n            ...                   index=['cat', 'dog'])\n            >>> df.kurt(axis=1)\n            cat   -6.0\n            dog   -6.0\n            dtype: float64"
+        kwargs = {'min_count': ''}
+    elif name == 'cumsum':
+        if ndim == 1:
+            base_doc = _cnum_series_doc
+        else:
+            base_doc = _cnum_pd_doc
+        desc = 'sum'
+        see_also = ''
+        examples = _cumsum_examples
+        kwargs = {'accum_func_name': 'sum'}
+    elif name == 'cumprod':
+        if ndim == 1:
+            base_doc = _cnum_series_doc
+        else:
+            base_doc = _cnum_pd_doc
+        desc = 'product'
+        see_also = ''
+        examples = _cumprod_examples
+        kwargs = {'accum_func_name': 'prod'}
+    elif name == 'cummin':
+        if ndim == 1:
+            base_doc = _cnum_series_doc
+        else:
+            base_doc = _cnum_pd_doc
+        desc = 'minimum'
+        see_also = ''
+        examples = _cummin_examples
+        kwargs = {'accum_func_name': 'min'}
+    elif name == 'cummax':
+        if ndim == 1:
+            base_doc = _cnum_series_doc
+        else:
+            base_doc = _cnum_pd_doc
+        desc = 'maximum'
+        see_also = ''
+        examples = _cummax_examples
+        kwargs = {'accum_func_name': 'max'}
+    else:
+        raise NotImplementedError
+    docstr = base_doc.format(desc=desc, name=name, name1=name1, name2=name2, axis_descr=axis_descr, see_also=see_also, examples=examples, **kwargs)
+    return docstr
+
+# File: pandas-main/pandas/core/groupby/__init__.py
+from pandas.core.groupby.generic import DataFrameGroupBy, NamedAgg, SeriesGroupBy
+from pandas.core.groupby.groupby import GroupBy
+from pandas.core.groupby.grouper import Grouper
+__all__ = ['DataFrameGroupBy', 'NamedAgg', 'SeriesGroupBy', 'GroupBy', 'Grouper']
+
+# File: pandas-main/pandas/core/groupby/base.py
+""""""
+from __future__ import annotations
+import dataclasses
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+
+@dataclasses.dataclass(order=True, frozen=True)
+class OutputKey:
+    label: Hashable
+    position: int
+plotting_methods = frozenset(['plot', 'hist'])
+cythonized_kernels = frozenset(['cumprod', 'cumsum', 'shift', 'cummin', 'cummax'])
+reduction_kernels = frozenset(['all', 'any', 'corrwith', 'count', 'first', 'idxmax', 'idxmin', 'last', 'max', 'mean', 'median', 'min', 'nunique', 'prod', 'quantile', 'sem', 'size', 'skew', 'std', 'sum', 'var'])
+transformation_kernels = frozenset(['bfill', 'cumcount', 'cummax', 'cummin', 'cumprod', 'cumsum', 'diff', 'ffill', 'ngroup', 'pct_change', 'rank', 'shift'])
+groupby_other_methods = frozenset(['agg', 'aggregate', 'apply', 'boxplot', 'corr', 'cov', 'describe', 'expanding', 'ewm', 'filter', 'get_group', 'groups', 'head', 'hist', 'indices', 'ndim', 'ngroups', 'nth', 'ohlc', 'pipe', 'plot', 'resample', 'rolling', 'tail', 'take', 'transform', 'sample', 'value_counts'])
+transform_kernel_allowlist = reduction_kernels | transformation_kernels
+
+# File: pandas-main/pandas/core/groupby/categorical.py
+from __future__ import annotations
+import numpy as np
+from pandas.core.algorithms import unique1d
+from pandas.core.arrays.categorical import Categorical, CategoricalDtype, recode_for_categories
+
+def recode_for_groupby(c: Categorical, sort: bool, observed: bool) -> Categorical:
+    if observed:
+        take_codes = unique1d(c.codes[c.codes != -1])
+        if sort:
+            take_codes = np.sort(take_codes)
+        categories = c.categories.take(take_codes)
+        codes = recode_for_categories(c.codes, c.categories, categories)
+        dtype = CategoricalDtype(categories, ordered=c.ordered)
+        return Categorical._simple_new(codes, dtype=dtype)
+    if sort:
+        return c
+    unique_notnan_codes = unique1d(c.codes[c.codes != -1])
+    if sort:
+        unique_notnan_codes = np.sort(unique_notnan_codes)
+    if (num_cat := len(c.categories)) > len(unique_notnan_codes):
+        missing_codes = np.setdiff1d(np.arange(num_cat), unique_notnan_codes, assume_unique=True)
+        take_codes = np.concatenate((unique_notnan_codes, missing_codes))
+    else:
+        take_codes = unique_notnan_codes
+    return Categorical(c, c.categories.take(take_codes))
+
+# File: pandas-main/pandas/core/groupby/generic.py
+""""""
+from __future__ import annotations
+from collections import abc
+from collections.abc import Callable
+from functools import partial
+from textwrap import dedent
+from typing import TYPE_CHECKING, Any, Literal, NamedTuple, TypeVar, Union, cast
+import warnings
+import numpy as np
+from pandas._libs import Interval
+from pandas._libs.hashtable import duplicated
+from pandas.errors import SpecificationError
+from pandas.util._decorators import Appender, Substitution, doc
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import ensure_int64, is_bool, is_dict_like, is_integer_dtype, is_list_like, is_numeric_dtype, is_scalar
+from pandas.core.dtypes.dtypes import CategoricalDtype, IntervalDtype
+from pandas.core.dtypes.inference import is_hashable
+from pandas.core.dtypes.missing import isna, notna
+from pandas.core import algorithms
+from pandas.core.apply import GroupByApply, maybe_mangle_lambdas, reconstruct_func, validate_func_kwargs
+import pandas.core.common as com
+from pandas.core.frame import DataFrame
+from pandas.core.groupby import base
+from pandas.core.groupby.groupby import GroupBy, GroupByPlot, _agg_template_frame, _agg_template_series, _transform_template
+from pandas.core.indexes.api import Index, MultiIndex, all_indexes_same, default_index
+from pandas.core.series import Series
+from pandas.core.sorting import get_group_index
+from pandas.core.util.numba_ import maybe_use_numba
+from pandas.plotting import boxplot_frame_groupby
+if TYPE_CHECKING:
+    from collections.abc import Hashable, Sequence
+    from pandas._typing import ArrayLike, BlockManager, CorrelationMethod, IndexLabel, Manager, SingleBlockManager, TakeIndexer
+    from pandas import Categorical
+    from pandas.core.generic import NDFrame
+AggScalar = Union[str, Callable[..., Any]]
+ScalarResult = TypeVar('ScalarResult')
+
+class NamedAgg(NamedTuple):
+    column: Hashable
+    aggfunc: AggScalar
+
+class SeriesGroupBy(GroupBy[Series]):
+
+    def _wrap_agged_manager(self, mgr: Manager) -> Series:
+        out = self.obj._constructor_from_mgr(mgr, axes=mgr.axes)
+        out._name = self.obj.name
+        return out
+
+    def _get_data_to_aggregate(self, *, numeric_only: bool=False, name: str | None=None) -> SingleBlockManager:
+        ser = self._obj_with_exclusions
+        single = ser._mgr
+        if numeric_only and (not is_numeric_dtype(ser.dtype)):
+            kwd_name = 'numeric_only'
+            raise TypeError(f'Cannot use {kwd_name}=True with {type(self).__name__}.{name} and non-numeric dtypes.')
+        return single
+    _agg_examples_doc = dedent("\n    Examples\n    --------\n    >>> s = pd.Series([1, 2, 3, 4])\n\n    >>> s\n    0    1\n    1    2\n    2    3\n    3    4\n    dtype: int64\n\n    >>> s.groupby([1, 1, 2, 2]).min()\n    1    1\n    2    3\n    dtype: int64\n\n    >>> s.groupby([1, 1, 2, 2]).agg('min')\n    1    1\n    2    3\n    dtype: int64\n\n    >>> s.groupby([1, 1, 2, 2]).agg(['min', 'max'])\n       min  max\n    1    1    2\n    2    3    4\n\n    The output column names can be controlled by passing\n    the desired column names and aggregations as keyword arguments.\n\n    >>> s.groupby([1, 1, 2, 2]).agg(\n    ...     minimum='min',\n    ...     maximum='max',\n    ... )\n       minimum  maximum\n    1        1        2\n    2        3        4\n\n    .. versionchanged:: 1.3.0\n\n        The resulting dtype will reflect the return value of the aggregating function.\n\n    >>> s.groupby([1, 1, 2, 2]).agg(lambda x: x.astype(float).min())\n    1    1.0\n    2    3.0\n    dtype: float64\n    ")
+
+    def apply(self, func, *args, **kwargs) -> Series:
+        return super().apply(func, *args, **kwargs)
+
+    @doc(_agg_template_series, examples=_agg_examples_doc, klass='Series')
+    def aggregate(self, func=None, *args, engine=None, engine_kwargs=None, **kwargs):
+        relabeling = func is None
+        columns = None
+        if relabeling:
+            (columns, func) = validate_func_kwargs(kwargs)
+            kwargs = {}
+        if isinstance(func, str):
+            if maybe_use_numba(engine) and engine is not None:
+                kwargs['engine'] = engine
+            if engine_kwargs is not None:
+                kwargs['engine_kwargs'] = engine_kwargs
+            return getattr(self, func)(*args, **kwargs)
+        elif isinstance(func, abc.Iterable):
+            func = maybe_mangle_lambdas(func)
+            kwargs['engine'] = engine
+            kwargs['engine_kwargs'] = engine_kwargs
+            ret = self._aggregate_multiple_funcs(func, *args, **kwargs)
+            if relabeling:
+                assert columns is not None
+                ret.columns = columns
+            if not self.as_index:
+                ret = ret.reset_index()
+            return ret
+        else:
+            if maybe_use_numba(engine):
+                return self._aggregate_with_numba(func, *args, engine_kwargs=engine_kwargs, **kwargs)
+            if self.ngroups == 0:
+                obj = self._obj_with_exclusions
+                return self.obj._constructor([], name=self.obj.name, index=self._grouper.result_index, dtype=obj.dtype)
+            return self._python_agg_general(func, *args, **kwargs)
+    agg = aggregate
+
+    def _python_agg_general(self, func, *args, **kwargs):
+        f = lambda x: func(x, *args, **kwargs)
+        obj = self._obj_with_exclusions
+        result = self._grouper.agg_series(obj, f)
+        res = obj._constructor(result, name=obj.name)
+        return self._wrap_aggregated_output(res)
+
+    def _aggregate_multiple_funcs(self, arg, *args, **kwargs) -> DataFrame:
+        if isinstance(arg, dict):
+            raise SpecificationError('nested renamer is not supported')
+        if any((isinstance(x, (tuple, list)) for x in arg)):
+            arg = ((x, x) if not isinstance(x, (tuple, list)) else x for x in arg)
+        else:
+            columns = (com.get_callable_name(f) or f for f in arg)
+            arg = zip(columns, arg)
+        results: dict[base.OutputKey, DataFrame | Series] = {}
+        with com.temp_setattr(self, 'as_index', True):
+            for (idx, (name, func)) in enumerate(arg):
+                key = base.OutputKey(label=name, position=idx)
+                results[key] = self.aggregate(func, *args, **kwargs)
+        if any((isinstance(x, DataFrame) for x in results.values())):
+            from pandas import concat
+            res_df = concat(results.values(), axis=1, keys=[key.label for key in results])
+            return res_df
+        indexed_output = {key.position: val for (key, val) in results.items()}
+        output = self.obj._constructor_expanddim(indexed_output, index=None)
+        output.columns = Index((key.label for key in results))
+        return output
+
+    def _wrap_applied_output(self, data: Series, values: list[Any], not_indexed_same: bool=False, is_transform: bool=False) -> DataFrame | Series:
+        if len(values) == 0:
+            if is_transform:
+                res_index = data.index
+            else:
+                res_index = self._grouper.result_index
+            return self.obj._constructor([], name=self.obj.name, index=res_index, dtype=data.dtype)
+        assert values is not None
+        if isinstance(values[0], dict):
+            index = self._grouper.result_index
+            res_df = self.obj._constructor_expanddim(values, index=index)
+            res_ser = res_df.stack()
+            res_ser.name = self.obj.name
+            return res_ser
+        elif isinstance(values[0], (Series, DataFrame)):
+            result = self._concat_objects(values, not_indexed_same=not_indexed_same, is_transform=is_transform)
+            if isinstance(result, Series):
+                result.name = self.obj.name
+            if not self.as_index and not_indexed_same:
+                result = self._insert_inaxis_grouper(result)
+                result.index = default_index(len(result))
+            return result
+        else:
+            result = self.obj._constructor(data=values, index=self._grouper.result_index, name=self.obj.name)
+            if not self.as_index:
+                result = self._insert_inaxis_grouper(result)
+                result.index = default_index(len(result))
+            return result
+    __examples_series_doc = dedent('\n    >>> ser = pd.Series([390.0, 350.0, 30.0, 20.0],\n    ...                 index=["Falcon", "Falcon", "Parrot", "Parrot"],\n    ...                 name="Max Speed")\n    >>> grouped = ser.groupby([1, 1, 2, 2])\n    >>> grouped.transform(lambda x: (x - x.mean()) / x.std())\n        Falcon    0.707107\n        Falcon   -0.707107\n        Parrot    0.707107\n        Parrot   -0.707107\n        Name: Max Speed, dtype: float64\n\n    Broadcast result of the transformation\n\n    >>> grouped.transform(lambda x: x.max() - x.min())\n    Falcon    40.0\n    Falcon    40.0\n    Parrot    10.0\n    Parrot    10.0\n    Name: Max Speed, dtype: float64\n\n    >>> grouped.transform("mean")\n    Falcon    370.0\n    Falcon    370.0\n    Parrot     25.0\n    Parrot     25.0\n    Name: Max Speed, dtype: float64\n\n    .. versionchanged:: 1.3.0\n\n    The resulting dtype will reflect the return value of the passed ``func``,\n    for example:\n\n    >>> grouped.transform(lambda x: x.astype(int).max())\n    Falcon    390\n    Falcon    390\n    Parrot     30\n    Parrot     30\n    Name: Max Speed, dtype: int64\n    ')
+
+    @Substitution(klass='Series', example=__examples_series_doc)
+    @Appender(_transform_template)
+    def transform(self, func, *args, engine=None, engine_kwargs=None, **kwargs):
+        return self._transform(func, *args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+
+    def _cython_transform(self, how: str, numeric_only: bool=False, **kwargs):
+        obj = self._obj_with_exclusions
+        try:
+            result = self._grouper._cython_operation('transform', obj._values, how, 0, **kwargs)
+        except NotImplementedError as err:
+            raise TypeError(f'{how} is not supported for {obj.dtype} dtype') from err
+        return obj._constructor(result, index=self.obj.index, name=obj.name)
+
+    def _transform_general(self, func: Callable, engine, engine_kwargs, *args, **kwargs) -> Series:
+        if maybe_use_numba(engine):
+            return self._transform_with_numba(func, *args, engine_kwargs=engine_kwargs, **kwargs)
+        assert callable(func)
+        klass = type(self.obj)
+        results = []
+        for (name, group) in self._grouper.get_iterator(self._obj_with_exclusions):
+            object.__setattr__(group, 'name', name)
+            res = func(group, *args, **kwargs)
+            results.append(klass(res, index=group.index))
+        if results:
+            from pandas.core.reshape.concat import concat
+            concatenated = concat(results, ignore_index=True)
+            result = self._set_result_index_ordered(concatenated)
+        else:
+            result = self.obj._constructor(dtype=np.float64)
+        result.name = self.obj.name
+        return result
+
+    def filter(self, func, dropna: bool=True, *args, **kwargs):
+        if isinstance(func, str):
+            wrapper = lambda x: getattr(x, func)(*args, **kwargs)
+        else:
+            wrapper = lambda x: func(x, *args, **kwargs)
+
+        def true_and_notna(x) -> bool:
+            b = wrapper(x)
+            return notna(b) and b
+        try:
+            indices = [self._get_index(name) for (name, group) in self._grouper.get_iterator(self._obj_with_exclusions) if true_and_notna(group)]
+        except (ValueError, TypeError) as err:
+            raise TypeError('the filter must return a boolean result') from err
+        filtered = self._apply_filter(indices, dropna)
+        return filtered
+
+    def nunique(self, dropna: bool=True) -> Series | DataFrame:
+        ids = self._grouper.ids
+        ngroups = self._grouper.ngroups
+        val = self.obj._values
+        (codes, uniques) = algorithms.factorize(val, use_na_sentinel=dropna, sort=False)
+        if self._grouper.has_dropped_na:
+            mask = ids >= 0
+            ids = ids[mask]
+            codes = codes[mask]
+        group_index = get_group_index(labels=[ids, codes], shape=(ngroups, len(uniques)), sort=False, xnull=dropna)
+        if dropna:
+            mask = group_index >= 0
+            if (~mask).any():
+                ids = ids[mask]
+                group_index = group_index[mask]
+        mask = duplicated(group_index, 'first')
+        res = np.bincount(ids[~mask], minlength=ngroups)
+        res = ensure_int64(res)
+        ri = self._grouper.result_index
+        result: Series | DataFrame = self.obj._constructor(res, index=ri, name=self.obj.name)
+        if not self.as_index:
+            result = self._insert_inaxis_grouper(result)
+            result.index = default_index(len(result))
+        return result
+
+    @doc(Series.describe)
+    def describe(self, percentiles=None, include=None, exclude=None) -> Series:
+        return super().describe(percentiles=percentiles, include=include, exclude=exclude)
+
+    def value_counts(self, normalize: bool=False, sort: bool=True, ascending: bool=False, bins=None, dropna: bool=True) -> Series | DataFrame:
+        name = 'proportion' if normalize else 'count'
+        if bins is None:
+            result = self._value_counts(normalize=normalize, sort=sort, ascending=ascending, dropna=dropna)
+            result.name = name
+            return result
+        from pandas.core.reshape.merge import get_join_indexers
+        from pandas.core.reshape.tile import cut
+        ids = self._grouper.ids
+        val = self.obj._values
+        index_names = self._grouper.names + [self.obj.name]
+        if isinstance(val.dtype, CategoricalDtype) or (bins is not None and (not np.iterable(bins))):
+            ser = self.apply(Series.value_counts, normalize=normalize, sort=sort, ascending=ascending, bins=bins)
+            ser.name = name
+            ser.index.names = index_names
+            return ser
+        mask = ids != -1
+        (ids, val) = (ids[mask], val[mask])
+        lab: Index | np.ndarray
+        if bins is None:
+            (lab, lev) = algorithms.factorize(val, sort=True)
+            llab = lambda lab, inc: lab[inc]
+        else:
+            cat_ser = cut(Series(val, copy=False), bins, include_lowest=True)
+            cat_obj = cast('Categorical', cat_ser._values)
+            lev = cat_obj.categories
+            lab = lev.take(cat_obj.codes, allow_fill=True, fill_value=lev._na_value)
+            llab = lambda lab, inc: lab[inc]._multiindex.codes[-1]
+        if isinstance(lab.dtype, IntervalDtype):
+            lab_interval = cast(Interval, lab)
+            sorter = np.lexsort((lab_interval.left, lab_interval.right, ids))
+        else:
+            sorter = np.lexsort((lab, ids))
+        (ids, lab) = (ids[sorter], lab[sorter])
+        idchanges = 1 + np.nonzero(ids[1:] != ids[:-1])[0]
+        idx = np.r_[0, idchanges]
+        if not len(ids):
+            idx = idchanges
+        lchanges = llab(lab, slice(1, None)) != llab(lab, slice(None, -1))
+        inc = np.r_[True, lchanges]
+        if not len(val):
+            inc = lchanges
+        inc[idx] = True
+        out = np.diff(np.nonzero(np.r_[inc, True])[0])
+        rep = partial(np.repeat, repeats=np.add.reduceat(inc, idx))
+        if isinstance(self._grouper.result_index, MultiIndex):
+            codes = list(self._grouper.result_index.codes)
+        else:
+            codes = [algorithms.factorize(self._grouper.result_index, sort=self._grouper._sort, use_na_sentinel=self._grouper.dropna)[0]]
+        codes = [rep(level_codes) for level_codes in codes] + [llab(lab, inc)]
+        levels = self._grouper.levels + [lev]
+        if dropna:
+            mask = codes[-1] != -1
+            if mask.all():
+                dropna = False
+            else:
+                (out, codes) = (out[mask], [level_codes[mask] for level_codes in codes])
+        if normalize:
+            out = out.astype('float')
+            d = np.diff(np.r_[idx, len(ids)])
+            if dropna:
+                m = ids[lab == -1]
+                np.add.at(d, m, -1)
+                acc = rep(d)[mask]
+            else:
+                acc = rep(d)
+            out /= acc
+        if sort and bins is None:
+            cat = ids[inc][mask] if dropna else ids[inc]
+            sorter = np.lexsort((out if ascending else -out, cat))
+            (out, codes[-1]) = (out[sorter], codes[-1][sorter])
+        if bins is not None:
+            diff = np.zeros(len(out), dtype='bool')
+            for level_codes in codes[:-1]:
+                diff |= np.r_[True, level_codes[1:] != level_codes[:-1]]
+            (ncat, nbin) = (diff.sum(), len(levels[-1]))
+            left = [np.repeat(np.arange(ncat), nbin), np.tile(np.arange(nbin), ncat)]
+            right = [diff.cumsum() - 1, codes[-1]]
+            (_, idx) = get_join_indexers(left, right, sort=False, how='left')
+            if idx is not None:
+                out = np.where(idx != -1, out[idx], 0)
+            if sort:
+                sorter = np.lexsort((out if ascending else -out, left[0]))
+                (out, left[-1]) = (out[sorter], left[-1][sorter])
+
+            def build_codes(lev_codes: np.ndarray) -> np.ndarray:
+                return np.repeat(lev_codes[diff], nbin)
+            codes = [build_codes(lev_codes) for lev_codes in codes[:-1]]
+            codes.append(left[-1])
+        mi = MultiIndex(levels=levels, codes=codes, names=index_names, verify_integrity=False)
+        if is_integer_dtype(out.dtype):
+            out = ensure_int64(out)
+        result = self.obj._constructor(out, index=mi, name=name)
+        if not self.as_index:
+            result = result.reset_index()
+        return result
+
+    def take(self, indices: TakeIndexer, **kwargs) -> Series:
+        result = self._op_via_apply('take', indices=indices, **kwargs)
+        return result
+
+    def skew(self, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Series:
+
+        def alt(obj):
+            raise TypeError(f"'skew' is not supported for dtype={obj.dtype}")
+        return self._cython_agg_general('skew', alt=alt, skipna=skipna, numeric_only=numeric_only, **kwargs)
+
+    @property
+    @doc(Series.plot.__doc__)
+    def plot(self) -> GroupByPlot:
+        result = GroupByPlot(self)
+        return result
+
+    @doc(Series.nlargest.__doc__)
+    def nlargest(self, n: int=5, keep: Literal['first', 'last', 'all']='first') -> Series:
+        f = partial(Series.nlargest, n=n, keep=keep)
+        data = self._obj_with_exclusions
+        result = self._python_apply_general(f, data, not_indexed_same=True)
+        return result
+
+    @doc(Series.nsmallest.__doc__)
+    def nsmallest(self, n: int=5, keep: Literal['first', 'last', 'all']='first') -> Series:
+        f = partial(Series.nsmallest, n=n, keep=keep)
+        data = self._obj_with_exclusions
+        result = self._python_apply_general(f, data, not_indexed_same=True)
+        return result
+
+    def idxmin(self, skipna: bool=True) -> Series:
+        return self._idxmax_idxmin('idxmin', skipna=skipna)
+
+    def idxmax(self, skipna: bool=True) -> Series:
+        return self._idxmax_idxmin('idxmax', skipna=skipna)
+
+    @doc(Series.corr.__doc__)
+    def corr(self, other: Series, method: CorrelationMethod='pearson', min_periods: int | None=None) -> Series:
+        result = self._op_via_apply('corr', other=other, method=method, min_periods=min_periods)
+        return result
+
+    @doc(Series.cov.__doc__)
+    def cov(self, other: Series, min_periods: int | None=None, ddof: int | None=1) -> Series:
+        result = self._op_via_apply('cov', other=other, min_periods=min_periods, ddof=ddof)
+        return result
+
+    @property
+    def is_monotonic_increasing(self) -> Series:
+        return self.apply(lambda ser: ser.is_monotonic_increasing)
+
+    @property
+    def is_monotonic_decreasing(self) -> Series:
+        return self.apply(lambda ser: ser.is_monotonic_decreasing)
+
+    @doc(Series.hist.__doc__)
+    def hist(self, by=None, ax=None, grid: bool=True, xlabelsize: int | None=None, xrot: float | None=None, ylabelsize: int | None=None, yrot: float | None=None, figsize: tuple[float, float] | None=None, bins: int | Sequence[int]=10, backend: str | None=None, legend: bool=False, **kwargs):
+        result = self._op_via_apply('hist', by=by, ax=ax, grid=grid, xlabelsize=xlabelsize, xrot=xrot, ylabelsize=ylabelsize, yrot=yrot, figsize=figsize, bins=bins, backend=backend, legend=legend, **kwargs)
+        return result
+
+    @property
+    @doc(Series.dtype.__doc__)
+    def dtype(self) -> Series:
+        return self.apply(lambda ser: ser.dtype)
+
+    def unique(self) -> Series:
+        result = self._op_via_apply('unique')
+        return result
+
+class DataFrameGroupBy(GroupBy[DataFrame]):
+    _agg_examples_doc = dedent('\n    Examples\n    --------\n    >>> data = {"A": [1, 1, 2, 2],\n    ...         "B": [1, 2, 3, 4],\n    ...         "C": [0.362838, 0.227877, 1.267767, -0.562860]}\n    >>> df = pd.DataFrame(data)\n    >>> df\n       A  B         C\n    0  1  1  0.362838\n    1  1  2  0.227877\n    2  2  3  1.267767\n    3  2  4 -0.562860\n\n    The aggregation is for each column.\n\n    >>> df.groupby(\'A\').agg(\'min\')\n       B         C\n    A\n    1  1  0.227877\n    2  3 -0.562860\n\n    Multiple aggregations\n\n    >>> df.groupby(\'A\').agg([\'min\', \'max\'])\n        B             C\n      min max       min       max\n    A\n    1   1   2  0.227877  0.362838\n    2   3   4 -0.562860  1.267767\n\n    Select a column for aggregation\n\n    >>> df.groupby(\'A\').B.agg([\'min\', \'max\'])\n       min  max\n    A\n    1    1    2\n    2    3    4\n\n    User-defined function for aggregation\n\n    >>> df.groupby(\'A\').agg(lambda x: sum(x) + 2)\n        B\t       C\n    A\n    1\t5\t2.590715\n    2\t9\t2.704907\n\n    Different aggregations per column\n\n    >>> df.groupby(\'A\').agg({\'B\': [\'min\', \'max\'], \'C\': \'sum\'})\n        B             C\n      min max       sum\n    A\n    1   1   2  0.590715\n    2   3   4  0.704907\n\n    To control the output names with different aggregations per column,\n    pandas supports "named aggregation"\n\n    >>> df.groupby("A").agg(\n    ...     b_min=pd.NamedAgg(column="B", aggfunc="min"),\n    ...     c_sum=pd.NamedAgg(column="C", aggfunc="sum")\n    ... )\n       b_min     c_sum\n    A\n    1      1  0.590715\n    2      3  0.704907\n\n    - The keywords are the *output* column names\n    - The values are tuples whose first element is the column to select\n      and the second element is the aggregation to apply to that column.\n      Pandas provides the ``pandas.NamedAgg`` namedtuple with the fields\n      ``[\'column\', \'aggfunc\']`` to make it clearer what the arguments are.\n      As usual, the aggregation can be a callable or a string alias.\n\n    See :ref:`groupby.aggregate.named` for more.\n\n    .. versionchanged:: 1.3.0\n\n        The resulting dtype will reflect the return value of the aggregating function.\n\n    >>> df.groupby("A")[["B"]].agg(lambda x: x.astype(float).min())\n          B\n    A\n    1   1.0\n    2   3.0\n    ')
+
+    @doc(_agg_template_frame, examples=_agg_examples_doc, klass='DataFrame')
+    def aggregate(self, func=None, *args, engine=None, engine_kwargs=None, **kwargs):
+        (relabeling, func, columns, order) = reconstruct_func(func, **kwargs)
+        func = maybe_mangle_lambdas(func)
+        if maybe_use_numba(engine):
+            kwargs['engine'] = engine
+            kwargs['engine_kwargs'] = engine_kwargs
+        op = GroupByApply(self, func, args=args, kwargs=kwargs)
+        result = op.agg()
+        if not is_dict_like(func) and result is not None:
+            if not self.as_index and is_list_like(func):
+                return result.reset_index()
+            else:
+                return result
+        elif relabeling:
+            result = cast(DataFrame, result)
+            result = result.iloc[:, order]
+            result = cast(DataFrame, result)
+            result.columns = columns
+        if result is None:
+            if 'engine' in kwargs:
+                del kwargs['engine']
+                del kwargs['engine_kwargs']
+            if maybe_use_numba(engine):
+                return self._aggregate_with_numba(func, *args, engine_kwargs=engine_kwargs, **kwargs)
+            if self._grouper.nkeys > 1:
+                return self._python_agg_general(func, *args, **kwargs)
+            elif args or kwargs:
+                result = self._aggregate_frame(func, *args, **kwargs)
+            else:
+                gba = GroupByApply(self, [func], args=(), kwargs={})
+                try:
+                    result = gba.agg()
+                except ValueError as err:
+                    if 'No objects to concatenate' not in str(err):
+                        raise
+                    result = self._aggregate_frame(func)
+                else:
+                    result = cast(DataFrame, result)
+                    result.columns = self._obj_with_exclusions.columns.copy()
+        if not self.as_index:
+            result = self._insert_inaxis_grouper(result)
+            result.index = default_index(len(result))
+        return result
+    agg = aggregate
+
+    def _python_agg_general(self, func, *args, **kwargs):
+        f = lambda x: func(x, *args, **kwargs)
+        if self.ngroups == 0:
+            return self._python_apply_general(f, self._selected_obj, is_agg=True)
+        obj = self._obj_with_exclusions
+        if not len(obj.columns):
+            return self._python_apply_general(f, self._selected_obj)
+        output: dict[int, ArrayLike] = {}
+        for (idx, (name, ser)) in enumerate(obj.items()):
+            result = self._grouper.agg_series(ser, f)
+            output[idx] = result
+        res = self.obj._constructor(output)
+        res.columns = obj.columns.copy(deep=False)
+        return self._wrap_aggregated_output(res)
+
+    def _aggregate_frame(self, func, *args, **kwargs) -> DataFrame:
+        if self._grouper.nkeys != 1:
+            raise AssertionError('Number of keys must be 1')
+        obj = self._obj_with_exclusions
+        result: dict[Hashable, NDFrame | np.ndarray] = {}
+        for (name, grp_df) in self._grouper.get_iterator(obj):
+            fres = func(grp_df, *args, **kwargs)
+            result[name] = fres
+        result_index = self._grouper.result_index
+        out = self.obj._constructor(result, index=obj.columns, columns=result_index)
+        out = out.T
+        return out
+
+    def _wrap_applied_output(self, data: DataFrame, values: list, not_indexed_same: bool=False, is_transform: bool=False):
+        if len(values) == 0:
+            if is_transform:
+                res_index = data.index
+            else:
+                res_index = self._grouper.result_index
+            result = self.obj._constructor(index=res_index, columns=data.columns)
+            result = result.astype(data.dtypes)
+            return result
+        first_not_none = next(com.not_none(*values), None)
+        if first_not_none is None:
+            result = self.obj._constructor(columns=data.columns)
+            result = result.astype(data.dtypes)
+            return result
+        elif isinstance(first_not_none, DataFrame):
+            return self._concat_objects(values, not_indexed_same=not_indexed_same, is_transform=is_transform)
+        key_index = self._grouper.result_index if self.as_index else None
+        if isinstance(first_not_none, (np.ndarray, Index)):
+            if not is_hashable(self._selection):
+                name = tuple(self._selection)
+            else:
+                name = self._selection
+            return self.obj._constructor_sliced(values, index=key_index, name=name)
+        elif not isinstance(first_not_none, Series):
+            if self.as_index:
+                return self.obj._constructor_sliced(values, index=key_index)
+            else:
+                result = self.obj._constructor(values, columns=[self._selection])
+                result = self._insert_inaxis_grouper(result)
+                return result
+        else:
+            return self._wrap_applied_output_series(values, not_indexed_same, first_not_none, key_index, is_transform)
+
+    def _wrap_applied_output_series(self, values: list[Series], not_indexed_same: bool, first_not_none, key_index: Index | None, is_transform: bool) -> DataFrame | Series:
+        kwargs = first_not_none._construct_axes_dict()
+        backup = Series(**kwargs)
+        values = [x if x is not None else backup for x in values]
+        all_indexed_same = all_indexes_same((x.index for x in values))
+        if not all_indexed_same:
+            return self._concat_objects(values, not_indexed_same=True, is_transform=is_transform)
+        stacked_values = np.vstack([np.asarray(v) for v in values])
+        index = key_index
+        columns = first_not_none.index.copy()
+        if columns.name is None:
+            names = {v.name for v in values}
+            if len(names) == 1:
+                columns.name = next(iter(names))
+        if stacked_values.dtype == object:
+            stacked_values = stacked_values.tolist()
+        result = self.obj._constructor(stacked_values, index=index, columns=columns)
+        if not self.as_index:
+            result = self._insert_inaxis_grouper(result)
+        return result
+
+    def _cython_transform(self, how: str, numeric_only: bool=False, **kwargs) -> DataFrame:
+        mgr: BlockManager = self._get_data_to_aggregate(numeric_only=numeric_only, name=how)
+
+        def arr_func(bvalues: ArrayLike) -> ArrayLike:
+            return self._grouper._cython_operation('transform', bvalues, how, 1, **kwargs)
+        res_mgr = mgr.apply(arr_func)
+        res_df = self.obj._constructor_from_mgr(res_mgr, axes=res_mgr.axes)
+        return res_df
+
+    def _transform_general(self, func, engine, engine_kwargs, *args, **kwargs):
+        if maybe_use_numba(engine):
+            return self._transform_with_numba(func, *args, engine_kwargs=engine_kwargs, **kwargs)
+        from pandas.core.reshape.concat import concat
+        applied = []
+        obj = self._obj_with_exclusions
+        gen = self._grouper.get_iterator(obj)
+        (fast_path, slow_path) = self._define_paths(func, *args, **kwargs)
+        try:
+            (name, group) = next(gen)
+        except StopIteration:
+            pass
+        else:
+            object.__setattr__(group, 'name', name)
+            try:
+                (path, res) = self._choose_path(fast_path, slow_path, group)
+            except ValueError as err:
+                msg = 'transform must return a scalar value for each group'
+                raise ValueError(msg) from err
+            if group.size > 0:
+                res = _wrap_transform_general_frame(self.obj, group, res)
+                applied.append(res)
+        for (name, group) in gen:
+            if group.size == 0:
+                continue
+            object.__setattr__(group, 'name', name)
+            res = path(group)
+            res = _wrap_transform_general_frame(self.obj, group, res)
+            applied.append(res)
+        concat_index = obj.columns
+        concatenated = concat(applied, axis=0, verify_integrity=False, ignore_index=True)
+        concatenated = concatenated.reindex(concat_index, axis=1)
+        return self._set_result_index_ordered(concatenated)
+    __examples_dataframe_doc = dedent('\n    >>> df = pd.DataFrame({\'A\' : [\'foo\', \'bar\', \'foo\', \'bar\',\n    ...                           \'foo\', \'bar\'],\n    ...                    \'B\' : [\'one\', \'one\', \'two\', \'three\',\n    ...                           \'two\', \'two\'],\n    ...                    \'C\' : [1, 5, 5, 2, 5, 5],\n    ...                    \'D\' : [2.0, 5., 8., 1., 2., 9.]})\n    >>> grouped = df.groupby(\'A\')[[\'C\', \'D\']]\n    >>> grouped.transform(lambda x: (x - x.mean()) / x.std())\n            C         D\n    0 -1.154701 -0.577350\n    1  0.577350  0.000000\n    2  0.577350  1.154701\n    3 -1.154701 -1.000000\n    4  0.577350 -0.577350\n    5  0.577350  1.000000\n\n    Broadcast result of the transformation\n\n    >>> grouped.transform(lambda x: x.max() - x.min())\n        C    D\n    0  4.0  6.0\n    1  3.0  8.0\n    2  4.0  6.0\n    3  3.0  8.0\n    4  4.0  6.0\n    5  3.0  8.0\n\n    >>> grouped.transform("mean")\n        C    D\n    0  3.666667  4.0\n    1  4.000000  5.0\n    2  3.666667  4.0\n    3  4.000000  5.0\n    4  3.666667  4.0\n    5  4.000000  5.0\n\n    .. versionchanged:: 1.3.0\n\n    The resulting dtype will reflect the return value of the passed ``func``,\n    for example:\n\n    >>> grouped.transform(lambda x: x.astype(int).max())\n    C  D\n    0  5  8\n    1  5  9\n    2  5  8\n    3  5  9\n    4  5  8\n    5  5  9\n    ')
+
+    @Substitution(klass='DataFrame', example=__examples_dataframe_doc)
+    @Appender(_transform_template)
+    def transform(self, func, *args, engine=None, engine_kwargs=None, **kwargs):
+        return self._transform(func, *args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+
+    def _define_paths(self, func, *args, **kwargs):
+        if isinstance(func, str):
+            fast_path = lambda group: getattr(group, func)(*args, **kwargs)
+            slow_path = lambda group: group.apply(lambda x: getattr(x, func)(*args, **kwargs), axis=0)
+        else:
+            fast_path = lambda group: func(group, *args, **kwargs)
+            slow_path = lambda group: group.apply(lambda x: func(x, *args, **kwargs), axis=0)
+        return (fast_path, slow_path)
+
+    def _choose_path(self, fast_path: Callable, slow_path: Callable, group: DataFrame):
+        path = slow_path
+        res = slow_path(group)
+        if self.ngroups == 1:
+            return (path, res)
+        try:
+            res_fast = fast_path(group)
+        except AssertionError:
+            raise
+        except Exception:
+            return (path, res)
+        if isinstance(res_fast, DataFrame):
+            if not res_fast.columns.equals(group.columns):
+                return (path, res)
+        elif isinstance(res_fast, Series):
+            if not res_fast.index.equals(group.columns):
+                return (path, res)
+        else:
+            return (path, res)
+        if res_fast.equals(res):
+            path = fast_path
+        return (path, res)
+
+    def filter(self, func, dropna: bool=True, *args, **kwargs) -> DataFrame:
+        indices = []
+        obj = self._selected_obj
+        gen = self._grouper.get_iterator(obj)
+        for (name, group) in gen:
+            object.__setattr__(group, 'name', name)
+            res = func(group, *args, **kwargs)
+            try:
+                res = res.squeeze()
+            except AttributeError:
+                pass
+            if is_bool(res) or (is_scalar(res) and isna(res)):
+                if notna(res) and res:
+                    indices.append(self._get_index(name))
+            else:
+                raise TypeError(f'filter function returned a {type(res).__name__}, but expected a scalar bool')
+        return self._apply_filter(indices, dropna)
+
+    def __getitem__(self, key) -> DataFrameGroupBy | SeriesGroupBy:
+        if isinstance(key, tuple) and len(key) > 1:
+            raise ValueError('Cannot subset columns with a tuple with more than one element. Use a list instead.')
+        return super().__getitem__(key)
+
+    def _gotitem(self, key, ndim: int, subset=None):
+        if ndim == 2:
+            if subset is None:
+                subset = self.obj
+            return DataFrameGroupBy(subset, self.keys, level=self.level, grouper=self._grouper, exclusions=self.exclusions, selection=key, as_index=self.as_index, sort=self.sort, group_keys=self.group_keys, observed=self.observed, dropna=self.dropna)
+        elif ndim == 1:
+            if subset is None:
+                subset = self.obj[key]
+            return SeriesGroupBy(subset, self.keys, level=self.level, grouper=self._grouper, exclusions=self.exclusions, selection=key, as_index=self.as_index, sort=self.sort, group_keys=self.group_keys, observed=self.observed, dropna=self.dropna)
+        raise AssertionError('invalid ndim for _gotitem')
+
+    def _get_data_to_aggregate(self, *, numeric_only: bool=False, name: str | None=None) -> BlockManager:
+        obj = self._obj_with_exclusions
+        mgr = obj._mgr
+        if numeric_only:
+            mgr = mgr.get_numeric_data()
+        return mgr
+
+    def _wrap_agged_manager(self, mgr: BlockManager) -> DataFrame:
+        return self.obj._constructor_from_mgr(mgr, axes=mgr.axes)
+
+    def _apply_to_column_groupbys(self, func) -> DataFrame:
+        from pandas.core.reshape.concat import concat
+        obj = self._obj_with_exclusions
+        columns = obj.columns
+        sgbs = (SeriesGroupBy(obj.iloc[:, i], selection=colname, grouper=self._grouper, exclusions=self.exclusions, observed=self.observed) for (i, colname) in enumerate(obj.columns))
+        results = [func(sgb) for sgb in sgbs]
+        if not len(results):
+            res_df = DataFrame([], columns=columns, index=self._grouper.result_index)
+        else:
+            res_df = concat(results, keys=columns, axis=1)
+        if not self.as_index:
+            res_df.index = default_index(len(res_df))
+            res_df = self._insert_inaxis_grouper(res_df)
+        return res_df
+
+    def nunique(self, dropna: bool=True) -> DataFrame:
+        return self._apply_to_column_groupbys(lambda sgb: sgb.nunique(dropna))
+
+    def idxmax(self, skipna: bool=True, numeric_only: bool=False) -> DataFrame:
+        return self._idxmax_idxmin('idxmax', numeric_only=numeric_only, skipna=skipna)
+
+    def idxmin(self, skipna: bool=True, numeric_only: bool=False) -> DataFrame:
+        return self._idxmax_idxmin('idxmin', numeric_only=numeric_only, skipna=skipna)
+    boxplot = boxplot_frame_groupby
+
+    def value_counts(self, subset: Sequence[Hashable] | None=None, normalize: bool=False, sort: bool=True, ascending: bool=False, dropna: bool=True) -> DataFrame | Series:
+        return self._value_counts(subset, normalize, sort, ascending, dropna)
+
+    def take(self, indices: TakeIndexer, **kwargs) -> DataFrame:
+        result = self._op_via_apply('take', indices=indices, **kwargs)
+        return result
+
+    def skew(self, skipna: bool=True, numeric_only: bool=False, **kwargs) -> DataFrame:
+
+        def alt(obj):
+            raise TypeError(f"'skew' is not supported for dtype={obj.dtype}")
+        return self._cython_agg_general('skew', alt=alt, skipna=skipna, numeric_only=numeric_only, **kwargs)
+
+    @property
+    @doc(DataFrame.plot.__doc__)
+    def plot(self) -> GroupByPlot:
+        result = GroupByPlot(self)
+        return result
+
+    @doc(DataFrame.corr.__doc__)
+    def corr(self, method: str | Callable[[np.ndarray, np.ndarray], float]='pearson', min_periods: int=1, numeric_only: bool=False) -> DataFrame:
+        result = self._op_via_apply('corr', method=method, min_periods=min_periods, numeric_only=numeric_only)
+        return result
+
+    @doc(DataFrame.cov.__doc__)
+    def cov(self, min_periods: int | None=None, ddof: int | None=1, numeric_only: bool=False) -> DataFrame:
+        result = self._op_via_apply('cov', min_periods=min_periods, ddof=ddof, numeric_only=numeric_only)
+        return result
+
+    def hist(self, column: IndexLabel | None=None, by=None, grid: bool=True, xlabelsize: int | None=None, xrot: float | None=None, ylabelsize: int | None=None, yrot: float | None=None, ax=None, sharex: bool=False, sharey: bool=False, figsize: tuple[float, float] | None=None, layout: tuple[int, int] | None=None, bins: int | Sequence[int]=10, backend: str | None=None, legend: bool=False, **kwargs):
+        result = self._op_via_apply('hist', column=column, by=by, grid=grid, xlabelsize=xlabelsize, xrot=xrot, ylabelsize=ylabelsize, yrot=yrot, ax=ax, sharex=sharex, sharey=sharey, figsize=figsize, layout=layout, bins=bins, backend=backend, legend=legend, **kwargs)
+        return result
+
+    def corrwith(self, other: DataFrame | Series, drop: bool=False, method: CorrelationMethod='pearson', numeric_only: bool=False) -> DataFrame:
+        warnings.warn('DataFrameGroupBy.corrwith is deprecated', FutureWarning, stacklevel=find_stack_level())
+        result = self._op_via_apply('corrwith', other=other, drop=drop, method=method, numeric_only=numeric_only)
+        return result
+
+def _wrap_transform_general_frame(obj: DataFrame, group: DataFrame, res: DataFrame | Series) -> DataFrame:
+    from pandas import concat
+    if isinstance(res, Series):
+        if res.index.is_(obj.index):
+            res_frame = concat([res] * len(group.columns), axis=1, ignore_index=True)
+            res_frame.columns = group.columns
+            res_frame.index = group.index
+        else:
+            res_frame = obj._constructor(np.tile(res.values, (len(group.index), 1)), columns=group.columns, index=group.index)
+        assert isinstance(res_frame, DataFrame)
+        return res_frame
+    elif isinstance(res, DataFrame) and (not res.index.is_(group.index)):
+        return res._align_frame(group)[0]
+    else:
+        return res
+
+# File: pandas-main/pandas/core/groupby/groupby.py
+""""""
+from __future__ import annotations
+from collections.abc import Callable, Hashable, Iterable, Iterator, Mapping, Sequence
+import datetime
+from functools import partial, wraps
+from textwrap import dedent
+from typing import TYPE_CHECKING, Literal, TypeVar, Union, cast, final, overload
+import warnings
+import numpy as np
+from pandas._libs import Timestamp, lib
+from pandas._libs.algos import rank_1d
+import pandas._libs.groupby as libgroupby
+from pandas._libs.missing import NA
+from pandas._typing import AnyArrayLike, ArrayLike, DtypeObj, IndexLabel, IntervalClosedType, NDFrameT, PositionalIndexer, RandomState, npt
+from pandas.compat.numpy import function as nv
+from pandas.errors import AbstractMethodError, DataError
+from pandas.util._decorators import Appender, Substitution, cache_readonly, doc
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.cast import coerce_indexer_dtype, ensure_dtype_can_hold_na
+from pandas.core.dtypes.common import is_bool_dtype, is_float_dtype, is_hashable, is_integer, is_integer_dtype, is_list_like, is_numeric_dtype, is_object_dtype, is_scalar, needs_i8_conversion, pandas_dtype
+from pandas.core.dtypes.missing import isna, na_value_for_dtype, notna
+from pandas.core import algorithms, sample
+from pandas.core._numba import executor
+from pandas.core.arrays import ArrowExtensionArray, BaseMaskedArray, ExtensionArray, FloatingArray, IntegerArray, SparseArray
+from pandas.core.arrays.string_ import StringDtype
+from pandas.core.arrays.string_arrow import ArrowStringArray, ArrowStringArrayNumpySemantics
+from pandas.core.base import PandasObject, SelectionMixin
+import pandas.core.common as com
+from pandas.core.frame import DataFrame
+from pandas.core.generic import NDFrame
+from pandas.core.groupby import base, numba_, ops
+from pandas.core.groupby.grouper import get_grouper
+from pandas.core.groupby.indexing import GroupByIndexingMixin, GroupByNthSelector
+from pandas.core.indexes.api import Index, MultiIndex, default_index
+from pandas.core.internals.blocks import ensure_block_shape
+from pandas.core.series import Series
+from pandas.core.sorting import get_group_index_sorter
+from pandas.core.util.numba_ import get_jit_arguments, maybe_use_numba
+if TYPE_CHECKING:
+    from pandas._libs.tslibs import BaseOffset
+    from pandas._typing import Any, Concatenate, P, Self, T
+    from pandas.core.indexers.objects import BaseIndexer
+    from pandas.core.resample import Resampler
+    from pandas.core.window import ExpandingGroupby, ExponentialMovingWindowGroupby, RollingGroupby
+_common_see_also = '\n        See Also\n        --------\n        Series.%(name)s : Apply a function %(name)s to a Series.\n        DataFrame.%(name)s : Apply a function %(name)s\n            to each row or column of a DataFrame.\n'
+_groupby_agg_method_engine_template = "\nCompute {fname} of group values.\n\nParameters\n----------\nnumeric_only : bool, default {no}\n    Include only float, int, boolean columns.\n\n    .. versionchanged:: 2.0.0\n\n        numeric_only no longer accepts ``None``.\n\nmin_count : int, default {mc}\n    The required number of valid values to perform the operation. If fewer\n    than ``min_count`` non-NA values are present the result will be NA.\n\nengine : str, default None {e}\n    * ``'cython'`` : Runs rolling apply through C-extensions from cython.\n    * ``'numba'`` : Runs rolling apply through JIT compiled code from numba.\n        Only available when ``raw`` is set to ``True``.\n    * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``\n\nengine_kwargs : dict, default None {ek}\n    * For ``'cython'`` engine, there are no accepted ``engine_kwargs``\n    * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``\n        and ``parallel`` dictionary keys. The values must either be ``True`` or\n        ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is\n        ``{{'nopython': True, 'nogil': False, 'parallel': False}}`` and will be\n        applied to both the ``func`` and the ``apply`` groupby aggregation.\n\nReturns\n-------\nSeries or DataFrame\n    Computed {fname} of values within each group.\n\nSee Also\n--------\nSeriesGroupBy.min : Return the min of the group values.\nDataFrameGroupBy.min : Return the min of the group values.\nSeriesGroupBy.max : Return the max of the group values.\nDataFrameGroupBy.max : Return the max of the group values.\nSeriesGroupBy.sum : Return the sum of the group values.\nDataFrameGroupBy.sum : Return the sum of the group values.\n\nExamples\n--------\n{example}\n"
+_pipe_template = '\nApply a ``func`` with arguments to this %(klass)s object and return its result.\n\nUse `.pipe` when you want to improve readability by chaining together\nfunctions that expect Series, DataFrames, GroupBy or Resampler objects.\nInstead of writing\n\n>>> h = lambda x, arg2, arg3: x + 1 - arg2 * arg3\n>>> g = lambda x, arg1: x * 5 / arg1\n>>> f = lambda x: x ** 4\n>>> df = pd.DataFrame([["a", 4], ["b", 5]], columns=["group", "value"])\n>>> h(g(f(df.groupby(\'group\')), arg1=1), arg2=2, arg3=3)  # doctest: +SKIP\n\nYou can write\n\n>>> (df.groupby(\'group\')\n...    .pipe(f)\n...    .pipe(g, arg1=1)\n...    .pipe(h, arg2=2, arg3=3))  # doctest: +SKIP\n\nwhich is much more readable.\n\nParameters\n----------\nfunc : callable or tuple of (callable, str)\n    Function to apply to this %(klass)s object or, alternatively,\n    a `(callable, data_keyword)` tuple where `data_keyword` is a\n    string indicating the keyword of `callable` that expects the\n    %(klass)s object.\n*args : iterable, optional\n       Positional arguments passed into `func`.\n**kwargs : dict, optional\n         A dictionary of keyword arguments passed into `func`.\n\nReturns\n-------\n%(klass)s\n    The original object with the function `func` applied.\n\nSee Also\n--------\nSeries.pipe : Apply a function with arguments to a series.\nDataFrame.pipe: Apply a function with arguments to a dataframe.\napply : Apply function to each group instead of to the\n    full %(klass)s object.\n\nNotes\n-----\nSee more `here\n<https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#piping-function-calls>`_\n\nExamples\n--------\n%(examples)s\n'
+_transform_template = '\nCall function producing a same-indexed %(klass)s on each group.\n\nReturns a %(klass)s having the same indexes as the original object\nfilled with the transformed values.\n\nParameters\n----------\nfunc : function, str\n    Function to apply to each group. See the Notes section below for requirements.\n\n    Accepted inputs are:\n\n    - String\n    - Python function\n    - Numba JIT function with ``engine=\'numba\'`` specified.\n\n    Only passing a single function is supported with this engine.\n    If the ``\'numba\'`` engine is chosen, the function must be\n    a user defined function with ``values`` and ``index`` as the\n    first and second arguments respectively in the function signature.\n    Each group\'s index will be passed to the user defined function\n    and optionally available for use.\n\n    If a string is chosen, then it needs to be the name\n    of the groupby method you want to use.\n*args\n    Positional arguments to pass to func.\nengine : str, default None\n    * ``\'cython\'`` : Runs the function through C-extensions from cython.\n    * ``\'numba\'`` : Runs the function through JIT compiled code from numba.\n    * ``None`` : Defaults to ``\'cython\'`` or the global setting ``compute.use_numba``\n\nengine_kwargs : dict, default None\n    * For ``\'cython\'`` engine, there are no accepted ``engine_kwargs``\n    * For ``\'numba\'`` engine, the engine can accept ``nopython``, ``nogil``\n      and ``parallel`` dictionary keys. The values must either be ``True`` or\n      ``False``. The default ``engine_kwargs`` for the ``\'numba\'`` engine is\n      ``{\'nopython\': True, \'nogil\': False, \'parallel\': False}`` and will be\n      applied to the function\n\n**kwargs\n    Keyword arguments to be passed into func.\n\nReturns\n-------\n%(klass)s\n    %(klass)s with the same indexes as the original object filled\n    with transformed values.\n\nSee Also\n--------\n%(klass)s.groupby.apply : Apply function ``func`` group-wise and combine\n    the results together.\n%(klass)s.groupby.aggregate : Aggregate using one or more operations.\n%(klass)s.transform : Call ``func`` on self producing a %(klass)s with the\n    same axis shape as self.\n\nNotes\n-----\nEach group is endowed the attribute \'name\' in case you need to know\nwhich group you are working on.\n\nThe current implementation imposes three requirements on f:\n\n* f must return a value that either has the same shape as the input\n  subframe or can be broadcast to the shape of the input subframe.\n  For example, if `f` returns a scalar it will be broadcast to have the\n  same shape as the input subframe.\n* if this is a DataFrame, f must support application column-by-column\n  in the subframe. If f also supports application to the entire subframe,\n  then a fast path is used starting from the second chunk.\n* f must not mutate groups. Mutation is not supported and may\n  produce unexpected results. See :ref:`gotchas.udf-mutation` for more details.\n\nWhen using ``engine=\'numba\'``, there will be no "fall back" behavior internally.\nThe group data and group index will be passed as numpy arrays to the JITed\nuser defined function, and no alternative execution attempts will be tried.\n\n.. versionchanged:: 1.3.0\n\n    The resulting dtype will reflect the return value of the passed ``func``,\n    see the examples below.\n\n.. versionchanged:: 2.0.0\n\n    When using ``.transform`` on a grouped DataFrame and the transformation function\n    returns a DataFrame, pandas now aligns the result\'s index\n    with the input\'s index. You can call ``.to_numpy()`` on the\n    result of the transformation function to avoid alignment.\n\nExamples\n--------\n%(example)s'
+_agg_template_series = '\nAggregate using one or more operations.\n\nParameters\n----------\nfunc : function, str, list, dict or None\n    Function to use for aggregating the data. If a function, must either\n    work when passed a {klass} or when passed to {klass}.apply.\n\n    Accepted combinations are:\n\n    - function\n    - string function name\n    - list of functions and/or function names, e.g. ``[np.sum, \'mean\']``\n    - None, in which case ``**kwargs`` are used with Named Aggregation. Here the\n      output has one column for each element in ``**kwargs``. The name of the\n      column is keyword, whereas the value determines the aggregation used to compute\n      the values in the column.\n\n      Can also accept a Numba JIT function with\n      ``engine=\'numba\'`` specified. Only passing a single function is supported\n      with this engine.\n\n      If the ``\'numba\'`` engine is chosen, the function must be\n      a user defined function with ``values`` and ``index`` as the\n      first and second arguments respectively in the function signature.\n      Each group\'s index will be passed to the user defined function\n      and optionally available for use.\n\n    .. deprecated:: 2.1.0\n\n        Passing a dictionary is deprecated and will raise in a future version\n        of pandas. Pass a list of aggregations instead.\n*args\n    Positional arguments to pass to func.\nengine : str, default None\n    * ``\'cython\'`` : Runs the function through C-extensions from cython.\n    * ``\'numba\'`` : Runs the function through JIT compiled code from numba.\n    * ``None`` : Defaults to ``\'cython\'`` or globally setting ``compute.use_numba``\n\nengine_kwargs : dict, default None\n    * For ``\'cython\'`` engine, there are no accepted ``engine_kwargs``\n    * For ``\'numba\'`` engine, the engine can accept ``nopython``, ``nogil``\n      and ``parallel`` dictionary keys. The values must either be ``True`` or\n      ``False``. The default ``engine_kwargs`` for the ``\'numba\'`` engine is\n      ``{{\'nopython\': True, \'nogil\': False, \'parallel\': False}}`` and will be\n      applied to the function\n\n**kwargs\n    * If ``func`` is None, ``**kwargs`` are used to define the output names and\n      aggregations via Named Aggregation. See ``func`` entry.\n    * Otherwise, keyword arguments to be passed into func.\n\nReturns\n-------\n{klass}\n\nSee Also\n--------\n{klass}GroupBy.apply : Apply function func group-wise\n    and combine the results together.\n{klass}GroupBy.transform : Transforms the Series on each group\n    based on the given function.\n{klass}.aggregate : Aggregate using one or more operations.\n\nNotes\n-----\nWhen using ``engine=\'numba\'``, there will be no "fall back" behavior internally.\nThe group data and group index will be passed as numpy arrays to the JITed\nuser defined function, and no alternative execution attempts will be tried.\n\nFunctions that mutate the passed object can produce unexpected\nbehavior or errors and are not supported. See :ref:`gotchas.udf-mutation`\nfor more details.\n\n.. versionchanged:: 1.3.0\n\n    The resulting dtype will reflect the return value of the passed ``func``,\n    see the examples below.\n{examples}'
+_agg_template_frame = '\nAggregate using one or more operations.\n\nParameters\n----------\nfunc : function, str, list, dict or None\n    Function to use for aggregating the data. If a function, must either\n    work when passed a {klass} or when passed to {klass}.apply.\n\n    Accepted combinations are:\n\n    - function\n    - string function name\n    - list of functions and/or function names, e.g. ``[np.sum, \'mean\']``\n    - dict of index labels -> functions, function names or list of such.\n    - None, in which case ``**kwargs`` are used with Named Aggregation. Here the\n      output has one column for each element in ``**kwargs``. The name of the\n      column is keyword, whereas the value determines the aggregation used to compute\n      the values in the column.\n\n      Can also accept a Numba JIT function with\n      ``engine=\'numba\'`` specified. Only passing a single function is supported\n      with this engine.\n\n      If the ``\'numba\'`` engine is chosen, the function must be\n      a user defined function with ``values`` and ``index`` as the\n      first and second arguments respectively in the function signature.\n      Each group\'s index will be passed to the user defined function\n      and optionally available for use.\n\n*args\n    Positional arguments to pass to func.\nengine : str, default None\n    * ``\'cython\'`` : Runs the function through C-extensions from cython.\n    * ``\'numba\'`` : Runs the function through JIT compiled code from numba.\n    * ``None`` : Defaults to ``\'cython\'`` or globally setting ``compute.use_numba``\n\nengine_kwargs : dict, default None\n    * For ``\'cython\'`` engine, there are no accepted ``engine_kwargs``\n    * For ``\'numba\'`` engine, the engine can accept ``nopython``, ``nogil``\n      and ``parallel`` dictionary keys. The values must either be ``True`` or\n      ``False``. The default ``engine_kwargs`` for the ``\'numba\'`` engine is\n      ``{{\'nopython\': True, \'nogil\': False, \'parallel\': False}}`` and will be\n      applied to the function\n\n**kwargs\n    * If ``func`` is None, ``**kwargs`` are used to define the output names and\n      aggregations via Named Aggregation. See ``func`` entry.\n    * Otherwise, keyword arguments to be passed into func.\n\nReturns\n-------\n{klass}\n\nSee Also\n--------\n{klass}.groupby.apply : Apply function func group-wise\n    and combine the results together.\n{klass}.groupby.transform : Transforms the Series on each group\n    based on the given function.\n{klass}.aggregate : Aggregate using one or more operations.\n\nNotes\n-----\nWhen using ``engine=\'numba\'``, there will be no "fall back" behavior internally.\nThe group data and group index will be passed as numpy arrays to the JITed\nuser defined function, and no alternative execution attempts will be tried.\n\nFunctions that mutate the passed object can produce unexpected\nbehavior or errors and are not supported. See :ref:`gotchas.udf-mutation`\nfor more details.\n\n.. versionchanged:: 1.3.0\n\n    The resulting dtype will reflect the return value of the passed ``func``,\n    see the examples below.\n{examples}'
+
+@final
+class GroupByPlot(PandasObject):
+
+    def __init__(self, groupby: GroupBy) -> None:
+        self._groupby = groupby
+
+    def __call__(self, *args, **kwargs):
+
+        def f(self):
+            return self.plot(*args, **kwargs)
+        f.__name__ = 'plot'
+        return self._groupby._python_apply_general(f, self._groupby._selected_obj)
+
+    def __getattr__(self, name: str):
+
+        def attr(*args, **kwargs):
+
+            def f(self):
+                return getattr(self.plot, name)(*args, **kwargs)
+            return self._groupby._python_apply_general(f, self._groupby._selected_obj)
+        return attr
+_KeysArgType = Union[Hashable, list[Hashable], Callable[[Hashable], Hashable], list[Callable[[Hashable], Hashable]], Mapping[Hashable, Hashable]]
+
+class BaseGroupBy(PandasObject, SelectionMixin[NDFrameT], GroupByIndexingMixin):
+    _hidden_attrs = PandasObject._hidden_attrs | {'as_index', 'dropna', 'exclusions', 'grouper', 'group_keys', 'keys', 'level', 'obj', 'observed', 'sort'}
+    _grouper: ops.BaseGrouper
+    keys: _KeysArgType | None = None
+    level: IndexLabel | None = None
+    group_keys: bool
+
+    @final
+    def __len__(self) -> int:
+        return self._grouper.ngroups
+
+    @final
+    def __repr__(self) -> str:
+        return object.__repr__(self)
+
+    @final
+    @property
+    def groups(self) -> dict[Hashable, Index]:
+        if isinstance(self.keys, list) and len(self.keys) == 1:
+            warnings.warn("`groups` by one element list returns scalar is deprecated and will be removed. In a future version `groups` by one element list will return tuple. Use ``df.groupby(by='a').groups`` instead of ``df.groupby(by=['a']).groups`` to avoid this warning", FutureWarning, stacklevel=find_stack_level())
+        return self._grouper.groups
+
+    @final
+    @property
+    def ngroups(self) -> int:
+        return self._grouper.ngroups
+
+    @final
+    @property
+    def indices(self) -> dict[Hashable, npt.NDArray[np.intp]]:
+        return self._grouper.indices
+
+    @final
+    def _get_indices(self, names):
+
+        def get_converter(s):
+            if isinstance(s, datetime.datetime):
+                return lambda key: Timestamp(key)
+            elif isinstance(s, np.datetime64):
+                return lambda key: Timestamp(key).asm8
+            else:
+                return lambda key: key
+        if len(names) == 0:
+            return []
+        if len(self.indices) > 0:
+            index_sample = next(iter(self.indices))
+        else:
+            index_sample = None
+        name_sample = names[0]
+        if isinstance(index_sample, tuple):
+            if not isinstance(name_sample, tuple):
+                msg = 'must supply a tuple to get_group with multiple grouping keys'
+                raise ValueError(msg)
+            if not len(name_sample) == len(index_sample):
+                try:
+                    return [self.indices[name] for name in names]
+                except KeyError as err:
+                    msg = 'must supply a same-length tuple to get_group with multiple grouping keys'
+                    raise ValueError(msg) from err
+            converters = (get_converter(s) for s in index_sample)
+            names = (tuple((f(n) for (f, n) in zip(converters, name))) for name in names)
+        else:
+            converter = get_converter(index_sample)
+            names = (converter(name) for name in names)
+        return [self.indices.get(name, []) for name in names]
+
+    @final
+    def _get_index(self, name):
+        return self._get_indices([name])[0]
+
+    @final
+    @cache_readonly
+    def _selected_obj(self):
+        if isinstance(self.obj, Series):
+            return self.obj
+        if self._selection is not None:
+            if is_hashable(self._selection):
+                return self.obj[self._selection]
+            return self._obj_with_exclusions
+        return self.obj
+
+    @final
+    def _dir_additions(self) -> set[str]:
+        return self.obj._dir_additions()
+
+    @overload
+    def pipe(self, func: Callable[Concatenate[Self, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+        ...
+
+    @overload
+    def pipe(self, func: tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T:
+        ...
+
+    @Substitution(klass='GroupBy', examples=dedent("        >>> df = pd.DataFrame({'A': 'a b a b'.split(), 'B': [1, 2, 3, 4]})\n        >>> df\n           A  B\n        0  a  1\n        1  b  2\n        2  a  3\n        3  b  4\n\n        To get the difference between each groups maximum and minimum value in one\n        pass, you can do\n\n        >>> df.groupby('A').pipe(lambda x: x.max() - x.min())\n           B\n        A\n        a  2\n        b  2"))
+    @Appender(_pipe_template)
+    def pipe(self, func: Callable[Concatenate[Self, P], T] | tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T:
+        return com.pipe(self, func, *args, **kwargs)
+
+    @final
+    def get_group(self, name) -> DataFrame | Series:
+        keys = self.keys
+        level = self.level
+        if is_list_like(level) and len(level) == 1 or (is_list_like(keys) and len(keys) == 1):
+            if isinstance(name, tuple) and len(name) == 1:
+                name = name[0]
+            else:
+                raise KeyError(name)
+        inds = self._get_index(name)
+        if not len(inds):
+            raise KeyError(name)
+        return self._selected_obj.iloc[inds]
+
+    @final
+    def __iter__(self) -> Iterator[tuple[Hashable, NDFrameT]]:
+        keys = self.keys
+        level = self.level
+        result = self._grouper.get_iterator(self._selected_obj)
+        if is_list_like(level) and len(level) == 1 or (isinstance(keys, list) and len(keys) == 1):
+            result = (((key,), group) for (key, group) in result)
+        return result
+OutputFrameOrSeries = TypeVar('OutputFrameOrSeries', bound=NDFrame)
+
+class GroupBy(BaseGroupBy[NDFrameT]):
+    _grouper: ops.BaseGrouper
+    as_index: bool
+
+    @final
+    def __init__(self, obj: NDFrameT, keys: _KeysArgType | None=None, level: IndexLabel | None=None, grouper: ops.BaseGrouper | None=None, exclusions: frozenset[Hashable] | None=None, selection: IndexLabel | None=None, as_index: bool=True, sort: bool=True, group_keys: bool=True, observed: bool=False, dropna: bool=True) -> None:
+        self._selection = selection
+        assert isinstance(obj, NDFrame), type(obj)
+        self.level = level
+        self.as_index = as_index
+        self.keys = keys
+        self.sort = sort
+        self.group_keys = group_keys
+        self.dropna = dropna
+        if grouper is None:
+            (grouper, exclusions, obj) = get_grouper(obj, keys, level=level, sort=sort, observed=observed, dropna=self.dropna)
+        self.observed = observed
+        self.obj = obj
+        self._grouper = grouper
+        self.exclusions = frozenset(exclusions) if exclusions else frozenset()
+
+    def __getattr__(self, attr: str):
+        if attr in self._internal_names_set:
+            return object.__getattribute__(self, attr)
+        if attr in self.obj:
+            return self[attr]
+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{attr}'")
+
+    @final
+    def _op_via_apply(self, name: str, *args, **kwargs):
+        f = getattr(type(self._obj_with_exclusions), name)
+
+        def curried(x):
+            return f(x, *args, **kwargs)
+        curried.__name__ = name
+        if name in base.plotting_methods:
+            return self._python_apply_general(curried, self._selected_obj)
+        is_transform = name in base.transformation_kernels
+        result = self._python_apply_general(curried, self._obj_with_exclusions, is_transform=is_transform, not_indexed_same=not is_transform)
+        if self._grouper.has_dropped_na and is_transform:
+            result = self._set_result_index_ordered(result)
+        return result
+
+    @final
+    def _concat_objects(self, values, not_indexed_same: bool=False, is_transform: bool=False):
+        from pandas.core.reshape.concat import concat
+        if self.group_keys and (not is_transform):
+            if self.as_index:
+                group_keys = self._grouper.result_index
+                group_levels = self._grouper.levels
+                group_names = self._grouper.names
+                result = concat(values, axis=0, keys=group_keys, levels=group_levels, names=group_names, sort=False)
+            else:
+                result = concat(values, axis=0)
+        elif not not_indexed_same:
+            result = concat(values, axis=0)
+            ax = self._selected_obj.index
+            if self.dropna:
+                labels = self._grouper.ids
+                mask = labels != -1
+                ax = ax[mask]
+            if ax.has_duplicates and (not result.axes[0].equals(ax)):
+                target = algorithms.unique1d(ax._values)
+                (indexer, _) = result.index.get_indexer_non_unique(target)
+                result = result.take(indexer, axis=0)
+            else:
+                result = result.reindex(ax, axis=0)
+        else:
+            result = concat(values, axis=0)
+        if self.obj.ndim == 1:
+            name = self.obj.name
+        elif is_hashable(self._selection):
+            name = self._selection
+        else:
+            name = None
+        if isinstance(result, Series) and name is not None:
+            result.name = name
+        return result
+
+    @final
+    def _set_result_index_ordered(self, result: OutputFrameOrSeries) -> OutputFrameOrSeries:
+        index = self.obj.index
+        if self._grouper.is_monotonic and (not self._grouper.has_dropped_na):
+            result = result.set_axis(index, axis=0)
+            return result
+        original_positions = Index(self._grouper.result_ilocs)
+        result = result.set_axis(original_positions, axis=0)
+        result = result.sort_index(axis=0)
+        if self._grouper.has_dropped_na:
+            result = result.reindex(default_index(len(index)), axis=0)
+        result = result.set_axis(index, axis=0)
+        return result
+
+    @final
+    def _insert_inaxis_grouper(self, result: Series | DataFrame, qs: npt.NDArray[np.float64] | None=None) -> DataFrame:
+        if isinstance(result, Series):
+            result = result.to_frame()
+        n_groupings = len(self._grouper.groupings)
+        if qs is not None:
+            result.insert(0, f'level_{n_groupings}', np.tile(qs, len(result) // len(qs)))
+        for (level, (name, lev)) in enumerate(zip(reversed(self._grouper.names), self._grouper.get_group_levels())):
+            if name is None:
+                name = 'index' if n_groupings == 1 and qs is None else f'level_{n_groupings - level - 1}'
+            if name not in result.columns:
+                if qs is None:
+                    result.insert(0, name, lev)
+                else:
+                    result.insert(0, name, Index(np.repeat(lev, len(qs))))
+        return result
+
+    @final
+    def _wrap_aggregated_output(self, result: Series | DataFrame, qs: npt.NDArray[np.float64] | None=None):
+        if not self.as_index:
+            result = self._insert_inaxis_grouper(result, qs=qs)
+            result = result._consolidate()
+            result.index = default_index(len(result))
+        else:
+            index = self._grouper.result_index
+            if qs is not None:
+                index = _insert_quantile_level(index, qs)
+            result.index = index
+        return result
+
+    def _wrap_applied_output(self, data, values: list, not_indexed_same: bool=False, is_transform: bool=False):
+        raise AbstractMethodError(self)
+
+    @final
+    def _numba_prep(self, data: DataFrame):
+        ngroups = self._grouper.ngroups
+        sorted_index = self._grouper.result_ilocs
+        sorted_ids = self._grouper._sorted_ids
+        sorted_data = data.take(sorted_index, axis=0).to_numpy()
+        index_data = data.index
+        if isinstance(index_data, MultiIndex):
+            if len(self._grouper.groupings) > 1:
+                raise NotImplementedError("Grouping with more than 1 grouping labels and a MultiIndex is not supported with engine='numba'")
+            group_key = self._grouper.groupings[0].name
+            index_data = index_data.get_level_values(group_key)
+        sorted_index_data = index_data.take(sorted_index).to_numpy()
+        (starts, ends) = lib.generate_slices(sorted_ids, ngroups)
+        return (starts, ends, sorted_index_data, sorted_data)
+
+    def _numba_agg_general(self, func: Callable, dtype_mapping: dict[np.dtype, Any], engine_kwargs: dict[str, bool] | None, **aggregator_kwargs):
+        if not self.as_index:
+            raise NotImplementedError('as_index=False is not supported. Use .reset_index() instead.')
+        data = self._obj_with_exclusions
+        df = data if data.ndim == 2 else data.to_frame()
+        aggregator = executor.generate_shared_aggregator(func, dtype_mapping, True, **get_jit_arguments(engine_kwargs))
+        ids = self._grouper.ids
+        ngroups = self._grouper.ngroups
+        res_mgr = df._mgr.apply(aggregator, labels=ids, ngroups=ngroups, **aggregator_kwargs)
+        res_mgr.axes[1] = self._grouper.result_index
+        result = df._constructor_from_mgr(res_mgr, axes=res_mgr.axes)
+        if data.ndim == 1:
+            result = result.squeeze('columns')
+            result.name = data.name
+        else:
+            result.columns = data.columns
+        return result
+
+    @final
+    def _transform_with_numba(self, func, *args, engine_kwargs=None, **kwargs):
+        data = self._obj_with_exclusions
+        index_sorting = self._grouper.result_ilocs
+        df = data if data.ndim == 2 else data.to_frame()
+        (starts, ends, sorted_index, sorted_data) = self._numba_prep(df)
+        numba_.validate_udf(func)
+        numba_transform_func = numba_.generate_numba_transform_func(func, **get_jit_arguments(engine_kwargs, kwargs))
+        result = numba_transform_func(sorted_data, sorted_index, starts, ends, len(df.columns), *args)
+        result = result.take(np.argsort(index_sorting), axis=0)
+        index = data.index
+        if data.ndim == 1:
+            result_kwargs = {'name': data.name}
+            result = result.ravel()
+        else:
+            result_kwargs = {'columns': data.columns}
+        return data._constructor(result, index=index, **result_kwargs)
+
+    @final
+    def _aggregate_with_numba(self, func, *args, engine_kwargs=None, **kwargs):
+        data = self._obj_with_exclusions
+        df = data if data.ndim == 2 else data.to_frame()
+        (starts, ends, sorted_index, sorted_data) = self._numba_prep(df)
+        numba_.validate_udf(func)
+        numba_agg_func = numba_.generate_numba_agg_func(func, **get_jit_arguments(engine_kwargs, kwargs))
+        result = numba_agg_func(sorted_data, sorted_index, starts, ends, len(df.columns), *args)
+        index = self._grouper.result_index
+        if data.ndim == 1:
+            result_kwargs = {'name': data.name}
+            result = result.ravel()
+        else:
+            result_kwargs = {'columns': data.columns}
+        res = data._constructor(result, index=index, **result_kwargs)
+        if not self.as_index:
+            res = self._insert_inaxis_grouper(res)
+            res.index = default_index(len(res))
+        return res
+
+    def apply(self, func, *args, include_groups: bool=True, **kwargs) -> NDFrameT:
+        if isinstance(func, str):
+            if hasattr(self, func):
+                res = getattr(self, func)
+                if callable(res):
+                    return res(*args, **kwargs)
+                elif args or kwargs:
+                    raise ValueError(f'Cannot pass arguments to property {func}')
+                return res
+            else:
+                raise TypeError(f"apply func should be callable, not '{func}'")
+        elif args or kwargs:
+            if callable(func):
+
+                @wraps(func)
+                def f(g):
+                    return func(g, *args, **kwargs)
+            else:
+                raise ValueError('func must be a callable if args or kwargs are supplied')
+        else:
+            f = func
+        if not include_groups:
+            return self._python_apply_general(f, self._obj_with_exclusions)
+        try:
+            result = self._python_apply_general(f, self._selected_obj)
+            if not isinstance(self.obj, Series) and self._selection is None and (self._selected_obj.shape != self._obj_with_exclusions.shape):
+                warnings.warn(message=_apply_groupings_depr.format(type(self).__name__, 'apply'), category=DeprecationWarning, stacklevel=find_stack_level())
+        except TypeError:
+            return self._python_apply_general(f, self._obj_with_exclusions)
+        return result
+
+    @final
+    def _python_apply_general(self, f: Callable, data: DataFrame | Series, not_indexed_same: bool | None=None, is_transform: bool=False, is_agg: bool=False) -> NDFrameT:
+        (values, mutated) = self._grouper.apply_groupwise(f, data)
+        if not_indexed_same is None:
+            not_indexed_same = mutated
+        return self._wrap_applied_output(data, values, not_indexed_same, is_transform)
+
+    @final
+    def _agg_general(self, numeric_only: bool=False, min_count: int=-1, *, alias: str, npfunc: Callable | None=None, **kwargs):
+        result = self._cython_agg_general(how=alias, alt=npfunc, numeric_only=numeric_only, min_count=min_count, **kwargs)
+        return result.__finalize__(self.obj, method='groupby')
+
+    def _agg_py_fallback(self, how: str, values: ArrayLike, ndim: int, alt: Callable) -> ArrayLike:
+        assert alt is not None
+        if values.ndim == 1:
+            ser = Series(values, copy=False)
+        else:
+            df = DataFrame(values.T, dtype=values.dtype)
+            assert df.shape[1] == 1
+            ser = df.iloc[:, 0]
+        try:
+            res_values = self._grouper.agg_series(ser, alt, preserve_dtype=True)
+        except Exception as err:
+            msg = f'agg function failed [how->{how},dtype->{ser.dtype}]'
+            raise type(err)(msg) from err
+        if ser.dtype == object:
+            res_values = res_values.astype(object, copy=False)
+        return ensure_block_shape(res_values, ndim=ndim)
+
+    @final
+    def _cython_agg_general(self, how: str, alt: Callable | None=None, numeric_only: bool=False, min_count: int=-1, **kwargs):
+        data = self._get_data_to_aggregate(numeric_only=numeric_only, name=how)
+
+        def array_func(values: ArrayLike) -> ArrayLike:
+            try:
+                result = self._grouper._cython_operation('aggregate', values, how, axis=data.ndim - 1, min_count=min_count, **kwargs)
+            except NotImplementedError:
+                if how in ['any', 'all'] and isinstance(values, SparseArray):
+                    pass
+                elif alt is None or how in ['any', 'all', 'std', 'sem']:
+                    raise
+            else:
+                return result
+            assert alt is not None
+            result = self._agg_py_fallback(how, values, ndim=data.ndim, alt=alt)
+            return result
+        new_mgr = data.grouped_reduce(array_func)
+        res = self._wrap_agged_manager(new_mgr)
+        if how in ['idxmin', 'idxmax']:
+            res = self._wrap_idxmax_idxmin(res)
+        out = self._wrap_aggregated_output(res)
+        return out
+
+    def _cython_transform(self, how: str, numeric_only: bool=False, **kwargs):
+        raise AbstractMethodError(self)
+
+    @final
+    def _transform(self, func, *args, engine=None, engine_kwargs=None, **kwargs):
+        if not isinstance(func, str):
+            return self._transform_general(func, engine, engine_kwargs, *args, **kwargs)
+        elif func not in base.transform_kernel_allowlist:
+            msg = f"'{func}' is not a valid function name for transform(name)"
+            raise ValueError(msg)
+        elif func in base.cythonized_kernels or func in base.transformation_kernels:
+            if engine is not None:
+                kwargs['engine'] = engine
+                kwargs['engine_kwargs'] = engine_kwargs
+            return getattr(self, func)(*args, **kwargs)
+        else:
+            if self.observed:
+                return self._reduction_kernel_transform(func, *args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+            with com.temp_setattr(self, 'observed', True), com.temp_setattr(self, '_grouper', self._grouper.observed_grouper):
+                return self._reduction_kernel_transform(func, *args, engine=engine, engine_kwargs=engine_kwargs, **kwargs)
+
+    @final
+    def _reduction_kernel_transform(self, func, *args, engine=None, engine_kwargs=None, **kwargs):
+        with com.temp_setattr(self, 'as_index', True):
+            if func in ['idxmin', 'idxmax']:
+                func = cast(Literal['idxmin', 'idxmax'], func)
+                result = self._idxmax_idxmin(func, True, *args, **kwargs)
+            else:
+                if engine is not None:
+                    kwargs['engine'] = engine
+                    kwargs['engine_kwargs'] = engine_kwargs
+                result = getattr(self, func)(*args, **kwargs)
+        return self._wrap_transform_fast_result(result)
+
+    @final
+    def _wrap_transform_fast_result(self, result: NDFrameT) -> NDFrameT:
+        obj = self._obj_with_exclusions
+        ids = self._grouper.ids
+        result = result.reindex(self._grouper.result_index, axis=0)
+        if self.obj.ndim == 1:
+            out = algorithms.take_nd(result._values, ids)
+            output = obj._constructor(out, index=obj.index, name=obj.name)
+        else:
+            new_ax = result.index.take(ids)
+            output = result._reindex_with_indexers({0: (new_ax, ids)}, allow_dups=True)
+            output = output.set_axis(obj.index, axis=0)
+        return output
+
+    @final
+    def _apply_filter(self, indices, dropna):
+        if len(indices) == 0:
+            indices = np.array([], dtype='int64')
+        else:
+            indices = np.sort(np.concatenate(indices))
+        if dropna:
+            filtered = self._selected_obj.take(indices, axis=0)
+        else:
+            mask = np.empty(len(self._selected_obj.index), dtype=bool)
+            mask.fill(False)
+            mask[indices.astype(int)] = True
+            mask = np.tile(mask, list(self._selected_obj.shape[1:]) + [1]).T
+            filtered = self._selected_obj.where(mask)
+        return filtered
+
+    @final
+    def _cumcount_array(self, ascending: bool=True) -> np.ndarray:
+        ids = self._grouper.ids
+        ngroups = self._grouper.ngroups
+        sorter = get_group_index_sorter(ids, ngroups)
+        (ids, count) = (ids[sorter], len(ids))
+        if count == 0:
+            return np.empty(0, dtype=np.int64)
+        run = np.r_[True, ids[:-1] != ids[1:]]
+        rep = np.diff(np.r_[np.nonzero(run)[0], count])
+        out = (~run).cumsum()
+        if ascending:
+            out -= np.repeat(out[run], rep)
+        else:
+            out = np.repeat(out[np.r_[run[1:], True]], rep) - out
+        if self._grouper.has_dropped_na:
+            out = np.where(ids == -1, np.nan, out.astype(np.float64, copy=False))
+        else:
+            out = out.astype(np.int64, copy=False)
+        rev = np.empty(count, dtype=np.intp)
+        rev[sorter] = np.arange(count, dtype=np.intp)
+        return out[rev]
+
+    @final
+    @property
+    def _obj_1d_constructor(self) -> Callable:
+        if isinstance(self.obj, DataFrame):
+            return self.obj._constructor_sliced
+        assert isinstance(self.obj, Series)
+        return self.obj._constructor
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def any(self, skipna: bool=True) -> NDFrameT:
+        return self._cython_agg_general('any', alt=lambda x: Series(x, copy=False).any(skipna=skipna), skipna=skipna)
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def all(self, skipna: bool=True) -> NDFrameT:
+        return self._cython_agg_general('all', alt=lambda x: Series(x, copy=False).all(skipna=skipna), skipna=skipna)
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def count(self) -> NDFrameT:
+        data = self._get_data_to_aggregate()
+        ids = self._grouper.ids
+        ngroups = self._grouper.ngroups
+        mask = ids != -1
+        is_series = data.ndim == 1
+
+        def hfunc(bvalues: ArrayLike) -> ArrayLike:
+            if bvalues.ndim == 1:
+                masked = mask & ~isna(bvalues).reshape(1, -1)
+            else:
+                masked = mask & ~isna(bvalues)
+            counted = lib.count_level_2d(masked, labels=ids, max_bin=ngroups)
+            if isinstance(bvalues, BaseMaskedArray):
+                return IntegerArray(counted[0], mask=np.zeros(counted.shape[1], dtype=np.bool_))
+            elif isinstance(bvalues, ArrowExtensionArray) and (not isinstance(bvalues.dtype, StringDtype)):
+                dtype = pandas_dtype('int64[pyarrow]')
+                return type(bvalues)._from_sequence(counted[0], dtype=dtype)
+            if is_series:
+                assert counted.ndim == 2
+                assert counted.shape[0] == 1
+                return counted[0]
+            return counted
+        new_mgr = data.grouped_reduce(hfunc)
+        new_obj = self._wrap_agged_manager(new_mgr)
+        result = self._wrap_aggregated_output(new_obj)
+        return result
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def mean(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        if maybe_use_numba(engine):
+            from pandas.core._numba.kernels import grouped_mean
+            return self._numba_agg_general(grouped_mean, executor.float_dtype_mapping, engine_kwargs, min_periods=0)
+        else:
+            result = self._cython_agg_general('mean', alt=lambda x: Series(x, copy=False).mean(numeric_only=numeric_only), numeric_only=numeric_only)
+            return result.__finalize__(self.obj, method='groupby')
+
+    @final
+    def median(self, numeric_only: bool=False) -> NDFrameT:
+        result = self._cython_agg_general('median', alt=lambda x: Series(x, copy=False).median(numeric_only=numeric_only), numeric_only=numeric_only)
+        return result.__finalize__(self.obj, method='groupby')
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def std(self, ddof: int=1, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None, numeric_only: bool=False):
+        if maybe_use_numba(engine):
+            from pandas.core._numba.kernels import grouped_var
+            return np.sqrt(self._numba_agg_general(grouped_var, executor.float_dtype_mapping, engine_kwargs, min_periods=0, ddof=ddof))
+        else:
+            return self._cython_agg_general('std', alt=lambda x: Series(x, copy=False).std(ddof=ddof), numeric_only=numeric_only, ddof=ddof)
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def var(self, ddof: int=1, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None, numeric_only: bool=False):
+        if maybe_use_numba(engine):
+            from pandas.core._numba.kernels import grouped_var
+            return self._numba_agg_general(grouped_var, executor.float_dtype_mapping, engine_kwargs, min_periods=0, ddof=ddof)
+        else:
+            return self._cython_agg_general('var', alt=lambda x: Series(x, copy=False).var(ddof=ddof), numeric_only=numeric_only, ddof=ddof)
+
+    @final
+    def _value_counts(self, subset: Sequence[Hashable] | None=None, normalize: bool=False, sort: bool=True, ascending: bool=False, dropna: bool=True) -> DataFrame | Series:
+        name = 'proportion' if normalize else 'count'
+        df = self.obj
+        obj = self._obj_with_exclusions
+        in_axis_names = {grouping.name for grouping in self._grouper.groupings if grouping.in_axis}
+        if isinstance(obj, Series):
+            _name = obj.name
+            keys: Iterable[Series] = [] if _name in in_axis_names else [obj]
+        else:
+            unique_cols = set(obj.columns)
+            if subset is not None:
+                subsetted = set(subset)
+                clashing = subsetted & set(in_axis_names)
+                if clashing:
+                    raise ValueError(f'Keys {clashing} in subset cannot be in the groupby column keys.')
+                doesnt_exist = subsetted - unique_cols
+                if doesnt_exist:
+                    raise ValueError(f'Keys {doesnt_exist} in subset do not exist in the DataFrame.')
+            else:
+                subsetted = unique_cols
+            keys = (obj.iloc[:, idx] for (idx, _name) in enumerate(obj.columns) if _name not in in_axis_names and _name in subsetted)
+        groupings = list(self._grouper.groupings)
+        for key in keys:
+            (grouper, _, _) = get_grouper(df, key=key, sort=self.sort, observed=False, dropna=dropna)
+            groupings += list(grouper.groupings)
+        gb = df.groupby(groupings, sort=self.sort, observed=self.observed, dropna=self.dropna)
+        result_series = cast(Series, gb.size())
+        result_series.name = name
+        if sort:
+            result_series = result_series.sort_values(ascending=ascending, kind='stable')
+        if self.sort:
+            names = result_series.index.names
+            result_series.index.names = range(len(names))
+            index_level = range(len(self._grouper.groupings))
+            result_series = result_series.sort_index(level=index_level, sort_remaining=False)
+            result_series.index.names = names
+        if normalize:
+            levels = list(range(len(self._grouper.groupings), result_series.index.nlevels))
+            indexed_group_size = result_series.groupby(result_series.index.droplevel(levels), sort=self.sort, dropna=self.dropna, observed=False).transform('sum')
+            result_series /= indexed_group_size
+            result_series = result_series.fillna(0.0)
+        result: Series | DataFrame
+        if self.as_index:
+            result = result_series
+        else:
+            index = result_series.index
+            columns = com.fill_missing_names(index.names)
+            if name in columns:
+                raise ValueError(f"Column label '{name}' is duplicate of result column")
+            result_series.name = name
+            result_series.index = index.set_names(range(len(columns)))
+            result_frame = result_series.reset_index()
+            orig_dtype = self._grouper.groupings[0].obj.columns.dtype
+            cols = Index(columns, dtype=orig_dtype).insert(len(columns), name)
+            result_frame.columns = cols
+            result = result_frame
+        return result.__finalize__(self.obj, method='value_counts')
+
+    @final
+    def sem(self, ddof: int=1, numeric_only: bool=False) -> NDFrameT:
+        if numeric_only and self.obj.ndim == 1 and (not is_numeric_dtype(self.obj.dtype)):
+            raise TypeError(f'{type(self).__name__}.sem called with numeric_only={numeric_only} and dtype {self.obj.dtype}')
+        return self._cython_agg_general('sem', alt=lambda x: Series(x, copy=False).sem(ddof=ddof), numeric_only=numeric_only, ddof=ddof)
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def size(self) -> DataFrame | Series:
+        result = self._grouper.size()
+        dtype_backend: None | Literal['pyarrow', 'numpy_nullable'] = None
+        if isinstance(self.obj, Series):
+            if isinstance(self.obj.array, ArrowExtensionArray):
+                if isinstance(self.obj.array, ArrowStringArrayNumpySemantics):
+                    dtype_backend = None
+                elif isinstance(self.obj.array, ArrowStringArray):
+                    dtype_backend = 'numpy_nullable'
+                else:
+                    dtype_backend = 'pyarrow'
+            elif isinstance(self.obj.array, BaseMaskedArray):
+                dtype_backend = 'numpy_nullable'
+        if isinstance(self.obj, Series):
+            result = self._obj_1d_constructor(result, name=self.obj.name)
+        else:
+            result = self._obj_1d_constructor(result)
+        if dtype_backend is not None:
+            result = result.convert_dtypes(infer_objects=False, convert_string=False, convert_boolean=False, convert_floating=False, dtype_backend=dtype_backend)
+        if not self.as_index:
+            result = result.rename('size').reset_index()
+        return result
+
+    @final
+    @doc(_groupby_agg_method_engine_template, fname='sum', no=False, mc=0, e=None, ek=None, example=dedent('        For SeriesGroupBy:\n\n        >>> lst = [\'a\', \'a\', \'b\', \'b\']\n        >>> ser = pd.Series([1, 2, 3, 4], index=lst)\n        >>> ser\n        a    1\n        a    2\n        b    3\n        b    4\n        dtype: int64\n        >>> ser.groupby(level=0).sum()\n        a    3\n        b    7\n        dtype: int64\n\n        For DataFrameGroupBy:\n\n        >>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]]\n        >>> df = pd.DataFrame(data, columns=["a", "b", "c"],\n        ...                   index=["tiger", "leopard", "cheetah", "lion"])\n        >>> df\n                  a  b  c\n          tiger   1  8  2\n        leopard   1  2  5\n        cheetah   2  5  8\n           lion   2  6  9\n        >>> df.groupby("a").sum()\n             b   c\n        a\n        1   10   7\n        2   11  17'))
+    def sum(self, numeric_only: bool=False, min_count: int=0, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        if maybe_use_numba(engine):
+            from pandas.core._numba.kernels import grouped_sum
+            return self._numba_agg_general(grouped_sum, executor.default_dtype_mapping, engine_kwargs, min_periods=min_count)
+        else:
+            with com.temp_setattr(self, 'observed', True):
+                result = self._agg_general(numeric_only=numeric_only, min_count=min_count, alias='sum', npfunc=np.sum)
+            return result
+
+    @final
+    def prod(self, numeric_only: bool=False, min_count: int=0) -> NDFrameT:
+        return self._agg_general(numeric_only=numeric_only, min_count=min_count, alias='prod', npfunc=np.prod)
+
+    @final
+    @doc(_groupby_agg_method_engine_template, fname='min', no=False, mc=-1, e=None, ek=None, example=dedent('        For SeriesGroupBy:\n\n        >>> lst = [\'a\', \'a\', \'b\', \'b\']\n        >>> ser = pd.Series([1, 2, 3, 4], index=lst)\n        >>> ser\n        a    1\n        a    2\n        b    3\n        b    4\n        dtype: int64\n        >>> ser.groupby(level=0).min()\n        a    1\n        b    3\n        dtype: int64\n\n        For DataFrameGroupBy:\n\n        >>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]]\n        >>> df = pd.DataFrame(data, columns=["a", "b", "c"],\n        ...                   index=["tiger", "leopard", "cheetah", "lion"])\n        >>> df\n                  a  b  c\n          tiger   1  8  2\n        leopard   1  2  5\n        cheetah   2  5  8\n           lion   2  6  9\n        >>> df.groupby("a").min()\n            b  c\n        a\n        1   2  2\n        2   5  8'))
+    def min(self, numeric_only: bool=False, min_count: int=-1, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        if maybe_use_numba(engine):
+            from pandas.core._numba.kernels import grouped_min_max
+            return self._numba_agg_general(grouped_min_max, executor.identity_dtype_mapping, engine_kwargs, min_periods=min_count, is_max=False)
+        else:
+            return self._agg_general(numeric_only=numeric_only, min_count=min_count, alias='min', npfunc=np.min)
+
+    @final
+    @doc(_groupby_agg_method_engine_template, fname='max', no=False, mc=-1, e=None, ek=None, example=dedent('        For SeriesGroupBy:\n\n        >>> lst = [\'a\', \'a\', \'b\', \'b\']\n        >>> ser = pd.Series([1, 2, 3, 4], index=lst)\n        >>> ser\n        a    1\n        a    2\n        b    3\n        b    4\n        dtype: int64\n        >>> ser.groupby(level=0).max()\n        a    2\n        b    4\n        dtype: int64\n\n        For DataFrameGroupBy:\n\n        >>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]]\n        >>> df = pd.DataFrame(data, columns=["a", "b", "c"],\n        ...                   index=["tiger", "leopard", "cheetah", "lion"])\n        >>> df\n                  a  b  c\n          tiger   1  8  2\n        leopard   1  2  5\n        cheetah   2  5  8\n           lion   2  6  9\n        >>> df.groupby("a").max()\n            b  c\n        a\n        1   8  5\n        2   6  9'))
+    def max(self, numeric_only: bool=False, min_count: int=-1, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        if maybe_use_numba(engine):
+            from pandas.core._numba.kernels import grouped_min_max
+            return self._numba_agg_general(grouped_min_max, executor.identity_dtype_mapping, engine_kwargs, min_periods=min_count, is_max=True)
+        else:
+            return self._agg_general(numeric_only=numeric_only, min_count=min_count, alias='max', npfunc=np.max)
+
+    @final
+    def first(self, numeric_only: bool=False, min_count: int=-1, skipna: bool=True) -> NDFrameT:
+
+        def first_compat(obj: NDFrameT):
+
+            def first(x: Series):
+                arr = x.array[notna(x.array)]
+                if not len(arr):
+                    return x.array.dtype.na_value
+                return arr[0]
+            if isinstance(obj, DataFrame):
+                return obj.apply(first)
+            elif isinstance(obj, Series):
+                return first(obj)
+            else:
+                raise TypeError(type(obj))
+        return self._agg_general(numeric_only=numeric_only, min_count=min_count, alias='first', npfunc=first_compat, skipna=skipna)
+
+    @final
+    def last(self, numeric_only: bool=False, min_count: int=-1, skipna: bool=True) -> NDFrameT:
+
+        def last_compat(obj: NDFrameT):
+
+            def last(x: Series):
+                arr = x.array[notna(x.array)]
+                if not len(arr):
+                    return x.array.dtype.na_value
+                return arr[-1]
+            if isinstance(obj, DataFrame):
+                return obj.apply(last)
+            elif isinstance(obj, Series):
+                return last(obj)
+            else:
+                raise TypeError(type(obj))
+        return self._agg_general(numeric_only=numeric_only, min_count=min_count, alias='last', npfunc=last_compat, skipna=skipna)
+
+    @final
+    def ohlc(self) -> DataFrame:
+        if self.obj.ndim == 1:
+            obj = self._selected_obj
+            is_numeric = is_numeric_dtype(obj.dtype)
+            if not is_numeric:
+                raise DataError('No numeric types to aggregate')
+            res_values = self._grouper._cython_operation('aggregate', obj._values, 'ohlc', axis=0, min_count=-1)
+            agg_names = ['open', 'high', 'low', 'close']
+            result = self.obj._constructor_expanddim(res_values, index=self._grouper.result_index, columns=agg_names)
+            return result
+        result = self._apply_to_column_groupbys(lambda sgb: sgb.ohlc())
+        return result
+
+    @doc(DataFrame.describe)
+    def describe(self, percentiles=None, include=None, exclude=None) -> NDFrameT:
+        obj = self._obj_with_exclusions
+        if len(obj) == 0:
+            described = obj.describe(percentiles=percentiles, include=include, exclude=exclude)
+            if obj.ndim == 1:
+                result = described
+            else:
+                result = described.unstack()
+            return result.to_frame().T.iloc[:0]
+        with com.temp_setattr(self, 'as_index', True):
+            result = self._python_apply_general(lambda x: x.describe(percentiles=percentiles, include=include, exclude=exclude), obj, not_indexed_same=True)
+        result = result.unstack()
+        if not self.as_index:
+            result = self._insert_inaxis_grouper(result)
+            result.index = default_index(len(result))
+        return result
+
+    @final
+    def resample(self, rule, *args, include_groups: bool=True, **kwargs) -> Resampler:
+        from pandas.core.resample import get_resampler_for_grouping
+        return get_resampler_for_grouping(self, rule, *args, include_groups=include_groups, **kwargs)
+
+    @final
+    def rolling(self, window: int | datetime.timedelta | str | BaseOffset | BaseIndexer, min_periods: int | None=None, center: bool=False, win_type: str | None=None, on: str | None=None, closed: IntervalClosedType | None=None, method: str='single') -> RollingGroupby:
+        from pandas.core.window import RollingGroupby
+        return RollingGroupby(self._selected_obj, window=window, min_periods=min_periods, center=center, win_type=win_type, on=on, closed=closed, method=method, _grouper=self._grouper, _as_index=self.as_index)
+
+    @final
+    @Substitution(name='groupby')
+    @Appender(_common_see_also)
+    def expanding(self, *args, **kwargs) -> ExpandingGroupby:
+        from pandas.core.window import ExpandingGroupby
+        return ExpandingGroupby(self._selected_obj, *args, _grouper=self._grouper, **kwargs)
+
+    @final
+    @Substitution(name='groupby')
+    @Appender(_common_see_also)
+    def ewm(self, *args, **kwargs) -> ExponentialMovingWindowGroupby:
+        from pandas.core.window import ExponentialMovingWindowGroupby
+        return ExponentialMovingWindowGroupby(self._selected_obj, *args, _grouper=self._grouper, **kwargs)
+
+    @final
+    def _fill(self, direction: Literal['ffill', 'bfill'], limit: int | None=None):
+        if limit is None:
+            limit = -1
+        ids = self._grouper.ids
+        ngroups = self._grouper.ngroups
+        col_func = partial(libgroupby.group_fillna_indexer, labels=ids, limit=limit, compute_ffill=direction == 'ffill', ngroups=ngroups)
+
+        def blk_func(values: ArrayLike) -> ArrayLike:
+            mask = isna(values)
+            if values.ndim == 1:
+                indexer = np.empty(values.shape, dtype=np.intp)
+                col_func(out=indexer, mask=mask)
+                return algorithms.take_nd(values, indexer)
+            else:
+                if isinstance(values, np.ndarray):
+                    dtype = values.dtype
+                    if self._grouper.has_dropped_na:
+                        dtype = ensure_dtype_can_hold_na(values.dtype)
+                    out = np.empty(values.shape, dtype=dtype)
+                else:
+                    out = type(values)._empty(values.shape, dtype=values.dtype)
+                for (i, value_element) in enumerate(values):
+                    indexer = np.empty(values.shape[1], dtype=np.intp)
+                    col_func(out=indexer, mask=mask[i])
+                    out[i, :] = algorithms.take_nd(value_element, indexer)
+                return out
+        mgr = self._get_data_to_aggregate()
+        res_mgr = mgr.apply(blk_func)
+        new_obj = self._wrap_agged_manager(res_mgr)
+        new_obj.index = self.obj.index
+        return new_obj
+
+    @final
+    @Substitution(name='groupby')
+    def ffill(self, limit: int | None=None):
+        return self._fill('ffill', limit=limit)
+
+    @final
+    @Substitution(name='groupby')
+    def bfill(self, limit: int | None=None):
+        return self._fill('bfill', limit=limit)
+
+    @final
+    @property
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def nth(self) -> GroupByNthSelector:
+        return GroupByNthSelector(self)
+
+    def _nth(self, n: PositionalIndexer | tuple, dropna: Literal['any', 'all', None]=None) -> NDFrameT:
+        if not dropna:
+            mask = self._make_mask_from_positional_indexer(n)
+            ids = self._grouper.ids
+            mask = mask & (ids != -1)
+            out = self._mask_selected_obj(mask)
+            return out
+        if not is_integer(n):
+            raise ValueError('dropna option only supported for an integer argument')
+        if dropna not in ['any', 'all']:
+            raise ValueError(f"For a DataFrame or Series groupby.nth, dropna must be either None, 'any' or 'all', (was passed {dropna}).")
+        n = cast(int, n)
+        dropped = self._selected_obj.dropna(how=dropna, axis=0)
+        grouper: np.ndarray | Index | ops.BaseGrouper
+        if len(dropped) == len(self._selected_obj):
+            grouper = self._grouper
+        else:
+            axis = self._grouper.axis
+            grouper = self._grouper.codes_info[axis.isin(dropped.index)]
+            if self._grouper.has_dropped_na:
+                nulls = grouper == -1
+                values = np.where(nulls, NA, grouper)
+                grouper = Index(values, dtype='Int64')
+        grb = dropped.groupby(grouper, as_index=self.as_index, sort=self.sort)
+        return grb.nth(n)
+
+    @final
+    def quantile(self, q: float | AnyArrayLike=0.5, interpolation: str='linear', numeric_only: bool=False):
+        mgr = self._get_data_to_aggregate(numeric_only=numeric_only, name='quantile')
+        obj = self._wrap_agged_manager(mgr)
+        splitter = self._grouper._get_splitter(obj)
+        sdata = splitter._sorted_data
+        (starts, ends) = lib.generate_slices(splitter._slabels, splitter.ngroups)
+
+        def pre_processor(vals: ArrayLike) -> tuple[np.ndarray, DtypeObj | None]:
+            if is_object_dtype(vals.dtype):
+                raise TypeError("'quantile' cannot be performed against 'object' dtypes!")
+            inference: DtypeObj | None = None
+            if isinstance(vals, BaseMaskedArray) and is_numeric_dtype(vals.dtype):
+                out = vals.to_numpy(dtype=float, na_value=np.nan)
+                inference = vals.dtype
+            elif is_integer_dtype(vals.dtype):
+                if isinstance(vals, ExtensionArray):
+                    out = vals.to_numpy(dtype=float, na_value=np.nan)
+                else:
+                    out = vals
+                inference = np.dtype(np.int64)
+            elif is_bool_dtype(vals.dtype) and isinstance(vals, ExtensionArray):
+                out = vals.to_numpy(dtype=float, na_value=np.nan)
+            elif is_bool_dtype(vals.dtype):
+                raise TypeError('Cannot use quantile with bool dtype')
+            elif needs_i8_conversion(vals.dtype):
+                inference = vals.dtype
+                return (vals, inference)
+            elif isinstance(vals, ExtensionArray) and is_float_dtype(vals.dtype):
+                inference = np.dtype(np.float64)
+                out = vals.to_numpy(dtype=float, na_value=np.nan)
+            else:
+                out = np.asarray(vals)
+            return (out, inference)
+
+        def post_processor(vals: np.ndarray, inference: DtypeObj | None, result_mask: np.ndarray | None, orig_vals: ArrayLike) -> ArrayLike:
+            if inference:
+                if isinstance(orig_vals, BaseMaskedArray):
+                    assert result_mask is not None
+                    if interpolation in {'linear', 'midpoint'} and (not is_float_dtype(orig_vals)):
+                        return FloatingArray(vals, result_mask)
+                    else:
+                        with warnings.catch_warnings():
+                            warnings.filterwarnings('ignore', category=RuntimeWarning)
+                            return type(orig_vals)(vals.astype(inference.numpy_dtype), result_mask)
+                elif not (is_integer_dtype(inference) and interpolation in {'linear', 'midpoint'}):
+                    if needs_i8_conversion(inference):
+                        vals = vals.astype('i8').view(orig_vals._ndarray.dtype)
+                        return orig_vals._from_backing_data(vals)
+                    assert isinstance(inference, np.dtype)
+                    return vals.astype(inference)
+            return vals
+        if is_scalar(q):
+            qs = np.array([q], dtype=np.float64)
+            pass_qs: None | np.ndarray = None
+        else:
+            qs = np.asarray(q, dtype=np.float64)
+            pass_qs = qs
+        ids = self._grouper.ids
+        ngroups = self._grouper.ngroups
+        if self.dropna:
+            ids = ids[ids >= 0]
+        nqs = len(qs)
+        func = partial(libgroupby.group_quantile, labels=ids, qs=qs, interpolation=interpolation, starts=starts, ends=ends)
+
+        def blk_func(values: ArrayLike) -> ArrayLike:
+            orig_vals = values
+            if isinstance(values, BaseMaskedArray):
+                mask = values._mask
+                result_mask = np.zeros((ngroups, nqs), dtype=np.bool_)
+            else:
+                mask = isna(values)
+                result_mask = None
+            is_datetimelike = needs_i8_conversion(values.dtype)
+            (vals, inference) = pre_processor(values)
+            ncols = 1
+            if vals.ndim == 2:
+                ncols = vals.shape[0]
+            out = np.empty((ncols, ngroups, nqs), dtype=np.float64)
+            if is_datetimelike:
+                vals = vals.view('i8')
+            if vals.ndim == 1:
+                func(out[0], values=vals, mask=mask, result_mask=result_mask, is_datetimelike=is_datetimelike)
+            else:
+                for i in range(ncols):
+                    func(out[i], values=vals[i], mask=mask[i], result_mask=None, is_datetimelike=is_datetimelike)
+            if vals.ndim == 1:
+                out = out.ravel('K')
+                if result_mask is not None:
+                    result_mask = result_mask.ravel('K')
+            else:
+                out = out.reshape(ncols, ngroups * nqs)
+            return post_processor(out, inference, result_mask, orig_vals)
+        res_mgr = sdata._mgr.grouped_reduce(blk_func)
+        res = self._wrap_agged_manager(res_mgr)
+        return self._wrap_aggregated_output(res, qs=pass_qs)
+
+    @final
+    @Substitution(name='groupby')
+    def ngroup(self, ascending: bool=True):
+        obj = self._obj_with_exclusions
+        index = obj.index
+        comp_ids = self._grouper.ids
+        dtype: type
+        if self._grouper.has_dropped_na:
+            comp_ids = np.where(comp_ids == -1, np.nan, comp_ids)
+            dtype = np.float64
+        else:
+            dtype = np.int64
+        if any((ping._passed_categorical for ping in self._grouper.groupings)):
+            comp_ids = rank_1d(comp_ids, ties_method='dense') - 1
+        result = self._obj_1d_constructor(comp_ids, index, dtype=dtype)
+        if not ascending:
+            result = self.ngroups - 1 - result
+        return result
+
+    @final
+    @Substitution(name='groupby')
+    def cumcount(self, ascending: bool=True):
+        index = self._obj_with_exclusions.index
+        cumcounts = self._cumcount_array(ascending=ascending)
+        return self._obj_1d_constructor(cumcounts, index)
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def rank(self, method: str='average', ascending: bool=True, na_option: str='keep', pct: bool=False) -> NDFrameT:
+        if na_option not in {'keep', 'top', 'bottom'}:
+            msg = "na_option must be one of 'keep', 'top', or 'bottom'"
+            raise ValueError(msg)
+        kwargs = {'ties_method': method, 'ascending': ascending, 'na_option': na_option, 'pct': pct}
+        return self._cython_transform('rank', numeric_only=False, **kwargs)
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def cumprod(self, numeric_only: bool=False, *args, **kwargs) -> NDFrameT:
+        nv.validate_groupby_func('cumprod', args, kwargs, ['skipna'])
+        return self._cython_transform('cumprod', numeric_only, **kwargs)
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def cumsum(self, numeric_only: bool=False, *args, **kwargs) -> NDFrameT:
+        nv.validate_groupby_func('cumsum', args, kwargs, ['skipna'])
+        return self._cython_transform('cumsum', numeric_only, **kwargs)
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def cummin(self, numeric_only: bool=False, **kwargs) -> NDFrameT:
+        skipna = kwargs.get('skipna', True)
+        return self._cython_transform('cummin', numeric_only=numeric_only, skipna=skipna)
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def cummax(self, numeric_only: bool=False, **kwargs) -> NDFrameT:
+        skipna = kwargs.get('skipna', True)
+        return self._cython_transform('cummax', numeric_only=numeric_only, skipna=skipna)
+
+    @final
+    @Substitution(name='groupby')
+    def shift(self, periods: int | Sequence[int]=1, freq=None, fill_value=lib.no_default, suffix: str | None=None):
+        if is_list_like(periods):
+            periods = cast(Sequence, periods)
+            if len(periods) == 0:
+                raise ValueError('If `periods` is an iterable, it cannot be empty.')
+            from pandas.core.reshape.concat import concat
+            add_suffix = True
+        else:
+            if not is_integer(periods):
+                raise TypeError(f'Periods must be integer, but {periods} is {type(periods)}.')
+            if suffix:
+                raise ValueError('Cannot specify `suffix` if `periods` is an int.')
+            periods = [cast(int, periods)]
+            add_suffix = False
+        shifted_dataframes = []
+        for period in periods:
+            if not is_integer(period):
+                raise TypeError(f'Periods must be integer, but {period} is {type(period)}.')
+            period = cast(int, period)
+            if freq is not None:
+                f = lambda x: x.shift(period, freq, 0, fill_value)
+                shifted = self._python_apply_general(f, self._selected_obj, is_transform=True)
+            else:
+                if fill_value is lib.no_default:
+                    fill_value = None
+                ids = self._grouper.ids
+                ngroups = self._grouper.ngroups
+                res_indexer = np.zeros(len(ids), dtype=np.int64)
+                libgroupby.group_shift_indexer(res_indexer, ids, ngroups, period)
+                obj = self._obj_with_exclusions
+                shifted = obj._reindex_with_indexers({0: (obj.index, res_indexer)}, fill_value=fill_value, allow_dups=True)
+            if add_suffix:
+                if isinstance(shifted, Series):
+                    shifted = cast(NDFrameT, shifted.to_frame())
+                shifted = shifted.add_suffix(f'{suffix}_{period}' if suffix else f'_{period}')
+            shifted_dataframes.append(cast(Union[Series, DataFrame], shifted))
+        return shifted_dataframes[0] if len(shifted_dataframes) == 1 else concat(shifted_dataframes, axis=1)
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def diff(self, periods: int=1) -> NDFrameT:
+        obj = self._obj_with_exclusions
+        shifted = self.shift(periods=periods)
+        dtypes_to_f32 = ['int8', 'int16']
+        if obj.ndim == 1:
+            if obj.dtype in dtypes_to_f32:
+                shifted = shifted.astype('float32')
+        else:
+            to_coerce = [c for (c, dtype) in obj.dtypes.items() if dtype in dtypes_to_f32]
+            if len(to_coerce):
+                shifted = shifted.astype({c: 'float32' for c in to_coerce})
+        return obj - shifted
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def pct_change(self, periods: int=1, fill_method: None=None, freq=None):
+        if fill_method is not None:
+            raise ValueError(f'fill_method must be None; got fill_method={fill_method!r}.')
+        if freq is not None:
+            f = lambda x: x.pct_change(periods=periods, freq=freq, axis=0)
+            return self._python_apply_general(f, self._selected_obj, is_transform=True)
+        if fill_method is None:
+            op = 'ffill'
+        else:
+            op = fill_method
+        filled = getattr(self, op)(limit=0)
+        fill_grp = filled.groupby(self._grouper.codes, group_keys=self.group_keys)
+        shifted = fill_grp.shift(periods=periods, freq=freq)
+        return filled / shifted - 1
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def head(self, n: int=5) -> NDFrameT:
+        mask = self._make_mask_from_positional_indexer(slice(None, n))
+        return self._mask_selected_obj(mask)
+
+    @final
+    @Substitution(name='groupby')
+    @Substitution(see_also=_common_see_also)
+    def tail(self, n: int=5) -> NDFrameT:
+        if n:
+            mask = self._make_mask_from_positional_indexer(slice(-n, None))
+        else:
+            mask = self._make_mask_from_positional_indexer([])
+        return self._mask_selected_obj(mask)
+
+    @final
+    def _mask_selected_obj(self, mask: npt.NDArray[np.bool_]) -> NDFrameT:
+        ids = self._grouper.ids
+        mask = mask & (ids != -1)
+        return self._selected_obj[mask]
+
+    @final
+    def sample(self, n: int | None=None, frac: float | None=None, replace: bool=False, weights: Sequence | Series | None=None, random_state: RandomState | None=None):
+        if self._selected_obj.empty:
+            return self._selected_obj
+        size = sample.process_sampling_size(n, frac, replace)
+        if weights is not None:
+            weights_arr = sample.preprocess_weights(self._selected_obj, weights, axis=0)
+        random_state = com.random_state(random_state)
+        group_iterator = self._grouper.get_iterator(self._selected_obj)
+        sampled_indices = []
+        for (labels, obj) in group_iterator:
+            grp_indices = self.indices[labels]
+            group_size = len(grp_indices)
+            if size is not None:
+                sample_size = size
+            else:
+                assert frac is not None
+                sample_size = round(frac * group_size)
+            grp_sample = sample.sample(group_size, size=sample_size, replace=replace, weights=None if weights is None else weights_arr[grp_indices], random_state=random_state)
+            sampled_indices.append(grp_indices[grp_sample])
+        sampled_indices = np.concatenate(sampled_indices)
+        return self._selected_obj.take(sampled_indices, axis=0)
+
+    def _idxmax_idxmin(self, how: Literal['idxmax', 'idxmin'], ignore_unobserved: bool=False, skipna: bool=True, numeric_only: bool=False) -> NDFrameT:
+        if not self.observed and any((ping._passed_categorical for ping in self._grouper.groupings)):
+            expected_len = len(self._grouper.result_index)
+            group_sizes = self._grouper.size()
+            result_len = group_sizes[group_sizes > 0].shape[0]
+            assert result_len <= expected_len
+            has_unobserved = result_len < expected_len
+            raise_err: bool | np.bool_ = not ignore_unobserved and has_unobserved
+            data = self._obj_with_exclusions
+            if raise_err and isinstance(data, DataFrame):
+                if numeric_only:
+                    data = data._get_numeric_data()
+                raise_err = len(data.columns) > 0
+            if raise_err:
+                raise ValueError(f"Can't get {how} of an empty group due to unobserved categories. Specify observed=True in groupby instead.")
+        elif not skipna and self._obj_with_exclusions.isna().any(axis=None):
+            raise ValueError(f'{type(self).__name__}.{how} with skipna=False encountered an NA value.')
+        result = self._agg_general(numeric_only=numeric_only, min_count=1, alias=how, skipna=skipna)
+        return result
+
+    def _wrap_idxmax_idxmin(self, res: NDFrameT) -> NDFrameT:
+        index = self.obj.index
+        if res.size == 0:
+            result = res.astype(index.dtype)
+        else:
+            if isinstance(index, MultiIndex):
+                index = index.to_flat_index()
+            values = res._values
+            assert isinstance(values, np.ndarray)
+            na_value = na_value_for_dtype(index.dtype, compat=False)
+            if isinstance(res, Series):
+                result = res._constructor(index.array.take(values, allow_fill=True, fill_value=na_value), index=res.index, name=res.name)
+            else:
+                data = {}
+                for (k, column_values) in enumerate(values.T):
+                    data[k] = index.array.take(column_values, allow_fill=True, fill_value=na_value)
+                result = self.obj._constructor(data, index=res.index)
+                result.columns = res.columns
+        return result
+
+@doc(GroupBy)
+def get_groupby(obj: NDFrame, by: _KeysArgType | None=None, grouper: ops.BaseGrouper | None=None, group_keys: bool=True) -> GroupBy:
+    klass: type[GroupBy]
+    if isinstance(obj, Series):
+        from pandas.core.groupby.generic import SeriesGroupBy
+        klass = SeriesGroupBy
+    elif isinstance(obj, DataFrame):
+        from pandas.core.groupby.generic import DataFrameGroupBy
+        klass = DataFrameGroupBy
+    else:
+        raise TypeError(f'invalid type: {obj}')
+    return klass(obj=obj, keys=by, grouper=grouper, group_keys=group_keys)
+
+def _insert_quantile_level(idx: Index, qs: npt.NDArray[np.float64]) -> MultiIndex:
+    nqs = len(qs)
+    (lev_codes, lev) = Index(qs).factorize()
+    lev_codes = coerce_indexer_dtype(lev_codes, lev)
+    if idx._is_multi:
+        idx = cast(MultiIndex, idx)
+        levels = list(idx.levels) + [lev]
+        codes = [np.repeat(x, nqs) for x in idx.codes] + [np.tile(lev_codes, len(idx))]
+        mi = MultiIndex(levels=levels, codes=codes, names=idx.names + [None])
+    else:
+        nidx = len(idx)
+        idx_codes = coerce_indexer_dtype(np.arange(nidx), idx)
+        levels = [idx, lev]
+        codes = [np.repeat(idx_codes, nqs), np.tile(lev_codes, nidx)]
+        mi = MultiIndex(levels=levels, codes=codes, names=[idx.name, None])
+    return mi
+_apply_groupings_depr = '{}.{} operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.'
+
+# File: pandas-main/pandas/core/groupby/grouper.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, final
+import numpy as np
+from pandas._libs.tslibs import OutOfBoundsDatetime
+from pandas.errors import InvalidIndexError
+from pandas.util._decorators import cache_readonly
+from pandas.core.dtypes.common import is_list_like, is_scalar
+from pandas.core.dtypes.dtypes import CategoricalDtype
+from pandas.core import algorithms
+from pandas.core.arrays import Categorical, ExtensionArray
+import pandas.core.common as com
+from pandas.core.frame import DataFrame
+from pandas.core.groupby import ops
+from pandas.core.groupby.categorical import recode_for_groupby
+from pandas.core.indexes.api import Index, MultiIndex, default_index
+from pandas.core.series import Series
+from pandas.io.formats.printing import pprint_thing
+if TYPE_CHECKING:
+    from collections.abc import Hashable, Iterator
+    from pandas._typing import ArrayLike, NDFrameT, npt
+    from pandas.core.generic import NDFrame
+
+class Grouper:
+    sort: bool
+    dropna: bool
+    _grouper: Index | None
+    _attributes: tuple[str, ...] = ('key', 'level', 'freq', 'sort', 'dropna')
+
+    def __new__(cls, *args, **kwargs):
+        if kwargs.get('freq') is not None:
+            from pandas.core.resample import TimeGrouper
+            cls = TimeGrouper
+        return super().__new__(cls)
+
+    def __init__(self, key=None, level=None, freq=None, sort: bool=False, dropna: bool=True) -> None:
+        self.key = key
+        self.level = level
+        self.freq = freq
+        self.sort = sort
+        self.dropna = dropna
+        self._indexer_deprecated: npt.NDArray[np.intp] | None = None
+        self.binner = None
+        self._grouper = None
+        self._indexer: npt.NDArray[np.intp] | None = None
+
+    def _get_grouper(self, obj: NDFrameT, validate: bool=True) -> tuple[ops.BaseGrouper, NDFrameT]:
+        (obj, _, _) = self._set_grouper(obj)
+        (grouper, _, obj) = get_grouper(obj, [self.key], level=self.level, sort=self.sort, validate=validate, dropna=self.dropna)
+        return (grouper, obj)
+
+    def _set_grouper(self, obj: NDFrameT, sort: bool=False, *, gpr_index: Index | None=None) -> tuple[NDFrameT, Index, npt.NDArray[np.intp] | None]:
+        assert obj is not None
+        if self.key is not None and self.level is not None:
+            raise ValueError('The Grouper cannot specify both a key and a level!')
+        if self._grouper is None:
+            self._grouper = gpr_index
+            self._indexer = self._indexer_deprecated
+        if self.key is not None:
+            key = self.key
+            if getattr(gpr_index, 'name', None) == key and isinstance(obj, Series):
+                assert self._grouper is not None
+                if self._indexer is not None:
+                    reverse_indexer = self._indexer.argsort()
+                    unsorted_ax = self._grouper.take(reverse_indexer)
+                    ax = unsorted_ax.take(obj.index)
+                else:
+                    ax = self._grouper.take(obj.index)
+            else:
+                if key not in obj._info_axis:
+                    raise KeyError(f'The grouper name {key} is not found')
+                ax = Index(obj[key], name=key)
+        else:
+            ax = obj.index
+            if self.level is not None:
+                level = self.level
+                if isinstance(ax, MultiIndex):
+                    level = ax._get_level_number(level)
+                    ax = Index(ax._get_level_values(level), name=ax.names[level])
+                elif level not in (0, ax.name):
+                    raise ValueError(f'The level {level} is not valid')
+        indexer: npt.NDArray[np.intp] | None = None
+        if (self.sort or sort) and (not ax.is_monotonic_increasing):
+            indexer = self._indexer_deprecated = ax.array.argsort(kind='mergesort', na_position='first')
+            ax = ax.take(indexer)
+            obj = obj.take(indexer, axis=0)
+        return (obj, ax, indexer)
+
+    @final
+    def __repr__(self) -> str:
+        attrs_list = (f'{attr_name}={getattr(self, attr_name)!r}' for attr_name in self._attributes if getattr(self, attr_name) is not None)
+        attrs = ', '.join(attrs_list)
+        cls_name = type(self).__name__
+        return f'{cls_name}({attrs})'
+
+@final
+class Grouping:
+    _codes: npt.NDArray[np.signedinteger] | None = None
+    _orig_cats: Index | None
+    _index: Index
+
+    def __init__(self, index: Index, grouper=None, obj: NDFrame | None=None, level=None, sort: bool=True, observed: bool=False, in_axis: bool=False, dropna: bool=True, uniques: ArrayLike | None=None) -> None:
+        self.level = level
+        self._orig_grouper = grouper
+        grouping_vector = _convert_grouper(index, grouper)
+        self._orig_cats = None
+        self._index = index
+        self._sort = sort
+        self.obj = obj
+        self._observed = observed
+        self.in_axis = in_axis
+        self._dropna = dropna
+        self._uniques = uniques
+        ilevel = self._ilevel
+        if ilevel is not None:
+            if isinstance(index, MultiIndex):
+                index_level = index.get_level_values(ilevel)
+            else:
+                index_level = index
+            if grouping_vector is None:
+                grouping_vector = index_level
+            else:
+                mapper = grouping_vector
+                grouping_vector = index_level.map(mapper)
+        elif isinstance(grouping_vector, Grouper):
+            assert self.obj is not None
+            (newgrouper, newobj) = grouping_vector._get_grouper(self.obj, validate=False)
+            self.obj = newobj
+            if isinstance(newgrouper, ops.BinGrouper):
+                grouping_vector = newgrouper
+            else:
+                ng = newgrouper.groupings[0].grouping_vector
+                grouping_vector = Index(ng, name=newgrouper.result_index.name)
+        elif not isinstance(grouping_vector, (Series, Index, ExtensionArray, np.ndarray)):
+            if getattr(grouping_vector, 'ndim', 1) != 1:
+                t = str(type(grouping_vector))
+                raise ValueError(f"Grouper for '{t}' not 1-dimensional")
+            grouping_vector = index.map(grouping_vector)
+            if not (hasattr(grouping_vector, '__len__') and len(grouping_vector) == len(index)):
+                grper = pprint_thing(grouping_vector)
+                errmsg = f'Grouper result violates len(labels) == len(data)\nresult: {grper}'
+                raise AssertionError(errmsg)
+        if isinstance(grouping_vector, np.ndarray):
+            if grouping_vector.dtype.kind in 'mM':
+                grouping_vector = Series(grouping_vector).to_numpy()
+        elif isinstance(getattr(grouping_vector, 'dtype', None), CategoricalDtype):
+            self._orig_cats = grouping_vector.categories
+            grouping_vector = recode_for_groupby(grouping_vector, sort, observed)
+        self.grouping_vector = grouping_vector
+
+    def __repr__(self) -> str:
+        return f'Grouping({self.name})'
+
+    def __iter__(self) -> Iterator:
+        return iter(self.indices)
+
+    @cache_readonly
+    def _passed_categorical(self) -> bool:
+        dtype = getattr(self.grouping_vector, 'dtype', None)
+        return isinstance(dtype, CategoricalDtype)
+
+    @cache_readonly
+    def name(self) -> Hashable:
+        ilevel = self._ilevel
+        if ilevel is not None:
+            return self._index.names[ilevel]
+        if isinstance(self._orig_grouper, (Index, Series)):
+            return self._orig_grouper.name
+        elif isinstance(self.grouping_vector, ops.BaseGrouper):
+            return self.grouping_vector.result_index.name
+        elif isinstance(self.grouping_vector, Index):
+            return self.grouping_vector.name
+        return None
+
+    @cache_readonly
+    def _ilevel(self) -> int | None:
+        level = self.level
+        if level is None:
+            return None
+        if not isinstance(level, int):
+            index = self._index
+            if level not in index.names:
+                raise AssertionError(f'Level {level} not in index')
+            return index.names.index(level)
+        return level
+
+    @property
+    def ngroups(self) -> int:
+        return len(self.uniques)
+
+    @cache_readonly
+    def indices(self) -> dict[Hashable, npt.NDArray[np.intp]]:
+        if isinstance(self.grouping_vector, ops.BaseGrouper):
+            return self.grouping_vector.indices
+        values = Categorical(self.grouping_vector)
+        return values._reverse_indexer()
+
+    @property
+    def codes(self) -> npt.NDArray[np.signedinteger]:
+        return self._codes_and_uniques[0]
+
+    @property
+    def uniques(self) -> ArrayLike:
+        return self._codes_and_uniques[1]
+
+    @cache_readonly
+    def _codes_and_uniques(self) -> tuple[npt.NDArray[np.signedinteger], ArrayLike]:
+        uniques: ArrayLike
+        if self._passed_categorical:
+            cat = self.grouping_vector
+            categories = cat.categories
+            if self._observed:
+                ucodes = algorithms.unique1d(cat.codes)
+                ucodes = ucodes[ucodes != -1]
+                if self._sort:
+                    ucodes = np.sort(ucodes)
+            else:
+                ucodes = np.arange(len(categories))
+            has_dropped_na = False
+            if not self._dropna:
+                na_mask = cat.isna()
+                if np.any(na_mask):
+                    has_dropped_na = True
+                    if self._sort:
+                        na_code = len(categories)
+                    else:
+                        na_idx = na_mask.argmax()
+                        na_code = algorithms.nunique_ints(cat.codes[:na_idx])
+                    ucodes = np.insert(ucodes, na_code, -1)
+            uniques = Categorical.from_codes(codes=ucodes, categories=categories, ordered=cat.ordered, validate=False)
+            codes = cat.codes
+            if has_dropped_na:
+                if not self._sort:
+                    codes = np.where(codes >= na_code, codes + 1, codes)
+                codes = np.where(na_mask, na_code, codes)
+            return (codes, uniques)
+        elif isinstance(self.grouping_vector, ops.BaseGrouper):
+            codes = self.grouping_vector.codes_info
+            uniques = self.grouping_vector.result_index._values
+        elif self._uniques is not None:
+            cat = Categorical(self.grouping_vector, categories=self._uniques)
+            codes = cat.codes
+            uniques = self._uniques
+        else:
+            (codes, uniques) = algorithms.factorize(self.grouping_vector, sort=self._sort, use_na_sentinel=self._dropna)
+        return (codes, uniques)
+
+    @cache_readonly
+    def groups(self) -> dict[Hashable, Index]:
+        (codes, uniques) = self._codes_and_uniques
+        uniques = Index._with_infer(uniques, name=self.name)
+        cats = Categorical.from_codes(codes, uniques, validate=False)
+        return self._index.groupby(cats)
+
+    @property
+    def observed_grouping(self) -> Grouping:
+        if self._observed:
+            return self
+        return self._observed_grouping
+
+    @cache_readonly
+    def _observed_grouping(self) -> Grouping:
+        grouping = Grouping(self._index, self._orig_grouper, obj=self.obj, level=self.level, sort=self._sort, observed=True, in_axis=self.in_axis, dropna=self._dropna, uniques=self._uniques)
+        return grouping
+
+def get_grouper(obj: NDFrameT, key=None, level=None, sort: bool=True, observed: bool=False, validate: bool=True, dropna: bool=True) -> tuple[ops.BaseGrouper, frozenset[Hashable], NDFrameT]:
+    group_axis = obj.index
+    if level is not None:
+        if isinstance(group_axis, MultiIndex):
+            if is_list_like(level) and len(level) == 1:
+                level = level[0]
+            if key is None and is_scalar(level):
+                key = group_axis.get_level_values(level)
+                level = None
+        else:
+            if is_list_like(level):
+                nlevels = len(level)
+                if nlevels == 1:
+                    level = level[0]
+                elif nlevels == 0:
+                    raise ValueError('No group keys passed!')
+                else:
+                    raise ValueError('multiple levels only valid with MultiIndex')
+            if isinstance(level, str):
+                if obj.index.name != level:
+                    raise ValueError(f'level name {level} is not the name of the index')
+            elif level > 0 or level < -1:
+                raise ValueError('level > 0 or level < -1 only valid with MultiIndex')
+            level = None
+            key = group_axis
+    if isinstance(key, Grouper):
+        (grouper, obj) = key._get_grouper(obj, validate=False)
+        if key.key is None:
+            return (grouper, frozenset(), obj)
+        else:
+            return (grouper, frozenset({key.key}), obj)
+    elif isinstance(key, ops.BaseGrouper):
+        return (key, frozenset(), obj)
+    if not isinstance(key, list):
+        keys = [key]
+        match_axis_length = False
+    else:
+        keys = key
+        match_axis_length = len(keys) == len(group_axis)
+    any_callable = any((callable(g) or isinstance(g, dict) for g in keys))
+    any_groupers = any((isinstance(g, (Grouper, Grouping)) for g in keys))
+    any_arraylike = any((isinstance(g, (list, tuple, Series, Index, np.ndarray)) for g in keys))
+    if not any_callable and (not any_arraylike) and (not any_groupers) and match_axis_length and (level is None):
+        if isinstance(obj, DataFrame):
+            all_in_columns_index = all((g in obj.columns or g in obj.index.names for g in keys))
+        else:
+            assert isinstance(obj, Series)
+            all_in_columns_index = all((g in obj.index.names for g in keys))
+        if not all_in_columns_index:
+            keys = [com.asarray_tuplesafe(keys)]
+    if isinstance(level, (tuple, list)):
+        if key is None:
+            keys = [None] * len(level)
+        levels = level
+    else:
+        levels = [level] * len(keys)
+    groupings: list[Grouping] = []
+    exclusions: set[Hashable] = set()
+
+    def is_in_axis(key) -> bool:
+        if not _is_label_like(key):
+            if obj.ndim == 1:
+                return False
+            items = obj.axes[-1]
+            try:
+                items.get_loc(key)
+            except (KeyError, TypeError, InvalidIndexError):
+                return False
+        return True
+
+    def is_in_obj(gpr) -> bool:
+        if not hasattr(gpr, 'name'):
+            return False
+        try:
+            obj_gpr_column = obj[gpr.name]
+        except (KeyError, IndexError, InvalidIndexError, OutOfBoundsDatetime):
+            return False
+        if isinstance(gpr, Series) and isinstance(obj_gpr_column, Series):
+            return gpr._mgr.references_same_values(obj_gpr_column._mgr, 0)
+        return False
+    for (gpr, level) in zip(keys, levels):
+        if is_in_obj(gpr):
+            in_axis = True
+            exclusions.add(gpr.name)
+        elif is_in_axis(gpr):
+            if obj.ndim != 1 and gpr in obj:
+                if validate:
+                    obj._check_label_or_level_ambiguity(gpr, axis=0)
+                (in_axis, name, gpr) = (True, gpr, obj[gpr])
+                if gpr.ndim != 1:
+                    raise ValueError(f"Grouper for '{name}' not 1-dimensional")
+                exclusions.add(name)
+            elif obj._is_level_reference(gpr, axis=0):
+                (in_axis, level, gpr) = (False, gpr, None)
+            else:
+                raise KeyError(gpr)
+        elif isinstance(gpr, Grouper) and gpr.key is not None:
+            exclusions.add(gpr.key)
+            in_axis = True
+        else:
+            in_axis = False
+        ping = Grouping(group_axis, gpr, obj=obj, level=level, sort=sort, observed=observed, in_axis=in_axis, dropna=dropna) if not isinstance(gpr, Grouping) else gpr
+        groupings.append(ping)
+    if len(groupings) == 0 and len(obj):
+        raise ValueError('No group keys passed!')
+    if len(groupings) == 0:
+        groupings.append(Grouping(default_index(0), np.array([], dtype=np.intp)))
+    grouper = ops.BaseGrouper(group_axis, groupings, sort=sort, dropna=dropna)
+    return (grouper, frozenset(exclusions), obj)
+
+def _is_label_like(val) -> bool:
+    return isinstance(val, (str, tuple)) or (val is not None and is_scalar(val))
+
+def _convert_grouper(axis: Index, grouper):
+    if isinstance(grouper, dict):
+        return grouper.get
+    elif isinstance(grouper, Series):
+        if grouper.index.equals(axis):
+            return grouper._values
+        else:
+            return grouper.reindex(axis)._values
+    elif isinstance(grouper, MultiIndex):
+        return grouper._values
+    elif isinstance(grouper, (list, tuple, Index, Categorical, np.ndarray)):
+        if len(grouper) != len(axis):
+            raise ValueError('Grouper and axis must be same length')
+        if isinstance(grouper, (list, tuple)):
+            grouper = com.asarray_tuplesafe(grouper)
+        return grouper
+    else:
+        return grouper
+
+# File: pandas-main/pandas/core/groupby/indexing.py
+from __future__ import annotations
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Literal, cast
+import numpy as np
+from pandas.util._decorators import cache_readonly, doc
+from pandas.core.dtypes.common import is_integer, is_list_like
+if TYPE_CHECKING:
+    from pandas._typing import PositionalIndexer
+    from pandas import DataFrame, Series
+    from pandas.core.groupby import groupby
+
+class GroupByIndexingMixin:
+
+    @cache_readonly
+    def _positional_selector(self) -> GroupByPositionalSelector:
+        if TYPE_CHECKING:
+            groupby_self = cast(groupby.GroupBy, self)
+        else:
+            groupby_self = self
+        return GroupByPositionalSelector(groupby_self)
+
+    def _make_mask_from_positional_indexer(self, arg: PositionalIndexer | tuple) -> np.ndarray:
+        if is_list_like(arg):
+            if all((is_integer(i) for i in cast(Iterable, arg))):
+                mask = self._make_mask_from_list(cast(Iterable[int], arg))
+            else:
+                mask = self._make_mask_from_tuple(cast(tuple, arg))
+        elif isinstance(arg, slice):
+            mask = self._make_mask_from_slice(arg)
+        elif is_integer(arg):
+            mask = self._make_mask_from_int(cast(int, arg))
+        else:
+            raise TypeError(f'Invalid index {type(arg)}. Must be integer, list-like, slice or a tuple of integers and slices')
+        if isinstance(mask, bool):
+            if mask:
+                mask = self._ascending_count >= 0
+            else:
+                mask = self._ascending_count < 0
+        return cast(np.ndarray, mask)
+
+    def _make_mask_from_int(self, arg: int) -> np.ndarray:
+        if arg >= 0:
+            return self._ascending_count == arg
+        else:
+            return self._descending_count == -arg - 1
+
+    def _make_mask_from_list(self, args: Iterable[int]) -> bool | np.ndarray:
+        positive = [arg for arg in args if arg >= 0]
+        negative = [-arg - 1 for arg in args if arg < 0]
+        mask: bool | np.ndarray = False
+        if positive:
+            mask |= np.isin(self._ascending_count, positive)
+        if negative:
+            mask |= np.isin(self._descending_count, negative)
+        return mask
+
+    def _make_mask_from_tuple(self, args: tuple) -> bool | np.ndarray:
+        mask: bool | np.ndarray = False
+        for arg in args:
+            if is_integer(arg):
+                mask |= self._make_mask_from_int(cast(int, arg))
+            elif isinstance(arg, slice):
+                mask |= self._make_mask_from_slice(arg)
+            else:
+                raise ValueError(f'Invalid argument {type(arg)}. Should be int or slice.')
+        return mask
+
+    def _make_mask_from_slice(self, arg: slice) -> bool | np.ndarray:
+        start = arg.start
+        stop = arg.stop
+        step = arg.step
+        if step is not None and step < 0:
+            raise ValueError(f'Invalid step {step}. Must be non-negative')
+        mask: bool | np.ndarray = True
+        if step is None:
+            step = 1
+        if start is None:
+            if step > 1:
+                mask &= self._ascending_count % step == 0
+        elif start >= 0:
+            mask &= self._ascending_count >= start
+            if step > 1:
+                mask &= (self._ascending_count - start) % step == 0
+        else:
+            mask &= self._descending_count < -start
+            offset_array = self._descending_count + start + 1
+            limit_array = self._ascending_count + self._descending_count + (start + 1) < 0
+            offset_array = np.where(limit_array, self._ascending_count, offset_array)
+            mask &= offset_array % step == 0
+        if stop is not None:
+            if stop >= 0:
+                mask &= self._ascending_count < stop
+            else:
+                mask &= self._descending_count >= -stop
+        return mask
+
+    @cache_readonly
+    def _ascending_count(self) -> np.ndarray:
+        if TYPE_CHECKING:
+            groupby_self = cast(groupby.GroupBy, self)
+        else:
+            groupby_self = self
+        return groupby_self._cumcount_array()
+
+    @cache_readonly
+    def _descending_count(self) -> np.ndarray:
+        if TYPE_CHECKING:
+            groupby_self = cast(groupby.GroupBy, self)
+        else:
+            groupby_self = self
+        return groupby_self._cumcount_array(ascending=False)
+
+@doc(GroupByIndexingMixin._positional_selector)
+class GroupByPositionalSelector:
+
+    def __init__(self, groupby_object: groupby.GroupBy) -> None:
+        self.groupby_object = groupby_object
+
+    def __getitem__(self, arg: PositionalIndexer | tuple) -> DataFrame | Series:
+        mask = self.groupby_object._make_mask_from_positional_indexer(arg)
+        return self.groupby_object._mask_selected_obj(mask)
+
+class GroupByNthSelector:
+
+    def __init__(self, groupby_object: groupby.GroupBy) -> None:
+        self.groupby_object = groupby_object
+
+    def __call__(self, n: PositionalIndexer | tuple, dropna: Literal['any', 'all', None]=None) -> DataFrame | Series:
+        return self.groupby_object._nth(n, dropna)
+
+    def __getitem__(self, n: PositionalIndexer | tuple) -> DataFrame | Series:
+        return self.groupby_object._nth(n)
+
+# File: pandas-main/pandas/core/groupby/numba_.py
+""""""
+from __future__ import annotations
+import functools
+import inspect
+from typing import TYPE_CHECKING, Any
+import numpy as np
+from pandas.compat._optional import import_optional_dependency
+from pandas.core.util.numba_ import NumbaUtilError, jit_user_function
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import Scalar
+
+def validate_udf(func: Callable) -> None:
+    if not callable(func):
+        raise NotImplementedError('Numba engine can only be used with a single function.')
+    udf_signature = list(inspect.signature(func).parameters.keys())
+    expected_args = ['values', 'index']
+    min_number_args = len(expected_args)
+    if len(udf_signature) < min_number_args or udf_signature[:min_number_args] != expected_args:
+        raise NumbaUtilError(f'The first {min_number_args} arguments to {func.__name__} must be {expected_args}')
+
+@functools.cache
+def generate_numba_agg_func(func: Callable[..., Scalar], nopython: bool, nogil: bool, parallel: bool) -> Callable[[np.ndarray, np.ndarray, np.ndarray, np.ndarray, int, Any], np.ndarray]:
+    numba_func = jit_user_function(func)
+    if TYPE_CHECKING:
+        import numba
+    else:
+        numba = import_optional_dependency('numba')
+
+    @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+    def group_agg(values: np.ndarray, index: np.ndarray, begin: np.ndarray, end: np.ndarray, num_columns: int, *args: Any) -> np.ndarray:
+        assert len(begin) == len(end)
+        num_groups = len(begin)
+        result = np.empty((num_groups, num_columns))
+        for i in numba.prange(num_groups):
+            group_index = index[begin[i]:end[i]]
+            for j in numba.prange(num_columns):
+                group = values[begin[i]:end[i], j]
+                result[i, j] = numba_func(group, group_index, *args)
+        return result
+    return group_agg
+
+@functools.cache
+def generate_numba_transform_func(func: Callable[..., np.ndarray], nopython: bool, nogil: bool, parallel: bool) -> Callable[[np.ndarray, np.ndarray, np.ndarray, np.ndarray, int, Any], np.ndarray]:
+    numba_func = jit_user_function(func)
+    if TYPE_CHECKING:
+        import numba
+    else:
+        numba = import_optional_dependency('numba')
+
+    @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+    def group_transform(values: np.ndarray, index: np.ndarray, begin: np.ndarray, end: np.ndarray, num_columns: int, *args: Any) -> np.ndarray:
+        assert len(begin) == len(end)
+        num_groups = len(begin)
+        result = np.empty((len(values), num_columns))
+        for i in numba.prange(num_groups):
+            group_index = index[begin[i]:end[i]]
+            for j in numba.prange(num_columns):
+                group = values[begin[i]:end[i], j]
+                result[begin[i]:end[i], j] = numba_func(group, group_index, *args)
+        return result
+    return group_transform
+
+# File: pandas-main/pandas/core/groupby/ops.py
+""""""
+from __future__ import annotations
+import collections
+import functools
+from typing import TYPE_CHECKING, Generic, final
+import numpy as np
+from pandas._libs import NaT, lib
+import pandas._libs.groupby as libgroupby
+from pandas._typing import ArrayLike, AxisInt, NDFrameT, Shape, npt
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import cache_readonly
+from pandas.core.dtypes.cast import maybe_cast_pointwise_result, maybe_downcast_to_dtype
+from pandas.core.dtypes.common import ensure_float64, ensure_int64, ensure_platform_int, ensure_uint64, is_1d_only_ea_dtype
+from pandas.core.dtypes.missing import isna, maybe_fill
+from pandas.core.arrays import Categorical
+from pandas.core.frame import DataFrame
+from pandas.core.groupby import grouper
+from pandas.core.indexes.api import CategoricalIndex, Index, MultiIndex, ensure_index
+from pandas.core.series import Series
+from pandas.core.sorting import compress_group_index, decons_obs_group_ids, get_group_index, get_group_index_sorter, get_indexer_dict
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator, Hashable, Iterator
+    from pandas.core.generic import NDFrame
+
+def check_result_array(obj, dtype) -> None:
+    if isinstance(obj, np.ndarray):
+        if dtype != object:
+            raise ValueError('Must produce aggregated value')
+
+def extract_result(res):
+    if hasattr(res, '_values'):
+        res = res._values
+        if res.ndim == 1 and len(res) == 1:
+            res = res[0]
+    return res
+
+class WrappedCythonOp:
+    cast_blocklist = frozenset(['any', 'all', 'rank', 'count', 'size', 'idxmin', 'idxmax'])
+
+    def __init__(self, kind: str, how: str, has_dropped_na: bool) -> None:
+        self.kind = kind
+        self.how = how
+        self.has_dropped_na = has_dropped_na
+    _CYTHON_FUNCTIONS: dict[str, dict] = {'aggregate': {'any': functools.partial(libgroupby.group_any_all, val_test='any'), 'all': functools.partial(libgroupby.group_any_all, val_test='all'), 'sum': 'group_sum', 'prod': 'group_prod', 'idxmin': functools.partial(libgroupby.group_idxmin_idxmax, name='idxmin'), 'idxmax': functools.partial(libgroupby.group_idxmin_idxmax, name='idxmax'), 'min': 'group_min', 'max': 'group_max', 'mean': 'group_mean', 'median': 'group_median_float64', 'var': 'group_var', 'std': functools.partial(libgroupby.group_var, name='std'), 'sem': functools.partial(libgroupby.group_var, name='sem'), 'skew': 'group_skew', 'first': 'group_nth', 'last': 'group_last', 'ohlc': 'group_ohlc'}, 'transform': {'cumprod': 'group_cumprod', 'cumsum': 'group_cumsum', 'cummin': 'group_cummin', 'cummax': 'group_cummax', 'rank': 'group_rank'}}
+    _cython_arity = {'ohlc': 4}
+
+    @classmethod
+    def get_kind_from_how(cls, how: str) -> str:
+        if how in cls._CYTHON_FUNCTIONS['aggregate']:
+            return 'aggregate'
+        return 'transform'
+
+    @classmethod
+    @functools.cache
+    def _get_cython_function(cls, kind: str, how: str, dtype: np.dtype, is_numeric: bool):
+        dtype_str = dtype.name
+        ftype = cls._CYTHON_FUNCTIONS[kind][how]
+        if callable(ftype):
+            f = ftype
+        else:
+            f = getattr(libgroupby, ftype)
+        if is_numeric:
+            return f
+        elif dtype == np.dtype(object):
+            if how in ['median', 'cumprod']:
+                raise NotImplementedError(f'function is not implemented for this dtype: [how->{how},dtype->{dtype_str}]')
+            elif how in ['std', 'sem', 'idxmin', 'idxmax']:
+                return f
+            elif how == 'skew':
+                pass
+            elif 'object' not in f.__signatures__:
+                raise NotImplementedError(f'function is not implemented for this dtype: [how->{how},dtype->{dtype_str}]')
+            return f
+        else:
+            raise NotImplementedError('This should not be reached. Please report a bug at github.com/pandas-dev/pandas/', dtype)
+
+    def _get_cython_vals(self, values: np.ndarray) -> np.ndarray:
+        how = self.how
+        if how in ['median', 'std', 'sem', 'skew']:
+            values = ensure_float64(values)
+        elif values.dtype.kind in 'iu':
+            if how in ['var', 'mean'] or (self.kind == 'transform' and self.has_dropped_na):
+                values = ensure_float64(values)
+            elif how in ['sum', 'ohlc', 'prod', 'cumsum', 'cumprod']:
+                if values.dtype.kind == 'i':
+                    values = ensure_int64(values)
+                else:
+                    values = ensure_uint64(values)
+        return values
+
+    def _get_output_shape(self, ngroups: int, values: np.ndarray) -> Shape:
+        how = self.how
+        kind = self.kind
+        arity = self._cython_arity.get(how, 1)
+        out_shape: Shape
+        if how == 'ohlc':
+            out_shape = (ngroups, arity)
+        elif arity > 1:
+            raise NotImplementedError("arity of more than 1 is not supported for the 'how' argument")
+        elif kind == 'transform':
+            out_shape = values.shape
+        else:
+            out_shape = (ngroups,) + values.shape[1:]
+        return out_shape
+
+    def _get_out_dtype(self, dtype: np.dtype) -> np.dtype:
+        how = self.how
+        if how == 'rank':
+            out_dtype = 'float64'
+        elif how in ['idxmin', 'idxmax']:
+            out_dtype = 'intp'
+        elif dtype.kind in 'iufcb':
+            out_dtype = f'{dtype.kind}{dtype.itemsize}'
+        else:
+            out_dtype = 'object'
+        return np.dtype(out_dtype)
+
+    def _get_result_dtype(self, dtype: np.dtype) -> np.dtype:
+        how = self.how
+        if how in ['sum', 'cumsum', 'sum', 'prod', 'cumprod']:
+            if dtype == np.dtype(bool):
+                return np.dtype(np.int64)
+        elif how in ['mean', 'median', 'var', 'std', 'sem']:
+            if dtype.kind in 'fc':
+                return dtype
+            elif dtype.kind in 'iub':
+                return np.dtype(np.float64)
+        return dtype
+
+    @final
+    def _cython_op_ndim_compat(self, values: np.ndarray, *, min_count: int, ngroups: int, comp_ids: np.ndarray, mask: npt.NDArray[np.bool_] | None=None, result_mask: npt.NDArray[np.bool_] | None=None, **kwargs) -> np.ndarray:
+        if values.ndim == 1:
+            values2d = values[None, :]
+            if mask is not None:
+                mask = mask[None, :]
+            if result_mask is not None:
+                result_mask = result_mask[None, :]
+            res = self._call_cython_op(values2d, min_count=min_count, ngroups=ngroups, comp_ids=comp_ids, mask=mask, result_mask=result_mask, **kwargs)
+            if res.shape[0] == 1:
+                return res[0]
+            return res.T
+        return self._call_cython_op(values, min_count=min_count, ngroups=ngroups, comp_ids=comp_ids, mask=mask, result_mask=result_mask, **kwargs)
+
+    @final
+    def _call_cython_op(self, values: np.ndarray, *, min_count: int, ngroups: int, comp_ids: np.ndarray, mask: npt.NDArray[np.bool_] | None, result_mask: npt.NDArray[np.bool_] | None, **kwargs) -> np.ndarray:
+        orig_values = values
+        dtype = values.dtype
+        is_numeric = dtype.kind in 'iufcb'
+        is_datetimelike = dtype.kind in 'mM'
+        if is_datetimelike:
+            values = values.view('int64')
+            is_numeric = True
+        elif dtype.kind == 'b':
+            values = values.view('uint8')
+        if values.dtype == 'float16':
+            values = values.astype(np.float32)
+        if self.how in ['any', 'all']:
+            if mask is None:
+                mask = isna(values)
+            if dtype == object:
+                if kwargs['skipna']:
+                    if mask.any():
+                        values = values.copy()
+                        values[mask] = True
+            values = values.astype(bool, copy=False).view(np.int8)
+            is_numeric = True
+        values = values.T
+        if mask is not None:
+            mask = mask.T
+            if result_mask is not None:
+                result_mask = result_mask.T
+        out_shape = self._get_output_shape(ngroups, values)
+        func = self._get_cython_function(self.kind, self.how, values.dtype, is_numeric)
+        values = self._get_cython_vals(values)
+        out_dtype = self._get_out_dtype(values.dtype)
+        result = maybe_fill(np.empty(out_shape, dtype=out_dtype))
+        if self.kind == 'aggregate':
+            counts = np.zeros(ngroups, dtype=np.int64)
+            if self.how in ['idxmin', 'idxmax', 'min', 'max', 'mean', 'last', 'first', 'sum', 'median']:
+                func(out=result, counts=counts, values=values, labels=comp_ids, min_count=min_count, mask=mask, result_mask=result_mask, is_datetimelike=is_datetimelike, **kwargs)
+            elif self.how in ['sem', 'std', 'var', 'ohlc', 'prod']:
+                if self.how in ['std', 'sem']:
+                    kwargs['is_datetimelike'] = is_datetimelike
+                func(result, counts, values, comp_ids, min_count=min_count, mask=mask, result_mask=result_mask, **kwargs)
+            elif self.how in ['any', 'all']:
+                func(out=result, values=values, labels=comp_ids, mask=mask, result_mask=result_mask, **kwargs)
+                result = result.astype(bool, copy=False)
+            elif self.how in ['skew']:
+                func(out=result, counts=counts, values=values, labels=comp_ids, mask=mask, result_mask=result_mask, **kwargs)
+                if dtype == object:
+                    result = result.astype(object)
+            else:
+                raise NotImplementedError(f'{self.how} is not implemented')
+        else:
+            if self.how != 'rank':
+                kwargs['result_mask'] = result_mask
+            func(out=result, values=values, labels=comp_ids, ngroups=ngroups, is_datetimelike=is_datetimelike, mask=mask, **kwargs)
+        if self.kind == 'aggregate' and self.how not in ['idxmin', 'idxmax']:
+            if result.dtype.kind in 'iu' and (not is_datetimelike):
+                cutoff = max(0 if self.how in ['sum', 'prod'] else 1, min_count)
+                empty_groups = counts < cutoff
+                if empty_groups.any():
+                    if result_mask is not None:
+                        assert result_mask[empty_groups].all()
+                    else:
+                        result = result.astype('float64')
+                        result[empty_groups] = np.nan
+        result = result.T
+        if self.how not in self.cast_blocklist:
+            res_dtype = self._get_result_dtype(orig_values.dtype)
+            op_result = maybe_downcast_to_dtype(result, res_dtype)
+        else:
+            op_result = result
+        return op_result
+
+    @final
+    def _validate_axis(self, axis: AxisInt, values: ArrayLike) -> None:
+        if values.ndim > 2:
+            raise NotImplementedError('number of dimensions is currently limited to 2')
+        if values.ndim == 2:
+            assert axis == 1, axis
+        elif not is_1d_only_ea_dtype(values.dtype):
+            assert axis == 0
+
+    @final
+    def cython_operation(self, *, values: ArrayLike, axis: AxisInt, min_count: int=-1, comp_ids: np.ndarray, ngroups: int, **kwargs) -> ArrayLike:
+        self._validate_axis(axis, values)
+        if not isinstance(values, np.ndarray):
+            return values._groupby_op(how=self.how, has_dropped_na=self.has_dropped_na, min_count=min_count, ngroups=ngroups, ids=comp_ids, **kwargs)
+        return self._cython_op_ndim_compat(values, min_count=min_count, ngroups=ngroups, comp_ids=comp_ids, mask=None, **kwargs)
+
+class BaseGrouper:
+    axis: Index
+
+    def __init__(self, axis: Index, groupings: list[grouper.Grouping], sort: bool=True, dropna: bool=True) -> None:
+        assert isinstance(axis, Index), axis
+        self.axis = axis
+        self._groupings = groupings
+        self._sort = sort
+        self.dropna = dropna
+
+    @property
+    def groupings(self) -> list[grouper.Grouping]:
+        return self._groupings
+
+    def __iter__(self) -> Iterator[Hashable]:
+        return iter(self.indices)
+
+    @property
+    def nkeys(self) -> int:
+        return len(self.groupings)
+
+    def get_iterator(self, data: NDFrameT) -> Iterator[tuple[Hashable, NDFrameT]]:
+        splitter = self._get_splitter(data)
+        keys = self.result_index
+        yield from zip(keys, splitter)
+
+    @final
+    def _get_splitter(self, data: NDFrame) -> DataSplitter:
+        if isinstance(data, Series):
+            klass: type[DataSplitter] = SeriesSplitter
+        else:
+            klass = FrameSplitter
+        return klass(data, self.ngroups, sorted_ids=self._sorted_ids, sort_idx=self.result_ilocs)
+
+    @cache_readonly
+    def indices(self) -> dict[Hashable, npt.NDArray[np.intp]]:
+        if len(self.groupings) == 1 and isinstance(self.result_index, CategoricalIndex):
+            return self.groupings[0].indices
+        codes_list = [ping.codes for ping in self.groupings]
+        return get_indexer_dict(codes_list, self.levels)
+
+    @final
+    @cache_readonly
+    def result_ilocs(self) -> npt.NDArray[np.intp]:
+        ids = self.ids
+        if self.has_dropped_na:
+            mask = np.where(ids >= 0)
+            null_gaps = np.cumsum(ids == -1)[mask]
+            ids = ids[mask]
+        result = get_group_index_sorter(ids, self.ngroups)
+        if self.has_dropped_na:
+            result += np.take(null_gaps, result)
+        return result
+
+    @property
+    def codes(self) -> list[npt.NDArray[np.signedinteger]]:
+        return [ping.codes for ping in self.groupings]
+
+    @property
+    def levels(self) -> list[Index]:
+        if len(self.groupings) > 1:
+            return list(self.result_index.levels)
+        else:
+            return [self.result_index]
+
+    @property
+    def names(self) -> list[Hashable]:
+        return [ping.name for ping in self.groupings]
+
+    @final
+    def size(self) -> Series:
+        ids = self.ids
+        ngroups = self.ngroups
+        out: np.ndarray | list
+        if ngroups:
+            out = np.bincount(ids[ids != -1], minlength=ngroups)
+        else:
+            out = []
+        return Series(out, index=self.result_index, dtype='int64', copy=False)
+
+    @cache_readonly
+    def groups(self) -> dict[Hashable, Index]:
+        if len(self.groupings) == 1:
+            return self.groupings[0].groups
+        (result_index, ids) = self.result_index_and_ids
+        values = result_index._values
+        categories = Categorical(ids, categories=range(len(result_index)))
+        result = {values[group]: self.axis.take(axis_ilocs) for (group, axis_ilocs) in categories._reverse_indexer().items()}
+        return result
+
+    @final
+    @cache_readonly
+    def is_monotonic(self) -> bool:
+        return Index(self.ids).is_monotonic_increasing
+
+    @final
+    @cache_readonly
+    def has_dropped_na(self) -> bool:
+        return bool((self.ids < 0).any())
+
+    @cache_readonly
+    def codes_info(self) -> npt.NDArray[np.intp]:
+        return self.ids
+
+    @final
+    @cache_readonly
+    def ngroups(self) -> int:
+        return len(self.result_index)
+
+    @property
+    def result_index(self) -> Index:
+        return self.result_index_and_ids[0]
+
+    @property
+    def ids(self) -> npt.NDArray[np.intp]:
+        return self.result_index_and_ids[1]
+
+    @cache_readonly
+    def result_index_and_ids(self) -> tuple[Index, npt.NDArray[np.intp]]:
+        levels = [Index._with_infer(ping.uniques) for ping in self.groupings]
+        obs = [ping._observed or not ping._passed_categorical for ping in self.groupings]
+        for (k, (ping, level)) in enumerate(zip(self.groupings, levels)):
+            if ping._passed_categorical:
+                levels[k] = level.set_categories(ping._orig_cats)
+        if len(self.groupings) == 1:
+            result_index = levels[0]
+            result_index.name = self.names[0]
+            ids = ensure_platform_int(self.codes[0])
+        elif all(obs):
+            (result_index, ids) = self._ob_index_and_ids(levels, self.codes, self.names)
+        elif not any(obs):
+            (result_index, ids) = self._unob_index_and_ids(levels, self.codes, self.names)
+        else:
+            names = self.names
+            codes = [ping.codes for ping in self.groupings]
+            ob_indices = [idx for (idx, ob) in enumerate(obs) if ob]
+            unob_indices = [idx for (idx, ob) in enumerate(obs) if not ob]
+            (ob_index, ob_ids) = self._ob_index_and_ids(levels=[levels[idx] for idx in ob_indices], codes=[codes[idx] for idx in ob_indices], names=[names[idx] for idx in ob_indices])
+            (unob_index, unob_ids) = self._unob_index_and_ids(levels=[levels[idx] for idx in unob_indices], codes=[codes[idx] for idx in unob_indices], names=[names[idx] for idx in unob_indices])
+            result_index_codes = np.concatenate([np.tile(unob_index.codes, len(ob_index)), np.repeat(ob_index.codes, len(unob_index), axis=1)], axis=0)
+            (_, index) = np.unique(unob_indices + ob_indices, return_index=True)
+            result_index = MultiIndex(levels=list(unob_index.levels) + list(ob_index.levels), codes=result_index_codes, names=list(unob_index.names) + list(ob_index.names)).reorder_levels(index)
+            ids = len(unob_index) * ob_ids + unob_ids
+            if self._sort:
+                sorter = result_index.argsort()
+                result_index = result_index.take(sorter)
+                (_, index) = np.unique(sorter, return_index=True)
+                ids = ensure_platform_int(ids)
+                ids = index.take(ids)
+            else:
+                (ids, uniques) = compress_group_index(ids, sort=False)
+                ids = ensure_platform_int(ids)
+                taker = np.concatenate([uniques, np.delete(np.arange(len(result_index)), uniques)])
+                result_index = result_index.take(taker)
+        return (result_index, ids)
+
+    @property
+    def observed_grouper(self) -> BaseGrouper:
+        if all((ping._observed for ping in self.groupings)):
+            return self
+        return self._observed_grouper
+
+    @cache_readonly
+    def _observed_grouper(self) -> BaseGrouper:
+        groupings = [ping.observed_grouping for ping in self.groupings]
+        grouper = BaseGrouper(self.axis, groupings, sort=self._sort, dropna=self.dropna)
+        return grouper
+
+    def _ob_index_and_ids(self, levels: list[Index], codes: list[npt.NDArray[np.intp]], names: list[Hashable]) -> tuple[MultiIndex, npt.NDArray[np.intp]]:
+        shape = tuple((len(level) for level in levels))
+        group_index = get_group_index(codes, shape, sort=True, xnull=True)
+        (ob_ids, obs_group_ids) = compress_group_index(group_index, sort=self._sort)
+        ob_ids = ensure_platform_int(ob_ids)
+        ob_index_codes = decons_obs_group_ids(ob_ids, obs_group_ids, shape, codes, xnull=True)
+        ob_index = MultiIndex(levels=levels, codes=ob_index_codes, names=names, verify_integrity=False)
+        ob_ids = ensure_platform_int(ob_ids)
+        return (ob_index, ob_ids)
+
+    def _unob_index_and_ids(self, levels: list[Index], codes: list[npt.NDArray[np.intp]], names: list[Hashable]) -> tuple[MultiIndex, npt.NDArray[np.intp]]:
+        shape = tuple((len(level) for level in levels))
+        unob_ids = get_group_index(codes, shape, sort=True, xnull=True)
+        unob_index = MultiIndex.from_product(levels, names=names)
+        unob_ids = ensure_platform_int(unob_ids)
+        return (unob_index, unob_ids)
+
+    @final
+    def get_group_levels(self) -> Generator[Index, None, None]:
+        result_index = self.result_index
+        if len(self.groupings) == 1:
+            yield result_index
+        else:
+            for level in range(result_index.nlevels - 1, -1, -1):
+                yield result_index.get_level_values(level)
+
+    @final
+    def _cython_operation(self, kind: str, values, how: str, axis: AxisInt, min_count: int=-1, **kwargs) -> ArrayLike:
+        assert kind in ['transform', 'aggregate']
+        cy_op = WrappedCythonOp(kind=kind, how=how, has_dropped_na=self.has_dropped_na)
+        return cy_op.cython_operation(values=values, axis=axis, min_count=min_count, comp_ids=self.ids, ngroups=self.ngroups, **kwargs)
+
+    @final
+    def agg_series(self, obj: Series, func: Callable, preserve_dtype: bool=False) -> ArrayLike:
+        if not isinstance(obj._values, np.ndarray):
+            preserve_dtype = True
+        result = self._aggregate_series_pure_python(obj, func)
+        npvalues = lib.maybe_convert_objects(result, try_float=False)
+        if preserve_dtype:
+            out = maybe_cast_pointwise_result(npvalues, obj.dtype, numeric_only=True)
+        else:
+            out = npvalues
+        return out
+
+    @final
+    def _aggregate_series_pure_python(self, obj: Series, func: Callable) -> npt.NDArray[np.object_]:
+        result = np.empty(self.ngroups, dtype='O')
+        initialized = False
+        splitter = self._get_splitter(obj)
+        for (i, group) in enumerate(splitter):
+            res = func(group)
+            res = extract_result(res)
+            if not initialized:
+                check_result_array(res, group.dtype)
+                initialized = True
+            result[i] = res
+        return result
+
+    @final
+    def apply_groupwise(self, f: Callable, data: DataFrame | Series) -> tuple[list, bool]:
+        mutated = False
+        splitter = self._get_splitter(data)
+        group_keys = self.result_index
+        result_values = []
+        zipped = zip(group_keys, splitter)
+        for (key, group) in zipped:
+            object.__setattr__(group, 'name', key)
+            group_axes = group.axes
+            res = f(group)
+            if not mutated and (not _is_indexed_like(res, group_axes)):
+                mutated = True
+            result_values.append(res)
+        if len(group_keys) == 0 and getattr(f, '__name__', None) in ['skew', 'sum', 'prod']:
+            f(data.iloc[:0])
+        return (result_values, mutated)
+
+    @final
+    @cache_readonly
+    def _sorted_ids(self) -> npt.NDArray[np.intp]:
+        result = self.ids.take(self.result_ilocs)
+        if getattr(self, 'dropna', True):
+            result = result[result >= 0]
+        return result
+
+class BinGrouper(BaseGrouper):
+    bins: npt.NDArray[np.int64]
+    binlabels: Index
+
+    def __init__(self, bins, binlabels, indexer=None) -> None:
+        self.bins = ensure_int64(bins)
+        self.binlabels = ensure_index(binlabels)
+        self.indexer = indexer
+        assert len(self.binlabels) == len(self.bins)
+
+    @cache_readonly
+    def groups(self):
+        result = {key: value for (key, value) in zip(self.binlabels, self.bins) if key is not NaT}
+        return result
+
+    @property
+    def nkeys(self) -> int:
+        return 1
+
+    @cache_readonly
+    def codes_info(self) -> npt.NDArray[np.intp]:
+        ids = self.ids
+        if self.indexer is not None:
+            sorter = np.lexsort((ids, self.indexer))
+            ids = ids[sorter]
+        return ids
+
+    def get_iterator(self, data: NDFrame):
+        slicer = lambda start, edge: data.iloc[start:edge]
+        start = 0
+        for (edge, label) in zip(self.bins, self.binlabels):
+            if label is not NaT:
+                yield (label, slicer(start, edge))
+            start = edge
+        if start < len(data):
+            yield (self.binlabels[-1], slicer(start, None))
+
+    @cache_readonly
+    def indices(self):
+        indices = collections.defaultdict(list)
+        i = 0
+        for (label, bin) in zip(self.binlabels, self.bins):
+            if i < bin:
+                if label is not NaT:
+                    indices[label] = list(range(i, bin))
+                i = bin
+        return indices
+
+    @cache_readonly
+    def codes(self) -> list[npt.NDArray[np.intp]]:
+        return [self.ids]
+
+    @cache_readonly
+    def result_index_and_ids(self):
+        result_index = self.binlabels
+        if len(self.binlabels) != 0 and isna(self.binlabels[0]):
+            result_index = result_index[1:]
+        ngroups = len(result_index)
+        rep = np.diff(np.r_[0, self.bins])
+        rep = ensure_platform_int(rep)
+        if ngroups == len(self.bins):
+            ids = np.repeat(np.arange(ngroups), rep)
+        else:
+            ids = np.repeat(np.r_[-1, np.arange(ngroups)], rep)
+        ids = ensure_platform_int(ids)
+        return (result_index, ids)
+
+    @property
+    def levels(self) -> list[Index]:
+        return [self.binlabels]
+
+    @property
+    def names(self) -> list[Hashable]:
+        return [self.binlabels.name]
+
+    @property
+    def groupings(self) -> list[grouper.Grouping]:
+        lev = self.binlabels
+        codes = self.ids
+        labels = lev.take(codes)
+        ping = grouper.Grouping(labels, labels, in_axis=False, level=None, uniques=lev._values)
+        return [ping]
+
+    @property
+    def observed_grouper(self) -> BinGrouper:
+        return self
+
+def _is_indexed_like(obj, axes) -> bool:
+    if isinstance(obj, Series):
+        if len(axes) > 1:
+            return False
+        return obj.index.equals(axes[0])
+    elif isinstance(obj, DataFrame):
+        return obj.index.equals(axes[0])
+    return False
+
+class DataSplitter(Generic[NDFrameT]):
+
+    def __init__(self, data: NDFrameT, ngroups: int, *, sort_idx: npt.NDArray[np.intp], sorted_ids: npt.NDArray[np.intp]) -> None:
+        self.data = data
+        self.ngroups = ngroups
+        self._slabels = sorted_ids
+        self._sort_idx = sort_idx
+
+    def __iter__(self) -> Iterator:
+        if self.ngroups == 0:
+            return
+        (starts, ends) = lib.generate_slices(self._slabels, self.ngroups)
+        sdata = self._sorted_data
+        for (start, end) in zip(starts, ends):
+            yield self._chop(sdata, slice(start, end))
+
+    @cache_readonly
+    def _sorted_data(self) -> NDFrameT:
+        return self.data.take(self._sort_idx, axis=0)
+
+    def _chop(self, sdata, slice_obj: slice) -> NDFrame:
+        raise AbstractMethodError(self)
+
+class SeriesSplitter(DataSplitter):
+
+    def _chop(self, sdata: Series, slice_obj: slice) -> Series:
+        mgr = sdata._mgr.get_slice(slice_obj)
+        ser = sdata._constructor_from_mgr(mgr, axes=mgr.axes)
+        ser._name = sdata.name
+        return ser.__finalize__(sdata, method='groupby')
+
+class FrameSplitter(DataSplitter):
+
+    def _chop(self, sdata: DataFrame, slice_obj: slice) -> DataFrame:
+        mgr = sdata._mgr.get_slice(slice_obj, axis=1)
+        df = sdata._constructor_from_mgr(mgr, axes=mgr.axes)
+        return df.__finalize__(sdata, method='groupby')
+
+# File: pandas-main/pandas/core/indexers/__init__.py
+from pandas.core.indexers.utils import check_array_indexer, check_key_length, check_setitem_lengths, disallow_ndim_indexing, is_empty_indexer, is_list_like_indexer, is_scalar_indexer, is_valid_positional_slice, length_of_indexer, maybe_convert_indices, unpack_1tuple, unpack_tuple_and_ellipses, validate_indices
+__all__ = ['is_valid_positional_slice', 'is_list_like_indexer', 'is_scalar_indexer', 'is_empty_indexer', 'check_setitem_lengths', 'validate_indices', 'maybe_convert_indices', 'length_of_indexer', 'disallow_ndim_indexing', 'unpack_1tuple', 'check_key_length', 'check_array_indexer', 'unpack_tuple_and_ellipses']
+
+# File: pandas-main/pandas/core/indexers/objects.py
+""""""
+from __future__ import annotations
+from datetime import timedelta
+import numpy as np
+from pandas._libs.tslibs import BaseOffset
+from pandas._libs.window.indexers import calculate_variable_window_bounds
+from pandas.util._decorators import Appender
+from pandas.core.dtypes.common import ensure_platform_int
+from pandas.core.indexes.datetimes import DatetimeIndex
+from pandas.tseries.offsets import Nano
+get_window_bounds_doc = '\nComputes the bounds of a window.\n\nParameters\n----------\nnum_values : int, default 0\n    number of values that will be aggregated over\nwindow_size : int, default 0\n    the number of rows in a window\nmin_periods : int, default None\n    min_periods passed from the top level rolling API\ncenter : bool, default None\n    center passed from the top level rolling API\nclosed : str, default None\n    closed passed from the top level rolling API\nstep : int, default None\n    step passed from the top level rolling API\n    .. versionadded:: 1.5\nwin_type : str, default None\n    win_type passed from the top level rolling API\n\nReturns\n-------\nA tuple of ndarray[int64]s, indicating the boundaries of each\nwindow\n'
+
+class BaseIndexer:
+
+    def __init__(self, index_array: np.ndarray | None=None, window_size: int=0, **kwargs) -> None:
+        self.index_array = index_array
+        self.window_size = window_size
+        for (key, value) in kwargs.items():
+            setattr(self, key, value)
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(self, num_values: int=0, min_periods: int | None=None, center: bool | None=None, closed: str | None=None, step: int | None=None) -> tuple[np.ndarray, np.ndarray]:
+        raise NotImplementedError
+
+class FixedWindowIndexer(BaseIndexer):
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(self, num_values: int=0, min_periods: int | None=None, center: bool | None=None, closed: str | None=None, step: int | None=None) -> tuple[np.ndarray, np.ndarray]:
+        if center or self.window_size == 0:
+            offset = (self.window_size - 1) // 2
+        else:
+            offset = 0
+        end = np.arange(1 + offset, num_values + 1 + offset, step, dtype='int64')
+        start = end - self.window_size
+        if closed in ['left', 'both']:
+            start -= 1
+        if closed in ['left', 'neither']:
+            end -= 1
+        end = np.clip(end, 0, num_values)
+        start = np.clip(start, 0, num_values)
+        return (start, end)
+
+class VariableWindowIndexer(BaseIndexer):
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(self, num_values: int=0, min_periods: int | None=None, center: bool | None=None, closed: str | None=None, step: int | None=None) -> tuple[np.ndarray, np.ndarray]:
+        return calculate_variable_window_bounds(num_values, self.window_size, min_periods, center, closed, self.index_array)
+
+class VariableOffsetWindowIndexer(BaseIndexer):
+
+    def __init__(self, index_array: np.ndarray | None=None, window_size: int=0, index: DatetimeIndex | None=None, offset: BaseOffset | None=None, **kwargs) -> None:
+        super().__init__(index_array, window_size, **kwargs)
+        if not isinstance(index, DatetimeIndex):
+            raise ValueError('index must be a DatetimeIndex.')
+        self.index = index
+        if not isinstance(offset, BaseOffset):
+            raise ValueError('offset must be a DateOffset-like object.')
+        self.offset = offset
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(self, num_values: int=0, min_periods: int | None=None, center: bool | None=None, closed: str | None=None, step: int | None=None) -> tuple[np.ndarray, np.ndarray]:
+        if step is not None:
+            raise NotImplementedError('step not implemented for variable offset window')
+        if num_values <= 0:
+            return (np.empty(0, dtype='int64'), np.empty(0, dtype='int64'))
+        if closed is None:
+            closed = 'right' if self.index is not None else 'both'
+        right_closed = closed in ['right', 'both']
+        left_closed = closed in ['left', 'both']
+        if self.index[num_values - 1] < self.index[0]:
+            index_growth_sign = -1
+        else:
+            index_growth_sign = 1
+        offset_diff = index_growth_sign * self.offset
+        start = np.empty(num_values, dtype='int64')
+        start.fill(-1)
+        end = np.empty(num_values, dtype='int64')
+        end.fill(-1)
+        start[0] = 0
+        if right_closed:
+            end[0] = 1
+        else:
+            end[0] = 0
+        zero = timedelta(0)
+        for i in range(1, num_values):
+            end_bound = self.index[i]
+            start_bound = end_bound - offset_diff
+            if left_closed:
+                start_bound -= Nano(1)
+            start[i] = i
+            for j in range(start[i - 1], i):
+                start_diff = (self.index[j] - start_bound) * index_growth_sign
+                if start_diff > zero:
+                    start[i] = j
+                    break
+            end_diff = (self.index[end[i - 1]] - end_bound) * index_growth_sign
+            if end_diff == zero and (not right_closed):
+                end[i] = end[i - 1] + 1
+            elif end_diff <= zero:
+                end[i] = i + 1
+            else:
+                end[i] = end[i - 1]
+            if not right_closed:
+                end[i] -= 1
+        return (start, end)
+
+class ExpandingIndexer(BaseIndexer):
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(self, num_values: int=0, min_periods: int | None=None, center: bool | None=None, closed: str | None=None, step: int | None=None) -> tuple[np.ndarray, np.ndarray]:
+        return (np.zeros(num_values, dtype=np.int64), np.arange(1, num_values + 1, dtype=np.int64))
+
+class FixedForwardWindowIndexer(BaseIndexer):
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(self, num_values: int=0, min_periods: int | None=None, center: bool | None=None, closed: str | None=None, step: int | None=None) -> tuple[np.ndarray, np.ndarray]:
+        if center:
+            raise ValueError("Forward-looking windows can't have center=True")
+        if closed is not None:
+            raise ValueError("Forward-looking windows don't support setting the closed argument")
+        if step is None:
+            step = 1
+        start = np.arange(0, num_values, step, dtype='int64')
+        end = start + self.window_size
+        if self.window_size:
+            end = np.clip(end, 0, num_values)
+        return (start, end)
+
+class GroupbyIndexer(BaseIndexer):
+
+    def __init__(self, index_array: np.ndarray | None=None, window_size: int | BaseIndexer=0, groupby_indices: dict | None=None, window_indexer: type[BaseIndexer]=BaseIndexer, indexer_kwargs: dict | None=None, **kwargs) -> None:
+        self.groupby_indices = groupby_indices or {}
+        self.window_indexer = window_indexer
+        self.indexer_kwargs = indexer_kwargs.copy() if indexer_kwargs else {}
+        super().__init__(index_array=index_array, window_size=self.indexer_kwargs.pop('window_size', window_size), **kwargs)
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(self, num_values: int=0, min_periods: int | None=None, center: bool | None=None, closed: str | None=None, step: int | None=None) -> tuple[np.ndarray, np.ndarray]:
+        start_arrays = []
+        end_arrays = []
+        window_indices_start = 0
+        for indices in self.groupby_indices.values():
+            index_array: np.ndarray | None
+            if self.index_array is not None:
+                index_array = self.index_array.take(ensure_platform_int(indices))
+            else:
+                index_array = self.index_array
+            indexer = self.window_indexer(index_array=index_array, window_size=self.window_size, **self.indexer_kwargs)
+            (start, end) = indexer.get_window_bounds(len(indices), min_periods, center, closed, step)
+            start = start.astype(np.int64)
+            end = end.astype(np.int64)
+            assert len(start) == len(end), 'these should be equal in length from get_window_bounds'
+            window_indices = np.arange(window_indices_start, window_indices_start + len(indices))
+            window_indices_start += len(indices)
+            window_indices = np.append(window_indices, [window_indices[-1] + 1]).astype(np.int64, copy=False)
+            start_arrays.append(window_indices.take(ensure_platform_int(start)))
+            end_arrays.append(window_indices.take(ensure_platform_int(end)))
+        if len(start_arrays) == 0:
+            return (np.array([], dtype=np.int64), np.array([], dtype=np.int64))
+        start = np.concatenate(start_arrays)
+        end = np.concatenate(end_arrays)
+        return (start, end)
+
+class ExponentialMovingWindowIndexer(BaseIndexer):
+
+    @Appender(get_window_bounds_doc)
+    def get_window_bounds(self, num_values: int=0, min_periods: int | None=None, center: bool | None=None, closed: str | None=None, step: int | None=None) -> tuple[np.ndarray, np.ndarray]:
+        return (np.array([0], dtype=np.int64), np.array([num_values], dtype=np.int64))
+
+# File: pandas-main/pandas/core/indexers/utils.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+import numpy as np
+from pandas._libs import lib
+from pandas.core.dtypes.common import is_array_like, is_bool_dtype, is_integer, is_integer_dtype, is_list_like
+from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.generic import ABCIndex, ABCSeries
+if TYPE_CHECKING:
+    from pandas._typing import AnyArrayLike
+    from pandas.core.frame import DataFrame
+    from pandas.core.indexes.base import Index
+
+def is_valid_positional_slice(slc: slice) -> bool:
+    return lib.is_int_or_none(slc.start) and lib.is_int_or_none(slc.stop) and lib.is_int_or_none(slc.step)
+
+def is_list_like_indexer(key) -> bool:
+    return is_list_like(key) and (not (isinstance(key, tuple) and type(key) is not tuple))
+
+def is_scalar_indexer(indexer, ndim: int) -> bool:
+    if ndim == 1 and is_integer(indexer):
+        return True
+    if isinstance(indexer, tuple) and len(indexer) == ndim:
+        return all((is_integer(x) for x in indexer))
+    return False
+
+def is_empty_indexer(indexer) -> bool:
+    if is_list_like(indexer) and (not len(indexer)):
+        return True
+    if not isinstance(indexer, tuple):
+        indexer = (indexer,)
+    return any((isinstance(idx, np.ndarray) and len(idx) == 0 for idx in indexer))
+
+def check_setitem_lengths(indexer, value, values) -> bool:
+    no_op = False
+    if isinstance(indexer, (np.ndarray, list)):
+        if is_list_like(value):
+            if len(indexer) != len(value) and values.ndim == 1:
+                if isinstance(indexer, list):
+                    indexer = np.array(indexer)
+                if not (isinstance(indexer, np.ndarray) and indexer.dtype == np.bool_ and (indexer.sum() == len(value))):
+                    raise ValueError('cannot set using a list-like indexer with a different length than the value')
+            if not len(indexer):
+                no_op = True
+    elif isinstance(indexer, slice):
+        if is_list_like(value):
+            if len(value) != length_of_indexer(indexer, values) and values.ndim == 1:
+                raise ValueError('cannot set using a slice indexer with a different length than the value')
+            if not len(value):
+                no_op = True
+    return no_op
+
+def validate_indices(indices: np.ndarray, n: int) -> None:
+    if len(indices):
+        min_idx = indices.min()
+        if min_idx < -1:
+            msg = f"'indices' contains values less than allowed ({min_idx} < -1)"
+            raise ValueError(msg)
+        max_idx = indices.max()
+        if max_idx >= n:
+            raise IndexError('indices are out-of-bounds')
+
+def maybe_convert_indices(indices, n: int, verify: bool=True) -> np.ndarray:
+    if isinstance(indices, list):
+        indices = np.array(indices)
+        if len(indices) == 0:
+            return np.empty(0, dtype=np.intp)
+    mask = indices < 0
+    if mask.any():
+        indices = indices.copy()
+        indices[mask] += n
+    if verify:
+        mask = (indices >= n) | (indices < 0)
+        if mask.any():
+            raise IndexError('indices are out-of-bounds')
+    return indices
+
+def length_of_indexer(indexer, target=None) -> int:
+    if target is not None and isinstance(indexer, slice):
+        target_len = len(target)
+        start = indexer.start
+        stop = indexer.stop
+        step = indexer.step
+        if start is None:
+            start = 0
+        elif start < 0:
+            start += target_len
+        if stop is None or stop > target_len:
+            stop = target_len
+        elif stop < 0:
+            stop += target_len
+        if step is None:
+            step = 1
+        elif step < 0:
+            (start, stop) = (stop + 1, start + 1)
+            step = -step
+        return (stop - start + step - 1) // step
+    elif isinstance(indexer, (ABCSeries, ABCIndex, np.ndarray, list)):
+        if isinstance(indexer, list):
+            indexer = np.array(indexer)
+        if indexer.dtype == bool:
+            return indexer.sum()
+        return len(indexer)
+    elif isinstance(indexer, range):
+        return (indexer.stop - indexer.start) // indexer.step
+    elif not is_list_like_indexer(indexer):
+        return 1
+    raise AssertionError('cannot find the length of the indexer')
+
+def disallow_ndim_indexing(result) -> None:
+    if np.ndim(result) > 1:
+        raise ValueError('Multi-dimensional indexing (e.g. `obj[:, None]`) is no longer supported. Convert to a numpy array before indexing instead.')
+
+def unpack_1tuple(tup):
+    if len(tup) == 1 and isinstance(tup[0], slice):
+        if isinstance(tup, list):
+            raise ValueError('Indexing with a single-item list containing a slice is not allowed. Pass a tuple instead.')
+        return tup[0]
+    return tup
+
+def check_key_length(columns: Index, key, value: DataFrame) -> None:
+    if columns.is_unique:
+        if len(value.columns) != len(key):
+            raise ValueError('Columns must be same length as key')
+    elif len(columns.get_indexer_non_unique(key)[0]) != len(value.columns):
+        raise ValueError('Columns must be same length as key')
+
+def unpack_tuple_and_ellipses(item: tuple):
+    if len(item) > 1:
+        if item[0] is Ellipsis:
+            item = item[1:]
+        elif item[-1] is Ellipsis:
+            item = item[:-1]
+    if len(item) > 1:
+        raise IndexError('too many indices for array.')
+    item = item[0]
+    return item
+
+def check_array_indexer(array: AnyArrayLike, indexer: Any) -> Any:
+    from pandas.core.construction import array as pd_array
+    if is_list_like(indexer):
+        if isinstance(indexer, tuple):
+            return indexer
+    else:
+        return indexer
+    if not is_array_like(indexer):
+        indexer = pd_array(indexer)
+        if len(indexer) == 0:
+            indexer = np.array([], dtype=np.intp)
+    dtype = indexer.dtype
+    if is_bool_dtype(dtype):
+        if isinstance(dtype, ExtensionDtype):
+            indexer = indexer.to_numpy(dtype=bool, na_value=False)
+        else:
+            indexer = np.asarray(indexer, dtype=bool)
+        if len(indexer) != len(array):
+            raise IndexError(f'Boolean index has wrong length: {len(indexer)} instead of {len(array)}')
+    elif is_integer_dtype(dtype):
+        try:
+            indexer = np.asarray(indexer, dtype=np.intp)
+        except ValueError as err:
+            raise ValueError('Cannot index with an integer indexer containing NA values') from err
+    else:
+        raise IndexError('arrays used as indices must be of integer or boolean type')
+    return indexer
+
+# File: pandas-main/pandas/core/indexes/accessors.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, NoReturn, cast
+import warnings
+import numpy as np
+from pandas._libs import lib
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import is_integer_dtype, is_list_like
+from pandas.core.dtypes.dtypes import ArrowDtype, CategoricalDtype, DatetimeTZDtype, PeriodDtype
+from pandas.core.dtypes.generic import ABCSeries
+from pandas.core.accessor import PandasDelegate, delegate_names
+from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray
+from pandas.core.arrays.arrow.array import ArrowExtensionArray
+from pandas.core.base import NoNewAttributesMixin, PandasObject
+from pandas.core.indexes.datetimes import DatetimeIndex
+from pandas.core.indexes.timedeltas import TimedeltaIndex
+if TYPE_CHECKING:
+    from pandas import DataFrame, Series
+
+class Properties(PandasDelegate, PandasObject, NoNewAttributesMixin):
+    _hidden_attrs = PandasObject._hidden_attrs | {'orig', 'name'}
+
+    def __init__(self, data: Series, orig) -> None:
+        if not isinstance(data, ABCSeries):
+            raise TypeError(f'cannot convert an object of type {type(data)} to a datetimelike index')
+        self._parent = data
+        self.orig = orig
+        self.name = getattr(data, 'name', None)
+        self._freeze()
+
+    def _get_values(self):
+        data = self._parent
+        if lib.is_np_dtype(data.dtype, 'M'):
+            return DatetimeIndex(data, copy=False, name=self.name)
+        elif isinstance(data.dtype, DatetimeTZDtype):
+            return DatetimeIndex(data, copy=False, name=self.name)
+        elif lib.is_np_dtype(data.dtype, 'm'):
+            return TimedeltaIndex(data, copy=False, name=self.name)
+        elif isinstance(data.dtype, PeriodDtype):
+            return PeriodArray(data, copy=False)
+        raise TypeError(f'cannot convert an object of type {type(data)} to a datetimelike index')
+
+    def _delegate_property_get(self, name: str):
+        from pandas import Series
+        values = self._get_values()
+        result = getattr(values, name)
+        if isinstance(result, np.ndarray):
+            if is_integer_dtype(result):
+                result = result.astype('int64')
+        elif not is_list_like(result):
+            return result
+        result = np.asarray(result)
+        if self.orig is not None:
+            index = self.orig.index
+        else:
+            index = self._parent.index
+        return Series(result, index=index, name=self.name).__finalize__(self._parent)
+
+    def _delegate_property_set(self, name: str, value, *args, **kwargs) -> NoReturn:
+        raise ValueError('modifications to a property of a datetimelike object are not supported. Change values on the original.')
+
+    def _delegate_method(self, name: str, *args, **kwargs):
+        from pandas import Series
+        values = self._get_values()
+        method = getattr(values, name)
+        result = method(*args, **kwargs)
+        if not is_list_like(result):
+            return result
+        return Series(result, index=self._parent.index, name=self.name).__finalize__(self._parent)
+
+@delegate_names(delegate=ArrowExtensionArray, accessors=TimedeltaArray._datetimelike_ops, typ='property', accessor_mapping=lambda x: f'_dt_{x}', raise_on_missing=False)
+@delegate_names(delegate=ArrowExtensionArray, accessors=TimedeltaArray._datetimelike_methods, typ='method', accessor_mapping=lambda x: f'_dt_{x}', raise_on_missing=False)
+@delegate_names(delegate=ArrowExtensionArray, accessors=DatetimeArray._datetimelike_ops, typ='property', accessor_mapping=lambda x: f'_dt_{x}', raise_on_missing=False)
+@delegate_names(delegate=ArrowExtensionArray, accessors=DatetimeArray._datetimelike_methods, typ='method', accessor_mapping=lambda x: f'_dt_{x}', raise_on_missing=False)
+class ArrowTemporalProperties(PandasDelegate, PandasObject, NoNewAttributesMixin):
+
+    def __init__(self, data: Series, orig) -> None:
+        if not isinstance(data, ABCSeries):
+            raise TypeError(f'cannot convert an object of type {type(data)} to a datetimelike index')
+        self._parent = data
+        self._orig = orig
+        self._freeze()
+
+    def _delegate_property_get(self, name: str):
+        if not hasattr(self._parent.array, f'_dt_{name}'):
+            raise NotImplementedError(f'dt.{name} is not supported for {self._parent.dtype}')
+        result = getattr(self._parent.array, f'_dt_{name}')
+        if not is_list_like(result):
+            return result
+        if self._orig is not None:
+            index = self._orig.index
+        else:
+            index = self._parent.index
+        result = type(self._parent)(result, index=index, name=self._parent.name).__finalize__(self._parent)
+        return result
+
+    def _delegate_method(self, name: str, *args, **kwargs):
+        if not hasattr(self._parent.array, f'_dt_{name}'):
+            raise NotImplementedError(f'dt.{name} is not supported for {self._parent.dtype}')
+        result = getattr(self._parent.array, f'_dt_{name}')(*args, **kwargs)
+        if self._orig is not None:
+            index = self._orig.index
+        else:
+            index = self._parent.index
+        result = type(self._parent)(result, index=index, name=self._parent.name).__finalize__(self._parent)
+        return result
+
+    def to_pytimedelta(self):
+        warnings.warn(f'The behavior of {type(self).__name__}.to_pytimedelta is deprecated, in a future version this will return a Series containing python datetime.timedelta objects instead of an ndarray. To retain the old behavior, call `np.array` on the result', FutureWarning, stacklevel=find_stack_level())
+        return cast(ArrowExtensionArray, self._parent.array)._dt_to_pytimedelta()
+
+    def to_pydatetime(self) -> Series:
+        return cast(ArrowExtensionArray, self._parent.array)._dt_to_pydatetime()
+
+    def isocalendar(self) -> DataFrame:
+        from pandas import DataFrame
+        result = cast(ArrowExtensionArray, self._parent.array)._dt_isocalendar()._pa_array.combine_chunks()
+        iso_calendar_df = DataFrame({col: type(self._parent.array)(result.field(i)) for (i, col) in enumerate(['year', 'week', 'day'])})
+        return iso_calendar_df
+
+    @property
+    def components(self) -> DataFrame:
+        from pandas import DataFrame
+        components_df = DataFrame({col: getattr(self._parent.array, f'_dt_{col}') for col in ['days', 'hours', 'minutes', 'seconds', 'milliseconds', 'microseconds', 'nanoseconds']})
+        return components_df
+
+@delegate_names(delegate=DatetimeArray, accessors=DatetimeArray._datetimelike_ops + ['unit'], typ='property')
+@delegate_names(delegate=DatetimeArray, accessors=DatetimeArray._datetimelike_methods + ['as_unit'], typ='method')
+class DatetimeProperties(Properties):
+
+    def to_pydatetime(self) -> Series:
+        from pandas import Series
+        return Series(self._get_values().to_pydatetime(), dtype=object)
+
+    @property
+    def freq(self):
+        return self._get_values().inferred_freq
+
+    def isocalendar(self) -> DataFrame:
+        return self._get_values().isocalendar().set_index(self._parent.index)
+
+@delegate_names(delegate=TimedeltaArray, accessors=TimedeltaArray._datetimelike_ops, typ='property')
+@delegate_names(delegate=TimedeltaArray, accessors=TimedeltaArray._datetimelike_methods, typ='method')
+class TimedeltaProperties(Properties):
+
+    def to_pytimedelta(self) -> np.ndarray:
+        warnings.warn(f'The behavior of {type(self).__name__}.to_pytimedelta is deprecated, in a future version this will return a Series containing python datetime.timedelta objects instead of an ndarray. To retain the old behavior, call `np.array` on the result', FutureWarning, stacklevel=find_stack_level())
+        return self._get_values().to_pytimedelta()
+
+    @property
+    def components(self) -> DataFrame:
+        return self._get_values().components.set_index(self._parent.index).__finalize__(self._parent)
+
+    @property
+    def freq(self):
+        return self._get_values().inferred_freq
+
+@delegate_names(delegate=PeriodArray, accessors=PeriodArray._datetimelike_ops, typ='property')
+@delegate_names(delegate=PeriodArray, accessors=PeriodArray._datetimelike_methods, typ='method')
+class PeriodProperties(Properties):
+
+class CombinedDatetimelikeProperties(DatetimeProperties, TimedeltaProperties, PeriodProperties):
+
+    def __new__(cls, data: Series):
+        if not isinstance(data, ABCSeries):
+            raise TypeError(f'cannot convert an object of type {type(data)} to a datetimelike index')
+        orig = data if isinstance(data.dtype, CategoricalDtype) else None
+        if orig is not None:
+            data = data._constructor(orig.array, name=orig.name, copy=False, dtype=orig._values.categories.dtype, index=orig.index)
+        if isinstance(data.dtype, ArrowDtype) and data.dtype.kind in 'Mm':
+            return ArrowTemporalProperties(data, orig)
+        if lib.is_np_dtype(data.dtype, 'M'):
+            return DatetimeProperties(data, orig)
+        elif isinstance(data.dtype, DatetimeTZDtype):
+            return DatetimeProperties(data, orig)
+        elif lib.is_np_dtype(data.dtype, 'm'):
+            return TimedeltaProperties(data, orig)
+        elif isinstance(data.dtype, PeriodDtype):
+            return PeriodProperties(data, orig)
+        raise AttributeError('Can only use .dt accessor with datetimelike values')
+
+# File: pandas-main/pandas/core/indexes/api.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, cast
+import numpy as np
+from pandas._libs import NaT, lib
+from pandas.errors import InvalidIndexError
+from pandas.core.dtypes.cast import find_common_type
+from pandas.core.algorithms import safe_sort
+from pandas.core.indexes.base import Index, _new_Index, ensure_index, ensure_index_from_sequences, get_unanimous_names, maybe_sequence_to_range
+from pandas.core.indexes.category import CategoricalIndex
+from pandas.core.indexes.datetimes import DatetimeIndex
+from pandas.core.indexes.interval import IntervalIndex
+from pandas.core.indexes.multi import MultiIndex
+from pandas.core.indexes.period import PeriodIndex
+from pandas.core.indexes.range import RangeIndex
+from pandas.core.indexes.timedeltas import TimedeltaIndex
+if TYPE_CHECKING:
+    from pandas._typing import Axis
+__all__ = ['Index', 'MultiIndex', 'CategoricalIndex', 'IntervalIndex', 'RangeIndex', 'InvalidIndexError', 'TimedeltaIndex', 'PeriodIndex', 'DatetimeIndex', '_new_Index', 'NaT', 'ensure_index', 'ensure_index_from_sequences', 'get_objs_combined_axis', 'union_indexes', 'get_unanimous_names', 'all_indexes_same', 'default_index', 'safe_sort_index', 'maybe_sequence_to_range']
+
+def get_objs_combined_axis(objs, intersect: bool=False, axis: Axis=0, sort: bool=True) -> Index:
+    obs_idxes = [obj._get_axis(axis) for obj in objs]
+    return _get_combined_index(obs_idxes, intersect=intersect, sort=sort)
+
+def _get_distinct_objs(objs: list[Index]) -> list[Index]:
+    ids: set[int] = set()
+    res = []
+    for obj in objs:
+        if id(obj) not in ids:
+            ids.add(id(obj))
+            res.append(obj)
+    return res
+
+def _get_combined_index(indexes: list[Index], intersect: bool=False, sort: bool=False) -> Index:
+    indexes = _get_distinct_objs(indexes)
+    if len(indexes) == 0:
+        index: Index = default_index(0)
+    elif len(indexes) == 1:
+        index = indexes[0]
+    elif intersect:
+        index = indexes[0]
+        for other in indexes[1:]:
+            index = index.intersection(other)
+    else:
+        index = union_indexes(indexes, sort=False)
+        index = ensure_index(index)
+    if sort:
+        index = safe_sort_index(index)
+    return index
+
+def safe_sort_index(index: Index) -> Index:
+    if index.is_monotonic_increasing:
+        return index
+    try:
+        array_sorted = safe_sort(index)
+    except TypeError:
+        pass
+    else:
+        if isinstance(array_sorted, Index):
+            return array_sorted
+        array_sorted = cast(np.ndarray, array_sorted)
+        if isinstance(index, MultiIndex):
+            index = MultiIndex.from_tuples(array_sorted, names=index.names)
+        else:
+            index = Index(array_sorted, name=index.name, dtype=index.dtype)
+    return index
+
+def union_indexes(indexes, sort: bool | None=True) -> Index:
+    if len(indexes) == 0:
+        raise AssertionError('Must have at least 1 Index to union')
+    if len(indexes) == 1:
+        result = indexes[0]
+        if isinstance(result, list):
+            if not sort:
+                result = Index(result)
+            else:
+                result = Index(sorted(result))
+        return result
+    (indexes, kind) = _sanitize_and_check(indexes)
+    if kind == 'special':
+        result = indexes[0]
+        num_dtis = 0
+        num_dti_tzs = 0
+        for idx in indexes:
+            if isinstance(idx, DatetimeIndex):
+                num_dtis += 1
+                if idx.tz is not None:
+                    num_dti_tzs += 1
+        if num_dti_tzs not in [0, num_dtis]:
+            raise TypeError('Cannot join tz-naive with tz-aware DatetimeIndex')
+        if num_dtis == len(indexes):
+            sort = True
+            result = indexes[0]
+        elif num_dtis > 1:
+            sort = False
+            indexes = [x.astype(object, copy=False) for x in indexes]
+            result = indexes[0]
+        for other in indexes[1:]:
+            result = result.union(other, sort=None if sort else False)
+        return result
+    elif kind == 'array':
+        if not all_indexes_same(indexes):
+            dtype = find_common_type([idx.dtype for idx in indexes])
+            inds = [ind.astype(dtype, copy=False) for ind in indexes]
+            index = inds[0].unique()
+            other = inds[1].append(inds[2:])
+            diff = other[index.get_indexer_for(other) == -1]
+            if len(diff):
+                index = index.append(diff.unique())
+            if sort:
+                index = index.sort_values()
+        else:
+            index = indexes[0]
+        name = get_unanimous_names(*indexes)[0]
+        if name != index.name:
+            index = index.rename(name)
+        return index
+    elif kind == 'list':
+        dtypes = [idx.dtype for idx in indexes if isinstance(idx, Index)]
+        if dtypes:
+            dtype = find_common_type(dtypes)
+        else:
+            dtype = None
+        all_lists = (idx.tolist() if isinstance(idx, Index) else idx for idx in indexes)
+        return Index(lib.fast_unique_multiple_list_gen(all_lists, sort=bool(sort)), dtype=dtype)
+    else:
+        raise ValueError(f"kind={kind!r} must be 'special', 'array' or 'list'.")
+
+def _sanitize_and_check(indexes):
+    kinds = {type(index) for index in indexes}
+    if list in kinds:
+        if len(kinds) > 1:
+            indexes = [Index(list(x)) if not isinstance(x, Index) else x for x in indexes]
+            kinds -= {list}
+        else:
+            return (indexes, 'list')
+    if len(kinds) > 1 or Index not in kinds:
+        return (indexes, 'special')
+    else:
+        return (indexes, 'array')
+
+def all_indexes_same(indexes) -> bool:
+    itr = iter(indexes)
+    first = next(itr)
+    return all((first.equals(index) for index in itr))
+
+def default_index(n: int) -> RangeIndex:
+    rng = range(n)
+    return RangeIndex._simple_new(rng, name=None)
+
+# File: pandas-main/pandas/core/indexes/base.py
+from __future__ import annotations
+from collections import abc
+from datetime import datetime
+import functools
+from itertools import zip_longest
+import operator
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, NoReturn, cast, final, overload
+import warnings
+import numpy as np
+from pandas._config import get_option
+from pandas._libs import NaT, algos as libalgos, index as libindex, lib, writers
+from pandas._libs.internals import BlockValuesRefs
+import pandas._libs.join as libjoin
+from pandas._libs.lib import is_datetime_array, no_default
+from pandas._libs.tslibs import IncompatibleFrequency, OutOfBoundsDatetime, Timestamp, tz_compare
+from pandas._typing import AnyAll, ArrayLike, Axes, Axis, AxisInt, DropKeep, Dtype, DtypeObj, F, IgnoreRaise, IndexLabel, IndexT, JoinHow, Level, NaPosition, ReindexMethod, Self, Shape, SliceType, npt
+from pandas.compat.numpy import function as nv
+from pandas.errors import DuplicateLabelError, InvalidIndexError
+from pandas.util._decorators import Appender, cache_readonly, doc
+from pandas.util._exceptions import find_stack_level, rewrite_exception
+from pandas.core.dtypes.astype import astype_array, astype_is_view
+from pandas.core.dtypes.cast import LossySetitemError, can_hold_element, common_dtype_categorical_compat, find_result_type, infer_dtype_from, maybe_cast_pointwise_result, np_can_hold_element
+from pandas.core.dtypes.common import ensure_int64, ensure_object, ensure_platform_int, is_any_real_numeric_dtype, is_bool_dtype, is_ea_or_datetimelike_dtype, is_float, is_hashable, is_integer, is_iterator, is_list_like, is_numeric_dtype, is_object_dtype, is_scalar, is_signed_integer_dtype, is_string_dtype, needs_i8_conversion, pandas_dtype, validate_all_hashable
+from pandas.core.dtypes.concat import concat_compat
+from pandas.core.dtypes.dtypes import ArrowDtype, CategoricalDtype, DatetimeTZDtype, ExtensionDtype, IntervalDtype, PeriodDtype, SparseDtype
+from pandas.core.dtypes.generic import ABCCategoricalIndex, ABCDataFrame, ABCDatetimeIndex, ABCIntervalIndex, ABCMultiIndex, ABCPeriodIndex, ABCRangeIndex, ABCSeries, ABCTimedeltaIndex
+from pandas.core.dtypes.inference import is_dict_like
+from pandas.core.dtypes.missing import array_equivalent, is_valid_na_for_dtype, isna
+from pandas.core import arraylike, nanops, ops
+from pandas.core.accessor import Accessor
+import pandas.core.algorithms as algos
+from pandas.core.array_algos.putmask import setitem_datetimelike_compat, validate_putmask
+from pandas.core.arrays import ArrowExtensionArray, BaseMaskedArray, Categorical, DatetimeArray, ExtensionArray, TimedeltaArray
+from pandas.core.arrays.string_ import StringArray, StringDtype
+from pandas.core.base import IndexOpsMixin, PandasObject
+import pandas.core.common as com
+from pandas.core.construction import ensure_wrapped_if_datetimelike, extract_array, sanitize_array
+from pandas.core.indexers import disallow_ndim_indexing, is_valid_positional_slice
+from pandas.core.indexes.frozen import FrozenList
+from pandas.core.missing import clean_reindex_fill_method
+from pandas.core.ops import get_op_result_name
+from pandas.core.sorting import ensure_key_mapped, get_group_index_sorter, nargsort
+from pandas.core.strings.accessor import StringMethods
+from pandas.io.formats.printing import PrettyDict, default_pprint, format_object_summary, pprint_thing
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Iterable, Sequence
+    from pandas import CategoricalIndex, DataFrame, MultiIndex, Series
+    from pandas.core.arrays import IntervalArray, PeriodArray
+__all__ = ['Index']
+_unsortable_types = frozenset(('mixed', 'mixed-integer'))
+_index_doc_kwargs: dict[str, str] = {'klass': 'Index', 'inplace': '', 'target_klass': 'Index', 'raises_section': '', 'unique': 'Index', 'duplicated': 'np.ndarray'}
+_index_shared_docs: dict[str, str] = {}
+str_t = str
+_dtype_obj = np.dtype('object')
+_masked_engines = {'Complex128': libindex.MaskedComplex128Engine, 'Complex64': libindex.MaskedComplex64Engine, 'Float64': libindex.MaskedFloat64Engine, 'Float32': libindex.MaskedFloat32Engine, 'UInt64': libindex.MaskedUInt64Engine, 'UInt32': libindex.MaskedUInt32Engine, 'UInt16': libindex.MaskedUInt16Engine, 'UInt8': libindex.MaskedUInt8Engine, 'Int64': libindex.MaskedInt64Engine, 'Int32': libindex.MaskedInt32Engine, 'Int16': libindex.MaskedInt16Engine, 'Int8': libindex.MaskedInt8Engine, 'boolean': libindex.MaskedBoolEngine, 'double[pyarrow]': libindex.MaskedFloat64Engine, 'float64[pyarrow]': libindex.MaskedFloat64Engine, 'float32[pyarrow]': libindex.MaskedFloat32Engine, 'float[pyarrow]': libindex.MaskedFloat32Engine, 'uint64[pyarrow]': libindex.MaskedUInt64Engine, 'uint32[pyarrow]': libindex.MaskedUInt32Engine, 'uint16[pyarrow]': libindex.MaskedUInt16Engine, 'uint8[pyarrow]': libindex.MaskedUInt8Engine, 'int64[pyarrow]': libindex.MaskedInt64Engine, 'int32[pyarrow]': libindex.MaskedInt32Engine, 'int16[pyarrow]': libindex.MaskedInt16Engine, 'int8[pyarrow]': libindex.MaskedInt8Engine, 'bool[pyarrow]': libindex.MaskedBoolEngine}
+
+def _maybe_return_indexers(meth: F) -> F:
+
+    @functools.wraps(meth)
+    def join(self, other: Index, *, how: JoinHow='left', level=None, return_indexers: bool=False, sort: bool=False):
+        (join_index, lidx, ridx) = meth(self, other, how=how, level=level, sort=sort)
+        if not return_indexers:
+            return join_index
+        if lidx is not None:
+            lidx = ensure_platform_int(lidx)
+        if ridx is not None:
+            ridx = ensure_platform_int(ridx)
+        return (join_index, lidx, ridx)
+    return cast(F, join)
+
+def _new_Index(cls, d):
+    if issubclass(cls, ABCPeriodIndex):
+        from pandas.core.indexes.period import _new_PeriodIndex
+        return _new_PeriodIndex(cls, **d)
+    if issubclass(cls, ABCMultiIndex):
+        if 'labels' in d and 'codes' not in d:
+            d['codes'] = d.pop('labels')
+        d['verify_integrity'] = False
+    elif 'dtype' not in d and 'data' in d:
+        d['dtype'] = d['data'].dtype
+    return cls.__new__(cls, **d)
+
+class Index(IndexOpsMixin, PandasObject):
+    __pandas_priority__ = 2000
+
+    @final
+    def _left_indexer_unique(self, other: Self) -> npt.NDArray[np.intp]:
+        sv = self._get_join_target()
+        ov = other._get_join_target()
+        return libjoin.left_join_indexer_unique(sv, ov)
+
+    @final
+    def _left_indexer(self, other: Self) -> tuple[ArrayLike, npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+        sv = self._get_join_target()
+        ov = other._get_join_target()
+        (joined_ndarray, lidx, ridx) = libjoin.left_join_indexer(sv, ov)
+        joined = self._from_join_target(joined_ndarray)
+        return (joined, lidx, ridx)
+
+    @final
+    def _inner_indexer(self, other: Self) -> tuple[ArrayLike, npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+        sv = self._get_join_target()
+        ov = other._get_join_target()
+        (joined_ndarray, lidx, ridx) = libjoin.inner_join_indexer(sv, ov)
+        joined = self._from_join_target(joined_ndarray)
+        return (joined, lidx, ridx)
+
+    @final
+    def _outer_indexer(self, other: Self) -> tuple[ArrayLike, npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+        sv = self._get_join_target()
+        ov = other._get_join_target()
+        (joined_ndarray, lidx, ridx) = libjoin.outer_join_indexer(sv, ov)
+        joined = self._from_join_target(joined_ndarray)
+        return (joined, lidx, ridx)
+    _typ: str = 'index'
+    _data: ExtensionArray | np.ndarray
+    _data_cls: type[ExtensionArray] | tuple[type[np.ndarray], type[ExtensionArray]] = (np.ndarray, ExtensionArray)
+    _id: object | None = None
+    _name: Hashable = None
+    _no_setting_name: bool = False
+    _comparables: list[str] = ['name']
+    _attributes: list[str] = ['name']
+
+    @cache_readonly
+    def _can_hold_strings(self) -> bool:
+        return not is_numeric_dtype(self.dtype)
+    _engine_types: dict[np.dtype | ExtensionDtype, type[libindex.IndexEngine]] = {np.dtype(np.int8): libindex.Int8Engine, np.dtype(np.int16): libindex.Int16Engine, np.dtype(np.int32): libindex.Int32Engine, np.dtype(np.int64): libindex.Int64Engine, np.dtype(np.uint8): libindex.UInt8Engine, np.dtype(np.uint16): libindex.UInt16Engine, np.dtype(np.uint32): libindex.UInt32Engine, np.dtype(np.uint64): libindex.UInt64Engine, np.dtype(np.float32): libindex.Float32Engine, np.dtype(np.float64): libindex.Float64Engine, np.dtype(np.complex64): libindex.Complex64Engine, np.dtype(np.complex128): libindex.Complex128Engine}
+
+    @property
+    def _engine_type(self) -> type[libindex.IndexEngine | libindex.ExtensionEngine]:
+        return self._engine_types.get(self.dtype, libindex.ObjectEngine)
+    _supports_partial_string_indexing = False
+    _accessors = {'str'}
+    str = Accessor('str', StringMethods)
+    _references = None
+
+    def __new__(cls, data=None, dtype=None, copy: bool=False, name=None, tupleize_cols: bool=True) -> Self:
+        from pandas.core.indexes.range import RangeIndex
+        name = maybe_extract_name(name, data, cls)
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+        data_dtype = getattr(data, 'dtype', None)
+        refs = None
+        if not copy and isinstance(data, (ABCSeries, Index)):
+            refs = data._references
+        if isinstance(data, (range, RangeIndex)):
+            result = RangeIndex(start=data, copy=copy, name=name)
+            if dtype is not None:
+                return result.astype(dtype, copy=False)
+            return result
+        elif is_ea_or_datetimelike_dtype(dtype):
+            if isinstance(data, (set, frozenset)):
+                data = list(data)
+        elif is_ea_or_datetimelike_dtype(data_dtype):
+            pass
+        elif isinstance(data, (np.ndarray, ABCMultiIndex)):
+            if isinstance(data, ABCMultiIndex):
+                data = data._values
+            if data.dtype.kind not in 'iufcbmM':
+                data = com.asarray_tuplesafe(data, dtype=_dtype_obj)
+        elif isinstance(data, (ABCSeries, Index)):
+            pass
+        elif is_scalar(data):
+            raise cls._raise_scalar_data_error(data)
+        elif hasattr(data, '__array__'):
+            return cls(np.asarray(data), dtype=dtype, copy=copy, name=name)
+        elif not is_list_like(data) and (not isinstance(data, memoryview)):
+            raise cls._raise_scalar_data_error(data)
+        else:
+            if tupleize_cols:
+                if is_iterator(data):
+                    data = list(data)
+                if data and all((isinstance(e, tuple) for e in data)):
+                    from pandas.core.indexes.multi import MultiIndex
+                    return MultiIndex.from_tuples(data, names=name)
+            if not isinstance(data, (list, tuple)):
+                data = list(data)
+            if len(data) == 0:
+                data = np.array(data, dtype=object)
+            if len(data) and isinstance(data[0], tuple):
+                data = com.asarray_tuplesafe(data, dtype=_dtype_obj)
+        try:
+            arr = sanitize_array(data, None, dtype=dtype, copy=copy)
+        except ValueError as err:
+            if 'index must be specified when data is not list-like' in str(err):
+                raise cls._raise_scalar_data_error(data) from err
+            if 'Data must be 1-dimensional' in str(err):
+                raise ValueError('Index data must be 1-dimensional') from err
+            raise
+        arr = ensure_wrapped_if_datetimelike(arr)
+        klass = cls._dtype_to_subclass(arr.dtype)
+        arr = klass._ensure_array(arr, arr.dtype, copy=False)
+        return klass._simple_new(arr, name, refs=refs)
+
+    @classmethod
+    def _ensure_array(cls, data, dtype, copy: bool):
+        if data.ndim > 1:
+            raise ValueError('Index data must be 1-dimensional')
+        elif dtype == np.float16:
+            raise NotImplementedError('float16 indexes are not supported')
+        if copy:
+            data = data.copy()
+        return data
+
+    @final
+    @classmethod
+    def _dtype_to_subclass(cls, dtype: DtypeObj):
+        if isinstance(dtype, ExtensionDtype):
+            return dtype.index_class
+        if dtype.kind == 'M':
+            from pandas import DatetimeIndex
+            return DatetimeIndex
+        elif dtype.kind == 'm':
+            from pandas import TimedeltaIndex
+            return TimedeltaIndex
+        elif dtype.kind == 'O':
+            return Index
+        elif issubclass(dtype.type, str) or is_numeric_dtype(dtype):
+            return Index
+        raise NotImplementedError(dtype)
+
+    @classmethod
+    def _simple_new(cls, values: ArrayLike, name: Hashable | None=None, refs=None) -> Self:
+        assert isinstance(values, cls._data_cls), type(values)
+        result = object.__new__(cls)
+        result._data = values
+        result._name = name
+        result._cache = {}
+        result._reset_identity()
+        if refs is not None:
+            result._references = refs
+        else:
+            result._references = BlockValuesRefs()
+        result._references.add_index_reference(result)
+        return result
+
+    @classmethod
+    def _with_infer(cls, *args, **kwargs):
+        result = cls(*args, **kwargs)
+        if result.dtype == _dtype_obj and (not result._is_multi):
+            values = lib.maybe_convert_objects(result._values)
+            if values.dtype.kind in 'iufb':
+                return Index(values, name=result.name)
+        return result
+
+    @cache_readonly
+    def _constructor(self) -> type[Self]:
+        return type(self)
+
+    @final
+    def _maybe_check_unique(self) -> None:
+        if not self.is_unique:
+            msg = 'Index has duplicates.'
+            duplicates = self._format_duplicate_message()
+            msg += f'\n{duplicates}'
+            raise DuplicateLabelError(msg)
+
+    @final
+    def _format_duplicate_message(self) -> DataFrame:
+        from pandas import Series
+        duplicates = self[self.duplicated(keep='first')].unique()
+        assert len(duplicates)
+        out = Series(np.arange(len(self)), copy=False).groupby(self, observed=False).agg(list)[duplicates]
+        if self._is_multi:
+            out.index = type(self).from_tuples(out.index)
+        if self.nlevels == 1:
+            out = out.rename_axis('label')
+        return out.to_frame(name='positions')
+
+    def _shallow_copy(self, values, name: Hashable=no_default) -> Self:
+        name = self._name if name is no_default else name
+        return self._simple_new(values, name=name, refs=self._references)
+
+    def _view(self) -> Self:
+        result = self._simple_new(self._values, name=self._name, refs=self._references)
+        result._cache = self._cache
+        return result
+
+    @final
+    def _rename(self, name: Hashable) -> Self:
+        result = self._view()
+        result._name = name
+        return result
+
+    @final
+    def is_(self, other) -> bool:
+        if self is other:
+            return True
+        elif not hasattr(other, '_id'):
+            return False
+        elif self._id is None or other._id is None:
+            return False
+        else:
+            return self._id is other._id
+
+    @final
+    def _reset_identity(self) -> None:
+        self._id = object()
+
+    @final
+    def _cleanup(self) -> None:
+        if '_engine' in self._cache:
+            self._engine.clear_mapping()
+
+    @cache_readonly
+    def _engine(self) -> libindex.IndexEngine | libindex.ExtensionEngine | libindex.MaskedIndexEngine:
+        target_values = self._get_engine_target()
+        if isinstance(self._values, ArrowExtensionArray) and self.dtype.kind in 'Mm':
+            import pyarrow as pa
+            pa_type = self._values._pa_array.type
+            if pa.types.is_timestamp(pa_type):
+                target_values = self._values._to_datetimearray()
+                return libindex.DatetimeEngine(target_values._ndarray)
+            elif pa.types.is_duration(pa_type):
+                target_values = self._values._to_timedeltaarray()
+                return libindex.TimedeltaEngine(target_values._ndarray)
+        if isinstance(target_values, ExtensionArray):
+            if isinstance(target_values, (BaseMaskedArray, ArrowExtensionArray)):
+                try:
+                    return _masked_engines[target_values.dtype.name](target_values)
+                except KeyError:
+                    pass
+            elif self._engine_type is libindex.ObjectEngine:
+                return libindex.ExtensionEngine(target_values)
+        target_values = cast(np.ndarray, target_values)
+        if target_values.dtype == bool:
+            return libindex.BoolEngine(target_values)
+        elif target_values.dtype == np.complex64:
+            return libindex.Complex64Engine(target_values)
+        elif target_values.dtype == np.complex128:
+            return libindex.Complex128Engine(target_values)
+        elif needs_i8_conversion(self.dtype):
+            target_values = self._data._ndarray
+        elif is_string_dtype(self.dtype) and (not is_object_dtype(self.dtype)):
+            return libindex.StringEngine(target_values)
+        return self._engine_type(target_values)
+
+    @final
+    @cache_readonly
+    def _dir_additions_for_owner(self) -> set[str_t]:
+        return {c for c in self.unique(level=0)[:get_option('display.max_dir_items')] if isinstance(c, str) and c.isidentifier()}
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def __array__(self, dtype=None, copy=None) -> np.ndarray:
+        return np.asarray(self._data, dtype=dtype)
+
+    def __array_ufunc__(self, ufunc: np.ufunc, method: str_t, *inputs, **kwargs):
+        if any((isinstance(other, (ABCSeries, ABCDataFrame)) for other in inputs)):
+            return NotImplemented
+        result = arraylike.maybe_dispatch_ufunc_to_dunder_op(self, ufunc, method, *inputs, **kwargs)
+        if result is not NotImplemented:
+            return result
+        if 'out' in kwargs:
+            return arraylike.dispatch_ufunc_with_out(self, ufunc, method, *inputs, **kwargs)
+        if method == 'reduce':
+            result = arraylike.dispatch_reduction_ufunc(self, ufunc, method, *inputs, **kwargs)
+            if result is not NotImplemented:
+                return result
+        new_inputs = [x if x is not self else x._values for x in inputs]
+        result = getattr(ufunc, method)(*new_inputs, **kwargs)
+        if ufunc.nout == 2:
+            return tuple((self.__array_wrap__(x) for x in result))
+        elif method == 'reduce':
+            result = lib.item_from_zerodim(result)
+            return result
+        elif is_scalar(result):
+            return result
+        if result.dtype == np.float16:
+            result = result.astype(np.float32)
+        return self.__array_wrap__(result)
+
+    @final
+    def __array_wrap__(self, result, context=None, return_scalar=False):
+        result = lib.item_from_zerodim(result)
+        if not isinstance(result, Index) and is_bool_dtype(result.dtype) or np.ndim(result) > 1:
+            return result
+        return Index(result, name=self.name)
+
+    @cache_readonly
+    def dtype(self) -> DtypeObj:
+        return self._data.dtype
+
+    @final
+    def ravel(self, order: str_t='C') -> Self:
+        return self[:]
+
+    def view(self, cls=None):
+        if cls is not None:
+            dtype = cls
+            if isinstance(cls, str):
+                dtype = pandas_dtype(cls)
+            if needs_i8_conversion(dtype):
+                idx_cls = self._dtype_to_subclass(dtype)
+                arr = self.array.view(dtype)
+                if isinstance(arr, ExtensionArray):
+                    return idx_cls._simple_new(arr, name=self.name, refs=self._references)
+                return arr
+            result = self._data.view(cls)
+        else:
+            result = self._view()
+        if isinstance(result, Index):
+            result._id = self._id
+        return result
+
+    def astype(self, dtype: Dtype, copy: bool=True):
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+        if self.dtype == dtype:
+            return self.copy() if copy else self
+        values = self._data
+        if isinstance(values, ExtensionArray):
+            with rewrite_exception(type(values).__name__, type(self).__name__):
+                new_values = values.astype(dtype, copy=copy)
+        elif isinstance(dtype, ExtensionDtype):
+            cls = dtype.construct_array_type()
+            new_values = cls._from_sequence(self, dtype=dtype, copy=copy)
+        else:
+            new_values = astype_array(values, dtype=dtype, copy=copy)
+        result = Index(new_values, name=self.name, dtype=new_values.dtype, copy=False)
+        if not copy and self._references is not None and astype_is_view(self.dtype, dtype):
+            result._references = self._references
+            result._references.add_index_reference(result)
+        return result
+    _index_shared_docs['take'] = "\n        Return a new %(klass)s of the values selected by the indices.\n\n        For internal compatibility with numpy arrays.\n\n        Parameters\n        ----------\n        indices : array-like\n            Indices to be taken.\n        axis : int, optional\n            The axis over which to select values, always 0.\n        allow_fill : bool, default True\n            How to handle negative values in `indices`.\n\n            * False: negative values in `indices` indicate positional indices\n              from the right (the default). This is similar to\n              :func:`numpy.take`.\n\n            * True: negative values in `indices` indicate\n              missing values. These values are set to `fill_value`. Any other\n              other negative values raise a ``ValueError``.\n\n        fill_value : scalar, default None\n            If allow_fill=True and fill_value is not None, indices specified by\n            -1 are regarded as NA. If Index doesn't hold NA, raise ValueError.\n        **kwargs\n            Required for compatibility with numpy.\n\n        Returns\n        -------\n        Index\n            An index formed of elements at the given indices. Will be the same\n            type as self, except for RangeIndex.\n\n        See Also\n        --------\n        numpy.ndarray.take: Return an array formed from the\n            elements of a at the given indices.\n\n        Examples\n        --------\n        >>> idx = pd.Index(['a', 'b', 'c'])\n        >>> idx.take([2, 2, 1, 2])\n        Index(['c', 'c', 'b', 'c'], dtype='object')\n        "
+
+    @Appender(_index_shared_docs['take'] % _index_doc_kwargs)
+    def take(self, indices, axis: Axis=0, allow_fill: bool=True, fill_value=None, **kwargs) -> Self:
+        if kwargs:
+            nv.validate_take((), kwargs)
+        if is_scalar(indices):
+            raise TypeError('Expected indices to be array-like')
+        indices = ensure_platform_int(indices)
+        allow_fill = self._maybe_disallow_fill(allow_fill, fill_value, indices)
+        if indices.ndim == 1 and lib.is_range_indexer(indices, len(self)):
+            return self.copy()
+        values = self._values
+        if isinstance(values, np.ndarray):
+            taken = algos.take(values, indices, allow_fill=allow_fill, fill_value=self._na_value)
+        else:
+            taken = values.take(indices, allow_fill=allow_fill, fill_value=self._na_value)
+        return self._constructor._simple_new(taken, name=self.name)
+
+    @final
+    def _maybe_disallow_fill(self, allow_fill: bool, fill_value, indices) -> bool:
+        if allow_fill and fill_value is not None:
+            if self._can_hold_na:
+                if (indices < -1).any():
+                    raise ValueError('When allow_fill=True and fill_value is not None, all indices must be >= -1')
+            else:
+                cls_name = type(self).__name__
+                raise ValueError(f'Unable to fill values because {cls_name} cannot contain NA')
+        else:
+            allow_fill = False
+        return allow_fill
+    _index_shared_docs['repeat'] = "\n        Repeat elements of a %(klass)s.\n\n        Returns a new %(klass)s where each element of the current %(klass)s\n        is repeated consecutively a given number of times.\n\n        Parameters\n        ----------\n        repeats : int or array of ints\n            The number of repetitions for each element. This should be a\n            non-negative integer. Repeating 0 times will return an empty\n            %(klass)s.\n        axis : None\n            Must be ``None``. Has no effect but is accepted for compatibility\n            with numpy.\n\n        Returns\n        -------\n        %(klass)s\n            Newly created %(klass)s with repeated elements.\n\n        See Also\n        --------\n        Series.repeat : Equivalent function for Series.\n        numpy.repeat : Similar method for :class:`numpy.ndarray`.\n\n        Examples\n        --------\n        >>> idx = pd.Index(['a', 'b', 'c'])\n        >>> idx\n        Index(['a', 'b', 'c'], dtype='object')\n        >>> idx.repeat(2)\n        Index(['a', 'a', 'b', 'b', 'c', 'c'], dtype='object')\n        >>> idx.repeat([1, 2, 3])\n        Index(['a', 'b', 'b', 'c', 'c', 'c'], dtype='object')\n        "
+
+    @Appender(_index_shared_docs['repeat'] % _index_doc_kwargs)
+    def repeat(self, repeats, axis: None=None) -> Self:
+        repeats = ensure_platform_int(repeats)
+        nv.validate_repeat((), {'axis': axis})
+        res_values = self._values.repeat(repeats)
+        return self._constructor._simple_new(res_values, name=self.name)
+
+    def copy(self, name: Hashable | None=None, deep: bool=False) -> Self:
+        name = self._validate_names(name=name, deep=deep)[0]
+        if deep:
+            new_data = self._data.copy()
+            new_index = type(self)._simple_new(new_data, name=name)
+        else:
+            new_index = self._rename(name=name)
+        return new_index
+
+    @final
+    def __copy__(self, **kwargs) -> Self:
+        return self.copy(**kwargs)
+
+    @final
+    def __deepcopy__(self, memo=None) -> Self:
+        return self.copy(deep=True)
+
+    @final
+    def __repr__(self) -> str_t:
+        klass_name = type(self).__name__
+        data = self._format_data()
+        attrs = self._format_attrs()
+        attrs_str = [f'{k}={v}' for (k, v) in attrs]
+        prepr = ', '.join(attrs_str)
+        return f'{klass_name}({data}{prepr})'
+
+    @property
+    def _formatter_func(self):
+        return default_pprint
+
+    @final
+    def _format_data(self, name=None) -> str_t:
+        is_justify = True
+        if self.inferred_type == 'string':
+            is_justify = False
+        elif isinstance(self.dtype, CategoricalDtype):
+            self = cast('CategoricalIndex', self)
+            if is_object_dtype(self.categories.dtype):
+                is_justify = False
+        elif isinstance(self, ABCRangeIndex):
+            return ''
+        return format_object_summary(self, self._formatter_func, is_justify=is_justify, name=name, line_break_each_value=self._is_multi)
+
+    def _format_attrs(self) -> list[tuple[str_t, str_t | int | bool | None]]:
+        attrs: list[tuple[str_t, str_t | int | bool | None]] = []
+        if not self._is_multi:
+            attrs.append(('dtype', f"'{self.dtype}'"))
+        if self.name is not None:
+            attrs.append(('name', default_pprint(self.name)))
+        elif self._is_multi and any((x is not None for x in self.names)):
+            attrs.append(('names', default_pprint(self.names)))
+        max_seq_items = get_option('display.max_seq_items') or len(self)
+        if len(self) > max_seq_items:
+            attrs.append(('length', len(self)))
+        return attrs
+
+    @final
+    def _get_level_names(self) -> range | Sequence[Hashable]:
+        if self._is_multi:
+            return maybe_sequence_to_range([level if name is None else name for (level, name) in enumerate(self.names)])
+        else:
+            return range(1) if self.name is None else [self.name]
+
+    @final
+    def _mpl_repr(self) -> np.ndarray:
+        if isinstance(self.dtype, np.dtype) and self.dtype.kind != 'M':
+            return cast(np.ndarray, self.values)
+        return self.astype(object, copy=False)._values
+    _default_na_rep = 'NaN'
+
+    @final
+    def _format_flat(self, *, include_name: bool, formatter: Callable | None=None) -> list[str_t]:
+        header = []
+        if include_name:
+            header.append(pprint_thing(self.name, escape_chars=('\t', '\r', '\n')) if self.name is not None else '')
+        if formatter is not None:
+            return header + list(self.map(formatter))
+        return self._format_with_header(header=header, na_rep=self._default_na_rep)
+
+    def _format_with_header(self, *, header: list[str_t], na_rep: str_t) -> list[str_t]:
+        from pandas.io.formats.format import format_array
+        values = self._values
+        if is_object_dtype(values.dtype) or is_string_dtype(values.dtype) or isinstance(self.dtype, (IntervalDtype, CategoricalDtype)):
+            justify = 'all'
+        else:
+            justify = 'left'
+        formatted = format_array(values, None, justify=justify)
+        result = trim_front(formatted)
+        return header + result
+
+    def _get_values_for_csv(self, *, na_rep: str_t='', decimal: str_t='.', float_format=None, date_format=None, quoting=None) -> npt.NDArray[np.object_]:
+        return get_values_for_csv(self._values, na_rep=na_rep, decimal=decimal, float_format=float_format, date_format=date_format, quoting=quoting)
+
+    def _summary(self, name=None) -> str_t:
+        if len(self) > 0:
+            head = self[0]
+            if hasattr(head, 'format') and (not isinstance(head, str)):
+                head = head.format()
+            elif needs_i8_conversion(self.dtype):
+                head = self._formatter_func(head).replace("'", '')
+            tail = self[-1]
+            if hasattr(tail, 'format') and (not isinstance(tail, str)):
+                tail = tail.format()
+            elif needs_i8_conversion(self.dtype):
+                tail = self._formatter_func(tail).replace("'", '')
+            index_summary = f', {head} to {tail}'
+        else:
+            index_summary = ''
+        if name is None:
+            name = type(self).__name__
+        return f'{name}: {len(self)} entries{index_summary}'
+
+    def to_flat_index(self) -> Self:
+        return self
+
+    @final
+    def to_series(self, index=None, name: Hashable | None=None) -> Series:
+        from pandas import Series
+        if index is None:
+            index = self._view()
+        if name is None:
+            name = self.name
+        return Series(self._values.copy(), index=index, name=name)
+
+    def to_frame(self, index: bool=True, name: Hashable=lib.no_default) -> DataFrame:
+        from pandas import DataFrame
+        if name is lib.no_default:
+            result_name = self._get_level_names()
+        else:
+            result_name = Index([name])
+        result = DataFrame(self, copy=False)
+        result.columns = result_name
+        if index:
+            result.index = self
+        return result
+
+    @property
+    def name(self) -> Hashable:
+        return self._name
+
+    @name.setter
+    def name(self, value: Hashable) -> None:
+        if self._no_setting_name:
+            raise RuntimeError("Cannot set name on a level of a MultiIndex. Use 'MultiIndex.set_names' instead.")
+        maybe_extract_name(value, None, type(self))
+        self._name = value
+
+    @final
+    def _validate_names(self, name=None, names=None, deep: bool=False) -> list[Hashable]:
+        from copy import deepcopy
+        if names is not None and name is not None:
+            raise TypeError('Can only provide one of `names` and `name`')
+        if names is None and name is None:
+            new_names = deepcopy(self.names) if deep else self.names
+        elif names is not None:
+            if not is_list_like(names):
+                raise TypeError('Must pass list-like as `names`.')
+            new_names = names
+        elif not is_list_like(name):
+            new_names = [name]
+        else:
+            new_names = name
+        if len(new_names) != len(self.names):
+            raise ValueError(f'Length of new names must be {len(self.names)}, got {len(new_names)}')
+        validate_all_hashable(*new_names, error_name=f'{type(self).__name__}.name')
+        return new_names
+
+    def _get_default_index_names(self, names: Hashable | Sequence[Hashable] | None=None, default=None) -> list[Hashable]:
+        from pandas.core.indexes.multi import MultiIndex
+        if names is not None:
+            if isinstance(names, (int, str)):
+                names = [names]
+        if not isinstance(names, list) and names is not None:
+            raise ValueError('Index names must be str or 1-dimensional list')
+        if not names:
+            if isinstance(self, MultiIndex):
+                names = com.fill_missing_names(self.names)
+            else:
+                names = [default] if self.name is None else [self.name]
+        return names
+
+    def _get_names(self) -> FrozenList:
+        return FrozenList((self.name,))
+
+    def _set_names(self, values, *, level=None) -> None:
+        if not is_list_like(values):
+            raise ValueError('Names must be a list-like')
+        if len(values) != 1:
+            raise ValueError(f'Length of new names must be 1, got {len(values)}')
+        validate_all_hashable(*values, error_name=f'{type(self).__name__}.name')
+        self._name = values[0]
+    names = property(fset=_set_names, fget=_get_names)
+
+    @overload
+    def set_names(self, names, *, level=..., inplace: Literal[False]=...) -> Self:
+        ...
+
+    @overload
+    def set_names(self, names, *, level=..., inplace: Literal[True]) -> None:
+        ...
+
+    @overload
+    def set_names(self, names, *, level=..., inplace: bool=...) -> Self | None:
+        ...
+
+    def set_names(self, names, *, level=None, inplace: bool=False) -> Self | None:
+        if level is not None and (not isinstance(self, ABCMultiIndex)):
+            raise ValueError('Level must be None for non-MultiIndex')
+        if level is not None and (not is_list_like(level)) and is_list_like(names):
+            raise TypeError('Names must be a string when a single level is provided.')
+        if not is_list_like(names) and level is None and (self.nlevels > 1):
+            raise TypeError('Must pass list-like as `names`.')
+        if is_dict_like(names) and (not isinstance(self, ABCMultiIndex)):
+            raise TypeError('Can only pass dict-like as `names` for MultiIndex.')
+        if is_dict_like(names) and level is not None:
+            raise TypeError('Can not pass level for dictlike `names`.')
+        if isinstance(self, ABCMultiIndex) and is_dict_like(names) and (level is None):
+            (level, names_adjusted) = ([], [])
+            for (i, name) in enumerate(self.names):
+                if name in names.keys():
+                    level.append(i)
+                    names_adjusted.append(names[name])
+            names = names_adjusted
+        if not is_list_like(names):
+            names = [names]
+        if level is not None and (not is_list_like(level)):
+            level = [level]
+        if inplace:
+            idx = self
+        else:
+            idx = self._view()
+        idx._set_names(names, level=level)
+        if not inplace:
+            return idx
+        return None
+
+    @overload
+    def rename(self, name, *, inplace: Literal[False]=...) -> Self:
+        ...
+
+    @overload
+    def rename(self, name, *, inplace: Literal[True]) -> None:
+        ...
+
+    def rename(self, name, *, inplace: bool=False) -> Self | None:
+        return self.set_names([name], inplace=inplace)
+
+    @property
+    def nlevels(self) -> int:
+        return 1
+
+    def _sort_levels_monotonic(self) -> Self:
+        return self
+
+    @final
+    def _validate_index_level(self, level) -> None:
+        if isinstance(level, int):
+            if level < 0 and level != -1:
+                raise IndexError(f'Too many levels: Index has only 1 level, {level} is not a valid level number')
+            if level > 0:
+                raise IndexError(f'Too many levels: Index has only 1 level, not {level + 1}')
+        elif level != self.name:
+            raise KeyError(f'Requested level ({level}) does not match index name ({self.name})')
+
+    def _get_level_number(self, level) -> int:
+        self._validate_index_level(level)
+        return 0
+
+    def sortlevel(self, level=None, ascending: bool | list[bool]=True, sort_remaining=None, na_position: NaPosition='first') -> tuple[Self, np.ndarray]:
+        if not isinstance(ascending, (list, bool)):
+            raise TypeError('ascending must be a single bool value ora list of bool values of length 1')
+        if isinstance(ascending, list):
+            if len(ascending) != 1:
+                raise TypeError('ascending must be a list of bool values of length 1')
+            ascending = ascending[0]
+        if not isinstance(ascending, bool):
+            raise TypeError('ascending must be a bool value')
+        return self.sort_values(return_indexer=True, ascending=ascending, na_position=na_position)
+
+    def _get_level_values(self, level) -> Index:
+        self._validate_index_level(level)
+        return self
+    get_level_values = _get_level_values
+
+    @final
+    def droplevel(self, level: IndexLabel=0):
+        if not isinstance(level, (tuple, list)):
+            level = [level]
+        levnums = sorted((self._get_level_number(lev) for lev in level), reverse=True)
+        return self._drop_level_numbers(levnums)
+
+    @final
+    def _drop_level_numbers(self, levnums: list[int]):
+        if not levnums and (not isinstance(self, ABCMultiIndex)):
+            return self
+        if len(levnums) >= self.nlevels:
+            raise ValueError(f'Cannot remove {len(levnums)} levels from an index with {self.nlevels} levels: at least one level must be left.')
+        self = cast('MultiIndex', self)
+        new_levels = list(self.levels)
+        new_codes = list(self.codes)
+        new_names = list(self.names)
+        for i in levnums:
+            new_levels.pop(i)
+            new_codes.pop(i)
+            new_names.pop(i)
+        if len(new_levels) == 1:
+            lev = new_levels[0]
+            if len(lev) == 0:
+                if len(new_codes[0]) == 0:
+                    result = lev[:0]
+                else:
+                    res_values = algos.take(lev._values, new_codes[0], allow_fill=True)
+                    result = lev._constructor._simple_new(res_values, name=new_names[0])
+            else:
+                mask = new_codes[0] == -1
+                result = new_levels[0].take(new_codes[0])
+                if mask.any():
+                    result = result.putmask(mask, np.nan)
+                result._name = new_names[0]
+            return result
+        else:
+            from pandas.core.indexes.multi import MultiIndex
+            return MultiIndex(levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False)
+
+    @cache_readonly
+    @final
+    def _can_hold_na(self) -> bool:
+        if isinstance(self.dtype, ExtensionDtype):
+            return self.dtype._can_hold_na
+        if self.dtype.kind in 'iub':
+            return False
+        return True
+
+    @property
+    def is_monotonic_increasing(self) -> bool:
+        return self._engine.is_monotonic_increasing
+
+    @property
+    def is_monotonic_decreasing(self) -> bool:
+        return self._engine.is_monotonic_decreasing
+
+    @final
+    @property
+    def _is_strictly_monotonic_increasing(self) -> bool:
+        return self.is_unique and self.is_monotonic_increasing
+
+    @final
+    @property
+    def _is_strictly_monotonic_decreasing(self) -> bool:
+        return self.is_unique and self.is_monotonic_decreasing
+
+    @cache_readonly
+    def is_unique(self) -> bool:
+        return self._engine.is_unique
+
+    @final
+    @property
+    def has_duplicates(self) -> bool:
+        return not self.is_unique
+
+    @cache_readonly
+    def inferred_type(self) -> str_t:
+        return lib.infer_dtype(self._values, skipna=False)
+
+    @cache_readonly
+    @final
+    def _is_all_dates(self) -> bool:
+        if needs_i8_conversion(self.dtype):
+            return True
+        elif self.dtype != _dtype_obj:
+            return False
+        elif self._is_multi:
+            return False
+        return is_datetime_array(ensure_object(self._values))
+
+    @final
+    @cache_readonly
+    def _is_multi(self) -> bool:
+        return isinstance(self, ABCMultiIndex)
+
+    def __reduce__(self):
+        d = {'data': self._data, 'name': self.name}
+        return (_new_Index, (type(self), d), None)
+
+    @cache_readonly
+    def _na_value(self):
+        dtype = self.dtype
+        if isinstance(dtype, np.dtype):
+            if dtype.kind in 'mM':
+                return NaT
+            return np.nan
+        return dtype.na_value
+
+    @cache_readonly
+    def _isnan(self) -> npt.NDArray[np.bool_]:
+        if self._can_hold_na:
+            return isna(self)
+        else:
+            values = np.empty(len(self), dtype=np.bool_)
+            values.fill(False)
+            return values
+
+    @cache_readonly
+    def hasnans(self) -> bool:
+        if self._can_hold_na:
+            return bool(self._isnan.any())
+        else:
+            return False
+
+    @final
+    def isna(self) -> npt.NDArray[np.bool_]:
+        return self._isnan
+    isnull = isna
+
+    @final
+    def notna(self) -> npt.NDArray[np.bool_]:
+        return ~self.isna()
+    notnull = notna
+
+    def fillna(self, value):
+        if not is_scalar(value):
+            raise TypeError(f"'value' must be a scalar, passed: {type(value).__name__}")
+        if self.hasnans:
+            result = self.putmask(self._isnan, value)
+            return Index._with_infer(result, name=self.name)
+        return self._view()
+
+    def dropna(self, how: AnyAll='any') -> Self:
+        if how not in ('any', 'all'):
+            raise ValueError(f'invalid how option: {how}')
+        if self.hasnans:
+            res_values = self._values[~self._isnan]
+            return type(self)._simple_new(res_values, name=self.name)
+        return self._view()
+
+    def unique(self, level: Hashable | None=None) -> Self:
+        if level is not None:
+            self._validate_index_level(level)
+        if self.is_unique:
+            return self._view()
+        result = super().unique()
+        return self._shallow_copy(result)
+
+    def drop_duplicates(self, *, keep: DropKeep='first') -> Self:
+        if self.is_unique:
+            return self._view()
+        return super().drop_duplicates(keep=keep)
+
+    def duplicated(self, keep: DropKeep='first') -> npt.NDArray[np.bool_]:
+        if self.is_unique:
+            return np.zeros(len(self), dtype=bool)
+        return self._duplicated(keep=keep)
+
+    def __iadd__(self, other):
+        return self + other
+
+    @final
+    def __bool__(self) -> NoReturn:
+        raise ValueError(f'The truth value of a {type(self).__name__} is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().')
+
+    def _get_reconciled_name_object(self, other):
+        name = get_op_result_name(self, other)
+        if self.name is not name:
+            return self.rename(name)
+        return self
+
+    @final
+    def _validate_sort_keyword(self, sort) -> None:
+        if sort not in [None, False, True]:
+            raise ValueError(f"The 'sort' keyword only takes the values of None, True, or False; {sort} was passed.")
+
+    @final
+    def _dti_setop_align_tzs(self, other: Index, setop: str_t) -> tuple[Index, Index]:
+        if isinstance(self, ABCDatetimeIndex) and isinstance(other, ABCDatetimeIndex) and (self.tz is not None) and (other.tz is not None):
+            left = self.tz_convert('UTC')
+            right = other.tz_convert('UTC')
+            return (left, right)
+        return (self, other)
+
+    @final
+    def union(self, other, sort: bool | None=None):
+        self._validate_sort_keyword(sort)
+        self._assert_can_do_setop(other)
+        (other, result_name) = self._convert_can_do_setop(other)
+        if self.dtype != other.dtype:
+            if isinstance(self, ABCMultiIndex) and (not is_object_dtype(_unpack_nested_dtype(other))) and (len(other) > 0):
+                raise NotImplementedError('Can only union MultiIndex with MultiIndex or Index of tuples, try mi.to_flat_index().union(other) instead.')
+            (self, other) = self._dti_setop_align_tzs(other, 'union')
+            dtype = self._find_common_type_compat(other)
+            left = self.astype(dtype, copy=False)
+            right = other.astype(dtype, copy=False)
+            return left.union(right, sort=sort)
+        elif not len(other) or self.equals(other):
+            result = self._get_reconciled_name_object(other)
+            if sort is True:
+                return result.sort_values()
+            return result
+        elif not len(self):
+            result = other._get_reconciled_name_object(self)
+            if sort is True:
+                return result.sort_values()
+            return result
+        result = self._union(other, sort=sort)
+        return self._wrap_setop_result(other, result)
+
+    def _union(self, other: Index, sort: bool | None):
+        lvals = self._values
+        rvals = other._values
+        if sort in (None, True) and (self.is_unique or other.is_unique) and self._can_use_libjoin and other._can_use_libjoin:
+            try:
+                return self._outer_indexer(other)[0]
+            except (TypeError, IncompatibleFrequency):
+                value_list = list(lvals)
+                value_set = set(lvals)
+                value_list.extend((x for x in rvals if x not in value_set))
+                return np.array(value_list, dtype=object)
+        elif not other.is_unique:
+            result_dups = algos.union_with_duplicates(self, other)
+            return _maybe_try_sort(result_dups, sort)
+        if self._index_as_unique:
+            indexer = self.get_indexer(other)
+            missing = (indexer == -1).nonzero()[0]
+        else:
+            missing = algos.unique1d(self.get_indexer_non_unique(other)[1])
+        result: Index | MultiIndex | ArrayLike
+        if self._is_multi:
+            result = self.append(other.take(missing))
+        elif len(missing) > 0:
+            other_diff = rvals.take(missing)
+            result = concat_compat((lvals, other_diff))
+        else:
+            result = lvals
+        if not self.is_monotonic_increasing or not other.is_monotonic_increasing:
+            result = _maybe_try_sort(result, sort)
+        return result
+
+    @final
+    def _wrap_setop_result(self, other: Index, result) -> Index:
+        name = get_op_result_name(self, other)
+        if isinstance(result, Index):
+            if result.name != name:
+                result = result.rename(name)
+        else:
+            result = self._shallow_copy(result, name=name)
+        return result
+
+    @final
+    def intersection(self, other, sort: bool=False):
+        self._validate_sort_keyword(sort)
+        self._assert_can_do_setop(other)
+        (other, result_name) = self._convert_can_do_setop(other)
+        if self.dtype != other.dtype:
+            (self, other) = self._dti_setop_align_tzs(other, 'intersection')
+        if self.equals(other):
+            if not self.is_unique:
+                result = self.unique()._get_reconciled_name_object(other)
+            else:
+                result = self._get_reconciled_name_object(other)
+            if sort is True:
+                result = result.sort_values()
+            return result
+        if len(self) == 0 or len(other) == 0:
+            if self._is_multi or other._is_multi:
+                return self[:0].rename(result_name)
+            dtype = self._find_common_type_compat(other)
+            if self.dtype == dtype:
+                if len(self) == 0:
+                    return self[:0].rename(result_name)
+                else:
+                    return other[:0].rename(result_name)
+            return Index([], dtype=dtype, name=result_name)
+        elif not self._should_compare(other):
+            if isinstance(self, ABCMultiIndex):
+                return self[:0].rename(result_name)
+            return Index([], name=result_name)
+        elif self.dtype != other.dtype:
+            dtype = self._find_common_type_compat(other)
+            this = self.astype(dtype, copy=False)
+            other = other.astype(dtype, copy=False)
+            return this.intersection(other, sort=sort)
+        result = self._intersection(other, sort=sort)
+        return self._wrap_intersection_result(other, result)
+
+    def _intersection(self, other: Index, sort: bool=False):
+        if self._can_use_libjoin and other._can_use_libjoin:
+            try:
+                (res_indexer, indexer, _) = self._inner_indexer(other)
+            except TypeError:
+                pass
+            else:
+                if is_numeric_dtype(self.dtype):
+                    res = algos.unique1d(res_indexer)
+                else:
+                    result = self.take(indexer)
+                    res = result.drop_duplicates()
+                return ensure_wrapped_if_datetimelike(res)
+        res_values = self._intersection_via_get_indexer(other, sort=sort)
+        res_values = _maybe_try_sort(res_values, sort)
+        return res_values
+
+    def _wrap_intersection_result(self, other, result):
+        return self._wrap_setop_result(other, result)
+
+    @final
+    def _intersection_via_get_indexer(self, other: Index | MultiIndex, sort) -> ArrayLike | MultiIndex:
+        left_unique = self.unique()
+        right_unique = other.unique()
+        indexer = left_unique.get_indexer_for(right_unique)
+        mask = indexer != -1
+        taker = indexer.take(mask.nonzero()[0])
+        if sort is False:
+            taker = np.sort(taker)
+        result: MultiIndex | ExtensionArray | np.ndarray
+        if isinstance(left_unique, ABCMultiIndex):
+            result = left_unique.take(taker)
+        else:
+            result = left_unique.take(taker)._values
+        return result
+
+    @final
+    def difference(self, other, sort: bool | None=None):
+        self._validate_sort_keyword(sort)
+        self._assert_can_do_setop(other)
+        (other, result_name) = self._convert_can_do_setop(other)
+        if self.equals(other):
+            return self[:0].rename(result_name)
+        if len(other) == 0:
+            result = self.unique().rename(result_name)
+            if sort is True:
+                return result.sort_values()
+            return result
+        if not self._should_compare(other):
+            result = self.unique().rename(result_name)
+            if sort is True:
+                return result.sort_values()
+            return result
+        result = self._difference(other, sort=sort)
+        return self._wrap_difference_result(other, result)
+
+    def _difference(self, other, sort):
+        this = self
+        if isinstance(self, ABCCategoricalIndex) and self.hasnans and other.hasnans:
+            this = this.dropna()
+        other = other.unique()
+        the_diff = this[other.get_indexer_for(this) == -1]
+        the_diff = the_diff if this.is_unique else the_diff.unique()
+        the_diff = _maybe_try_sort(the_diff, sort)
+        return the_diff
+
+    def _wrap_difference_result(self, other, result):
+        return self._wrap_setop_result(other, result)
+
+    def symmetric_difference(self, other, result_name: abc.Hashable | None=None, sort: bool | None=None):
+        self._validate_sort_keyword(sort)
+        self._assert_can_do_setop(other)
+        (other, result_name_update) = self._convert_can_do_setop(other)
+        if result_name is None:
+            result_name = result_name_update
+        if self.dtype != other.dtype:
+            (self, other) = self._dti_setop_align_tzs(other, 'symmetric_difference')
+        if not self._should_compare(other):
+            return self.union(other, sort=sort).rename(result_name)
+        elif self.dtype != other.dtype:
+            dtype = self._find_common_type_compat(other)
+            this = self.astype(dtype, copy=False)
+            that = other.astype(dtype, copy=False)
+            return this.symmetric_difference(that, sort=sort).rename(result_name)
+        this = self.unique()
+        other = other.unique()
+        indexer = this.get_indexer_for(other)
+        common_indexer = indexer.take((indexer != -1).nonzero()[0])
+        left_indexer = np.setdiff1d(np.arange(this.size), common_indexer, assume_unique=True)
+        left_diff = this.take(left_indexer)
+        right_indexer = (indexer == -1).nonzero()[0]
+        right_diff = other.take(right_indexer)
+        res_values = left_diff.append(right_diff)
+        result = _maybe_try_sort(res_values, sort)
+        if not self._is_multi:
+            return Index(result, name=result_name, dtype=res_values.dtype)
+        else:
+            left_diff = cast('MultiIndex', left_diff)
+            if len(result) == 0:
+                return left_diff.remove_unused_levels().set_names(result_name)
+            return result.set_names(result_name)
+
+    @final
+    def _assert_can_do_setop(self, other) -> bool:
+        if not is_list_like(other):
+            raise TypeError('Input must be Index or array-like')
+        return True
+
+    def _convert_can_do_setop(self, other) -> tuple[Index, Hashable]:
+        if not isinstance(other, Index):
+            other = Index(other, name=self.name)
+            result_name = self.name
+        else:
+            result_name = get_op_result_name(self, other)
+        return (other, result_name)
+
+    def get_loc(self, key):
+        casted_key = self._maybe_cast_indexer(key)
+        try:
+            return self._engine.get_loc(casted_key)
+        except KeyError as err:
+            if isinstance(casted_key, slice) or (isinstance(casted_key, abc.Iterable) and any((isinstance(x, slice) for x in casted_key))):
+                raise InvalidIndexError(key) from err
+            raise KeyError(key) from err
+        except TypeError:
+            self._check_indexing_error(key)
+            raise
+
+    @final
+    def get_indexer(self, target, method: ReindexMethod | None=None, limit: int | None=None, tolerance=None) -> npt.NDArray[np.intp]:
+        method = clean_reindex_fill_method(method)
+        orig_target = target
+        target = self._maybe_cast_listlike_indexer(target)
+        self._check_indexing_method(method, limit, tolerance)
+        if not self._index_as_unique:
+            raise InvalidIndexError(self._requires_unique_msg)
+        if len(target) == 0:
+            return np.array([], dtype=np.intp)
+        if not self._should_compare(target) and (not self._should_partial_index(target)):
+            return self._get_indexer_non_comparable(target, method=method, unique=True)
+        if isinstance(self.dtype, CategoricalDtype):
+            assert self.dtype == target.dtype
+            indexer = self._engine.get_indexer(target.codes)
+            if self.hasnans and target.hasnans:
+                target_nans = isna(orig_target)
+                loc = self.get_loc(np.nan)
+                mask = target.isna()
+                indexer[target_nans] = loc
+                indexer[mask & ~target_nans] = -1
+            return indexer
+        if isinstance(target.dtype, CategoricalDtype):
+            categories_indexer = self.get_indexer(target.categories)
+            indexer = algos.take_nd(categories_indexer, target.codes, fill_value=-1)
+            if (not self._is_multi and self.hasnans) and target.hasnans:
+                loc = self.get_loc(np.nan)
+                mask = target.isna()
+                indexer[mask] = loc
+            return ensure_platform_int(indexer)
+        (pself, ptarget) = self._maybe_downcast_for_indexing(target)
+        if pself is not self or ptarget is not target:
+            return pself.get_indexer(ptarget, method=method, limit=limit, tolerance=tolerance)
+        if self.dtype == target.dtype and self.equals(target):
+            return np.arange(len(target), dtype=np.intp)
+        if self.dtype != target.dtype and (not self._should_partial_index(target)):
+            dtype = self._find_common_type_compat(target)
+            this = self.astype(dtype, copy=False)
+            target = target.astype(dtype, copy=False)
+            return this._get_indexer(target, method=method, limit=limit, tolerance=tolerance)
+        return self._get_indexer(target, method, limit, tolerance)
+
+    def _get_indexer(self, target: Index, method: str_t | None=None, limit: int | None=None, tolerance=None) -> npt.NDArray[np.intp]:
+        if tolerance is not None:
+            tolerance = self._convert_tolerance(tolerance, target)
+        if method in ['pad', 'backfill']:
+            indexer = self._get_fill_indexer(target, method, limit, tolerance)
+        elif method == 'nearest':
+            indexer = self._get_nearest_indexer(target, limit, tolerance)
+        else:
+            if target._is_multi and self._is_multi:
+                engine = self._engine
+                tgt_values = engine._extract_level_codes(target)
+            else:
+                tgt_values = target._get_engine_target()
+            indexer = self._engine.get_indexer(tgt_values)
+        return ensure_platform_int(indexer)
+
+    @final
+    def _should_partial_index(self, target: Index) -> bool:
+        if isinstance(self.dtype, IntervalDtype):
+            if isinstance(target.dtype, IntervalDtype):
+                return False
+            return self.left._should_compare(target)
+        return False
+
+    @final
+    def _check_indexing_method(self, method: str_t | None, limit: int | None=None, tolerance=None) -> None:
+        if method not in [None, 'bfill', 'backfill', 'pad', 'ffill', 'nearest']:
+            raise ValueError('Invalid fill method')
+        if self._is_multi:
+            if method == 'nearest':
+                raise NotImplementedError("method='nearest' not implemented yet for MultiIndex; see GitHub issue 9365")
+            if method in ('pad', 'backfill'):
+                if tolerance is not None:
+                    raise NotImplementedError('tolerance not implemented yet for MultiIndex')
+        if isinstance(self.dtype, (IntervalDtype, CategoricalDtype)):
+            if method is not None:
+                raise NotImplementedError(f'method {method} not yet implemented for {type(self).__name__}')
+        if method is None:
+            if tolerance is not None:
+                raise ValueError('tolerance argument only valid if doing pad, backfill or nearest reindexing')
+            if limit is not None:
+                raise ValueError('limit argument only valid if doing pad, backfill or nearest reindexing')
+
+    def _convert_tolerance(self, tolerance, target: np.ndarray | Index) -> np.ndarray:
+        tolerance = np.asarray(tolerance)
+        if target.size != tolerance.size and tolerance.size > 1:
+            raise ValueError('list-like tolerance size must match target index size')
+        elif is_numeric_dtype(self) and (not np.issubdtype(tolerance.dtype, np.number)):
+            if tolerance.ndim > 0:
+                raise ValueError(f'tolerance argument for {type(self).__name__} with dtype {self.dtype} must contain numeric elements if it is list type')
+            raise ValueError(f'tolerance argument for {type(self).__name__} with dtype {self.dtype} must be numeric if it is a scalar: {tolerance!r}')
+        return tolerance
+
+    @final
+    def _get_fill_indexer(self, target: Index, method: str_t, limit: int | None=None, tolerance=None) -> npt.NDArray[np.intp]:
+        if self._is_multi:
+            if not (self.is_monotonic_increasing or self.is_monotonic_decreasing):
+                raise ValueError('index must be monotonic increasing or decreasing')
+            encoded = self.append(target)._engine.values
+            self_encoded = Index(encoded[:len(self)])
+            target_encoded = Index(encoded[len(self):])
+            return self_encoded._get_fill_indexer(target_encoded, method, limit, tolerance)
+        if self.is_monotonic_increasing and target.is_monotonic_increasing:
+            target_values = target._get_engine_target()
+            own_values = self._get_engine_target()
+            if not isinstance(target_values, np.ndarray) or not isinstance(own_values, np.ndarray):
+                raise NotImplementedError
+            if method == 'pad':
+                indexer = libalgos.pad(own_values, target_values, limit=limit)
+            else:
+                indexer = libalgos.backfill(own_values, target_values, limit=limit)
+        else:
+            indexer = self._get_fill_indexer_searchsorted(target, method, limit)
+        if tolerance is not None and len(self):
+            indexer = self._filter_indexer_tolerance(target, indexer, tolerance)
+        return indexer
+
+    @final
+    def _get_fill_indexer_searchsorted(self, target: Index, method: str_t, limit: int | None=None) -> npt.NDArray[np.intp]:
+        if limit is not None:
+            raise ValueError(f'limit argument for {method!r} method only well-defined if index and target are monotonic')
+        side: Literal['left', 'right'] = 'left' if method == 'pad' else 'right'
+        indexer = self.get_indexer(target)
+        nonexact = indexer == -1
+        indexer[nonexact] = self._searchsorted_monotonic(target[nonexact], side)
+        if side == 'left':
+            indexer[nonexact] -= 1
+        else:
+            indexer[indexer == len(self)] = -1
+        return indexer
+
+    @final
+    def _get_nearest_indexer(self, target: Index, limit: int | None, tolerance) -> npt.NDArray[np.intp]:
+        if not len(self):
+            return self._get_fill_indexer(target, 'pad')
+        left_indexer = self.get_indexer(target, 'pad', limit=limit)
+        right_indexer = self.get_indexer(target, 'backfill', limit=limit)
+        left_distances = self._difference_compat(target, left_indexer)
+        right_distances = self._difference_compat(target, right_indexer)
+        op = operator.lt if self.is_monotonic_increasing else operator.le
+        indexer = np.where(op(left_distances, right_distances) | (right_indexer == -1), left_indexer, right_indexer)
+        if tolerance is not None:
+            indexer = self._filter_indexer_tolerance(target, indexer, tolerance)
+        return indexer
+
+    @final
+    def _filter_indexer_tolerance(self, target: Index, indexer: npt.NDArray[np.intp], tolerance) -> npt.NDArray[np.intp]:
+        distance = self._difference_compat(target, indexer)
+        return np.where(distance <= tolerance, indexer, -1)
+
+    @final
+    def _difference_compat(self, target: Index, indexer: npt.NDArray[np.intp]) -> ArrayLike:
+        if isinstance(self.dtype, PeriodDtype):
+            own_values = cast('PeriodArray', self._data)._ndarray
+            target_values = cast('PeriodArray', target._data)._ndarray
+            diff = own_values[indexer] - target_values
+        else:
+            diff = self._values[indexer] - target._values
+        return abs(diff)
+
+    @final
+    def _validate_positional_slice(self, key: slice) -> None:
+        self._validate_indexer('positional', key.start, 'iloc')
+        self._validate_indexer('positional', key.stop, 'iloc')
+        self._validate_indexer('positional', key.step, 'iloc')
+
+    def _convert_slice_indexer(self, key: slice, kind: Literal['loc', 'getitem']):
+        (start, stop, step) = (key.start, key.stop, key.step)
+        is_index_slice = is_valid_positional_slice(key)
+        if kind == 'getitem':
+            if is_index_slice:
+                return key
+            elif self.dtype.kind in 'iu':
+                self._validate_indexer('slice', key.start, 'getitem')
+                self._validate_indexer('slice', key.stop, 'getitem')
+                self._validate_indexer('slice', key.step, 'getitem')
+                return key
+        is_positional = is_index_slice and self._should_fallback_to_positional
+        if is_positional:
+            try:
+                if start is not None:
+                    self.get_loc(start)
+                if stop is not None:
+                    self.get_loc(stop)
+                is_positional = False
+            except KeyError:
+                pass
+        if com.is_null_slice(key):
+            indexer = key
+        elif is_positional:
+            if kind == 'loc':
+                raise TypeError('Slicing a positional slice with .loc is not allowed, Use .loc with labels or .iloc with positions instead.')
+            indexer = key
+        else:
+            indexer = self.slice_indexer(start, stop, step)
+        return indexer
+
+    @final
+    def _raise_invalid_indexer(self, form: Literal['slice', 'positional'], key, reraise: lib.NoDefault | None | Exception=lib.no_default) -> None:
+        msg = f'cannot do {form} indexing on {type(self).__name__} with these indexers [{key}] of type {type(key).__name__}'
+        if reraise is not lib.no_default:
+            raise TypeError(msg) from reraise
+        raise TypeError(msg)
+
+    @final
+    def _validate_can_reindex(self, indexer: np.ndarray) -> None:
+        if not self._index_as_unique and len(indexer):
+            raise ValueError('cannot reindex on an axis with duplicate labels')
+
+    def reindex(self, target, method: ReindexMethod | None=None, level=None, limit: int | None=None, tolerance: float | None=None) -> tuple[Index, npt.NDArray[np.intp] | None]:
+        preserve_names = not hasattr(target, 'name')
+        target = ensure_has_len(target)
+        if not isinstance(target, Index) and len(target) == 0:
+            if level is not None and self._is_multi:
+                idx = self.levels[level]
+            else:
+                idx = self
+            target = idx[:0]
+        else:
+            target = ensure_index(target)
+        if level is not None and (isinstance(self, ABCMultiIndex) or isinstance(target, ABCMultiIndex)):
+            if method is not None:
+                raise TypeError('Fill method not supported if level passed')
+            (target, indexer, _) = self._join_level(target, level, how='right', keep_order=not self._is_multi)
+        elif self.equals(target):
+            indexer = None
+        elif self._index_as_unique:
+            indexer = self.get_indexer(target, method=method, limit=limit, tolerance=tolerance)
+        elif self._is_multi:
+            raise ValueError('cannot handle a non-unique multi-index!')
+        elif not self.is_unique:
+            raise ValueError('cannot reindex on an axis with duplicate labels')
+        else:
+            (indexer, _) = self.get_indexer_non_unique(target)
+        target = self._wrap_reindex_result(target, indexer, preserve_names)
+        return (target, indexer)
+
+    def _wrap_reindex_result(self, target, indexer, preserve_names: bool):
+        target = self._maybe_preserve_names(target, preserve_names)
+        return target
+
+    def _maybe_preserve_names(self, target: IndexT, preserve_names: bool) -> IndexT:
+        if preserve_names and target.nlevels == 1 and (target.name != self.name):
+            target = target.copy(deep=False)
+            target.name = self.name
+        return target
+
+    @final
+    def _reindex_non_unique(self, target: Index) -> tuple[Index, npt.NDArray[np.intp], npt.NDArray[np.intp] | None]:
+        target = ensure_index(target)
+        if len(target) == 0:
+            return (self[:0], np.array([], dtype=np.intp), None)
+        (indexer, missing) = self.get_indexer_non_unique(target)
+        check = indexer != -1
+        new_labels: Index | np.ndarray = self.take(indexer[check])
+        new_indexer = None
+        if len(missing):
+            length = np.arange(len(indexer), dtype=np.intp)
+            missing = ensure_platform_int(missing)
+            missing_labels = target.take(missing)
+            missing_indexer = length[~check]
+            cur_labels = self.take(indexer[check]).values
+            cur_indexer = length[check]
+            new_labels = np.empty((len(indexer),), dtype=object)
+            new_labels[cur_indexer] = cur_labels
+            new_labels[missing_indexer] = missing_labels
+            if not len(self):
+                new_indexer = np.arange(0, dtype=np.intp)
+            elif target.is_unique:
+                new_indexer = np.arange(len(indexer), dtype=np.intp)
+                new_indexer[cur_indexer] = np.arange(len(cur_labels))
+                new_indexer[missing_indexer] = -1
+            else:
+                indexer[~check] = -1
+                new_indexer = np.arange(len(self.take(indexer)), dtype=np.intp)
+                new_indexer[~check] = -1
+        if not isinstance(self, ABCMultiIndex):
+            new_index = Index(new_labels, name=self.name)
+        else:
+            new_index = type(self).from_tuples(new_labels, names=self.names)
+        return (new_index, indexer, new_indexer)
+
+    @overload
+    def join(self, other: Index, *, how: JoinHow=..., level: Level=..., return_indexers: Literal[True], sort: bool=...) -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        ...
+
+    @overload
+    def join(self, other: Index, *, how: JoinHow=..., level: Level=..., return_indexers: Literal[False]=..., sort: bool=...) -> Index:
+        ...
+
+    @overload
+    def join(self, other: Index, *, how: JoinHow=..., level: Level=..., return_indexers: bool=..., sort: bool=...) -> Index | tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        ...
+
+    @final
+    @_maybe_return_indexers
+    def join(self, other: Index, *, how: JoinHow='left', level: Level | None=None, return_indexers: bool=False, sort: bool=False) -> Index | tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        other = ensure_index(other)
+        sort = sort or how == 'outer'
+        if isinstance(self, ABCDatetimeIndex) and isinstance(other, ABCDatetimeIndex):
+            if (self.tz is None) ^ (other.tz is None):
+                raise TypeError('Cannot join tz-naive with tz-aware DatetimeIndex')
+        if not self._is_multi and (not other._is_multi):
+            (pself, pother) = self._maybe_downcast_for_indexing(other)
+            if pself is not self or pother is not other:
+                return pself.join(pother, how=how, level=level, return_indexers=True, sort=sort)
+        if level is None and (self._is_multi or other._is_multi):
+            if self.names == other.names:
+                pass
+            else:
+                return self._join_multi(other, how=how)
+        if level is not None and (self._is_multi or other._is_multi):
+            return self._join_level(other, level, how=how)
+        if len(self) == 0 or len(other) == 0:
+            try:
+                return self._join_empty(other, how, sort)
+            except TypeError:
+                pass
+        if self.dtype != other.dtype:
+            dtype = self._find_common_type_compat(other)
+            this = self.astype(dtype, copy=False)
+            other = other.astype(dtype, copy=False)
+            return this.join(other, how=how, return_indexers=True)
+        elif isinstance(self, ABCCategoricalIndex) and isinstance(other, ABCCategoricalIndex) and (not self.ordered) and (not self.categories.equals(other.categories)):
+            other = Index(other._values.reorder_categories(self.categories))
+        _validate_join_method(how)
+        if self.is_monotonic_increasing and other.is_monotonic_increasing and self._can_use_libjoin and other._can_use_libjoin and (self.is_unique or other.is_unique):
+            try:
+                return self._join_monotonic(other, how=how)
+            except TypeError:
+                pass
+        elif not self.is_unique or not other.is_unique:
+            return self._join_non_unique(other, how=how, sort=sort)
+        return self._join_via_get_indexer(other, how, sort)
+
+    def _join_empty(self, other: Index, how: JoinHow, sort: bool) -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        assert len(self) == 0 or len(other) == 0
+        _validate_join_method(how)
+        lidx: np.ndarray | None
+        ridx: np.ndarray | None
+        if len(other):
+            how = cast(JoinHow, {'left': 'right', 'right': 'left'}.get(how, how))
+            (join_index, ridx, lidx) = other._join_empty(self, how, sort)
+        elif how in ['left', 'outer']:
+            if sort and (not self.is_monotonic_increasing):
+                lidx = self.argsort()
+                join_index = self.take(lidx)
+            else:
+                lidx = None
+                join_index = self._view()
+            ridx = np.broadcast_to(np.intp(-1), len(join_index))
+        else:
+            join_index = other._view()
+            lidx = np.array([], dtype=np.intp)
+            ridx = None
+        return (join_index, lidx, ridx)
+
+    @final
+    def _join_via_get_indexer(self, other: Index, how: JoinHow, sort: bool) -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        lindexer: npt.NDArray[np.intp] | None
+        rindexer: npt.NDArray[np.intp] | None
+        if how == 'left':
+            if sort:
+                (join_index, lindexer) = self.sort_values(return_indexer=True)
+                rindexer = other.get_indexer_for(join_index)
+                return (join_index, lindexer, rindexer)
+            else:
+                join_index = self
+        elif how == 'right':
+            if sort:
+                (join_index, rindexer) = other.sort_values(return_indexer=True)
+                lindexer = self.get_indexer_for(join_index)
+                return (join_index, lindexer, rindexer)
+            else:
+                join_index = other
+        elif how == 'inner':
+            join_index = self.intersection(other, sort=sort)
+        elif how == 'outer':
+            try:
+                join_index = self.union(other, sort=sort)
+            except TypeError:
+                join_index = self.union(other)
+                try:
+                    join_index = _maybe_try_sort(join_index, sort)
+                except TypeError:
+                    pass
+        names = other.names if how == 'right' else self.names
+        if join_index.names != names:
+            join_index = join_index.set_names(names)
+        if join_index is self:
+            lindexer = None
+        else:
+            lindexer = self.get_indexer_for(join_index)
+        if join_index is other:
+            rindexer = None
+        else:
+            rindexer = other.get_indexer_for(join_index)
+        return (join_index, lindexer, rindexer)
+
+    @final
+    def _join_multi(self, other: Index, how: JoinHow):
+        from pandas.core.indexes.multi import MultiIndex
+        from pandas.core.reshape.merge import restore_dropped_levels_multijoin
+        self_names_list = list(self.names)
+        other_names_list = list(other.names)
+        self_names_order = self_names_list.index
+        other_names_order = other_names_list.index
+        self_names = set(self_names_list)
+        other_names = set(other_names_list)
+        overlap = self_names & other_names
+        if not overlap:
+            raise ValueError('cannot join with no overlapping index names')
+        if isinstance(self, MultiIndex) and isinstance(other, MultiIndex):
+            ldrop_names = sorted(self_names - overlap, key=self_names_order)
+            rdrop_names = sorted(other_names - overlap, key=other_names_order)
+            if not len(ldrop_names + rdrop_names):
+                self_jnlevels = self
+                other_jnlevels = other.reorder_levels(self.names)
+            else:
+                self_jnlevels = self.droplevel(ldrop_names)
+                other_jnlevels = other.droplevel(rdrop_names)
+            (join_idx, lidx, ridx) = self_jnlevels.join(other_jnlevels, how=how, return_indexers=True)
+            dropped_names = ldrop_names + rdrop_names
+            (levels, codes, names) = restore_dropped_levels_multijoin(self, other, dropped_names, join_idx, lidx, ridx)
+            multi_join_idx = MultiIndex(levels=levels, codes=codes, names=names, verify_integrity=False)
+            multi_join_idx = multi_join_idx.remove_unused_levels()
+            if how == 'right':
+                level_order = other_names_list + ldrop_names
+            else:
+                level_order = self_names_list + rdrop_names
+            multi_join_idx = multi_join_idx.reorder_levels(level_order)
+            return (multi_join_idx, lidx, ridx)
+        jl = next(iter(overlap))
+        flip_order = False
+        if isinstance(self, MultiIndex):
+            (self, other) = (other, self)
+            flip_order = True
+            flip: dict[JoinHow, JoinHow] = {'right': 'left', 'left': 'right'}
+            how = flip.get(how, how)
+        level = other.names.index(jl)
+        result = self._join_level(other, level, how=how)
+        if flip_order:
+            return (result[0], result[2], result[1])
+        return result
+
+    @final
+    def _join_non_unique(self, other: Index, how: JoinHow='left', sort: bool=False) -> tuple[Index, npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+        from pandas.core.reshape.merge import get_join_indexers_non_unique
+        assert self.dtype == other.dtype
+        (left_idx, right_idx) = get_join_indexers_non_unique(self._values, other._values, how=how, sort=sort)
+        if how == 'right':
+            join_index = other.take(right_idx)
+        else:
+            join_index = self.take(left_idx)
+        if how == 'outer':
+            mask = left_idx == -1
+            if mask.any():
+                right = other.take(right_idx)
+                join_index = join_index.putmask(mask, right)
+        if isinstance(join_index, ABCMultiIndex) and how == 'outer':
+            join_index = join_index._sort_levels_monotonic()
+        return (join_index, left_idx, right_idx)
+
+    @final
+    def _join_level(self, other: Index, level, how: JoinHow='left', keep_order: bool=True) -> tuple[MultiIndex, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        from pandas.core.indexes.multi import MultiIndex
+
+        def _get_leaf_sorter(labels: list[np.ndarray]) -> npt.NDArray[np.intp]:
+            if labels[0].size == 0:
+                return np.empty(0, dtype=np.intp)
+            if len(labels) == 1:
+                return get_group_index_sorter(ensure_platform_int(labels[0]))
+            tic = labels[0][:-1] != labels[0][1:]
+            for lab in labels[1:-1]:
+                tic |= lab[:-1] != lab[1:]
+            starts = np.hstack(([True], tic, [True])).nonzero()[0]
+            lab = ensure_int64(labels[-1])
+            return lib.get_level_sorter(lab, ensure_platform_int(starts))
+        if isinstance(self, MultiIndex) and isinstance(other, MultiIndex):
+            raise TypeError('Join on level between two MultiIndex objects is ambiguous')
+        (left, right) = (self, other)
+        flip_order = not isinstance(self, MultiIndex)
+        if flip_order:
+            (left, right) = (right, left)
+            flip: dict[JoinHow, JoinHow] = {'right': 'left', 'left': 'right'}
+            how = flip.get(how, how)
+        assert isinstance(left, MultiIndex)
+        level = left._get_level_number(level)
+        old_level = left.levels[level]
+        if not right.is_unique:
+            raise NotImplementedError('Index._join_level on non-unique index is not implemented')
+        (new_level, left_lev_indexer, right_lev_indexer) = old_level.join(right, how=how, return_indexers=True)
+        if left_lev_indexer is None:
+            if keep_order or len(left) == 0:
+                left_indexer = None
+                join_index = left
+            else:
+                left_indexer = _get_leaf_sorter(left.codes[:level + 1])
+                join_index = left[left_indexer]
+        else:
+            left_lev_indexer = ensure_platform_int(left_lev_indexer)
+            rev_indexer = lib.get_reverse_indexer(left_lev_indexer, len(old_level))
+            old_codes = left.codes[level]
+            taker = old_codes[old_codes != -1]
+            new_lev_codes = rev_indexer.take(taker)
+            new_codes = list(left.codes)
+            new_codes[level] = new_lev_codes
+            new_levels = list(left.levels)
+            new_levels[level] = new_level
+            if keep_order:
+                left_indexer = np.arange(len(left), dtype=np.intp)
+                left_indexer = cast(np.ndarray, left_indexer)
+                mask = new_lev_codes != -1
+                if not mask.all():
+                    new_codes = [lab[mask] for lab in new_codes]
+                    left_indexer = left_indexer[mask]
+            elif level == 0:
+                max_new_lev = 0 if len(new_lev_codes) == 0 else new_lev_codes.max()
+                ngroups = 1 + max_new_lev
+                (left_indexer, counts) = libalgos.groupsort_indexer(new_lev_codes, ngroups)
+                left_indexer = left_indexer[counts[0]:]
+                new_codes = [lab[left_indexer] for lab in new_codes]
+            else:
+                mask = new_lev_codes != -1
+                mask_all = mask.all()
+                if not mask_all:
+                    new_codes = [lab[mask] for lab in new_codes]
+                left_indexer = _get_leaf_sorter(new_codes[:level + 1])
+                new_codes = [lab[left_indexer] for lab in new_codes]
+                if not mask_all:
+                    left_indexer = mask.nonzero()[0][left_indexer]
+            join_index = MultiIndex(levels=new_levels, codes=new_codes, names=left.names, verify_integrity=False)
+        if right_lev_indexer is not None:
+            right_indexer = right_lev_indexer.take(join_index.codes[level])
+        else:
+            right_indexer = join_index.codes[level]
+        if flip_order:
+            (left_indexer, right_indexer) = (right_indexer, left_indexer)
+        left_indexer = None if left_indexer is None else ensure_platform_int(left_indexer)
+        right_indexer = None if right_indexer is None else ensure_platform_int(right_indexer)
+        return (join_index, left_indexer, right_indexer)
+
+    def _join_monotonic(self, other: Index, how: JoinHow='left') -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        assert other.dtype == self.dtype
+        assert self._can_use_libjoin and other._can_use_libjoin
+        if self.equals(other):
+            ret_index = other if how == 'right' else self
+            return (ret_index, None, None)
+        ridx: npt.NDArray[np.intp] | None
+        lidx: npt.NDArray[np.intp] | None
+        if how == 'left':
+            if other.is_unique:
+                join_index = self
+                lidx = None
+                ridx = self._left_indexer_unique(other)
+            else:
+                (join_array, lidx, ridx) = self._left_indexer(other)
+                (join_index, lidx, ridx) = self._wrap_join_result(join_array, other, lidx, ridx, how)
+        elif how == 'right':
+            if self.is_unique:
+                join_index = other
+                lidx = other._left_indexer_unique(self)
+                ridx = None
+            else:
+                (join_array, ridx, lidx) = other._left_indexer(self)
+                (join_index, lidx, ridx) = self._wrap_join_result(join_array, other, lidx, ridx, how)
+        elif how == 'inner':
+            (join_array, lidx, ridx) = self._inner_indexer(other)
+            (join_index, lidx, ridx) = self._wrap_join_result(join_array, other, lidx, ridx, how)
+        elif how == 'outer':
+            (join_array, lidx, ridx) = self._outer_indexer(other)
+            (join_index, lidx, ridx) = self._wrap_join_result(join_array, other, lidx, ridx, how)
+        lidx = None if lidx is None else ensure_platform_int(lidx)
+        ridx = None if ridx is None else ensure_platform_int(ridx)
+        return (join_index, lidx, ridx)
+
+    def _wrap_join_result(self, joined: ArrayLike, other: Self, lidx: npt.NDArray[np.intp] | None, ridx: npt.NDArray[np.intp] | None, how: JoinHow) -> tuple[Self, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        assert other.dtype == self.dtype
+        if lidx is not None and lib.is_range_indexer(lidx, len(self)):
+            lidx = None
+        if ridx is not None and lib.is_range_indexer(ridx, len(other)):
+            ridx = None
+        if lidx is None:
+            join_index = self
+        elif ridx is None:
+            join_index = other
+        else:
+            join_index = self._constructor._with_infer(joined, dtype=self.dtype)
+        names = other.names if how == 'right' else self.names
+        if join_index.names != names:
+            join_index = join_index.set_names(names)
+        return (join_index, lidx, ridx)
+
+    @final
+    @cache_readonly
+    def _can_use_libjoin(self) -> bool:
+        if not self.is_monotonic_increasing:
+            return False
+        if type(self) is Index:
+            return isinstance(self.dtype, np.dtype) or isinstance(self._values, (ArrowExtensionArray, BaseMaskedArray)) or (isinstance(self.dtype, StringDtype) and self.dtype.storage == 'python')
+        return not isinstance(self, (ABCIntervalIndex, ABCMultiIndex))
+
+    @property
+    def values(self) -> ArrayLike:
+        data = self._data
+        if isinstance(data, np.ndarray):
+            data = data.view()
+            data.flags.writeable = False
+        return data
+
+    @cache_readonly
+    @doc(IndexOpsMixin.array)
+    def array(self) -> ExtensionArray:
+        array = self._data
+        if isinstance(array, np.ndarray):
+            from pandas.core.arrays.numpy_ import NumpyExtensionArray
+            array = NumpyExtensionArray(array)
+        return array
+
+    @property
+    def _values(self) -> ExtensionArray | np.ndarray:
+        return self._data
+
+    def _get_engine_target(self) -> ArrayLike:
+        vals = self._values
+        if isinstance(vals, StringArray):
+            return vals._ndarray
+        if isinstance(vals, ArrowExtensionArray) and self.dtype.kind in 'Mm':
+            import pyarrow as pa
+            pa_type = vals._pa_array.type
+            if pa.types.is_timestamp(pa_type):
+                vals = vals._to_datetimearray()
+                return vals._ndarray.view('i8')
+            elif pa.types.is_duration(pa_type):
+                vals = vals._to_timedeltaarray()
+                return vals._ndarray.view('i8')
+        if type(self) is Index and isinstance(self._values, ExtensionArray) and (not isinstance(self._values, BaseMaskedArray)) and (not (isinstance(self._values, ArrowExtensionArray) and is_numeric_dtype(self.dtype) and (self.dtype.kind != 'O'))):
+            return self._values.astype(object)
+        return vals
+
+    @final
+    def _get_join_target(self) -> np.ndarray:
+        if isinstance(self._values, BaseMaskedArray):
+            return self._values._data
+        elif isinstance(self._values, ArrowExtensionArray):
+            return self._values.to_numpy()
+        target = self._get_engine_target()
+        if not isinstance(target, np.ndarray):
+            raise ValueError('_can_use_libjoin should return False.')
+        return target
+
+    def _from_join_target(self, result: np.ndarray) -> ArrayLike:
+        if isinstance(self.values, BaseMaskedArray):
+            return type(self.values)(result, np.zeros(result.shape, dtype=np.bool_))
+        elif isinstance(self.values, (ArrowExtensionArray, StringArray)):
+            return type(self.values)._from_sequence(result, dtype=self.dtype)
+        return result
+
+    @doc(IndexOpsMixin._memory_usage)
+    def memory_usage(self, deep: bool=False) -> int:
+        result = self._memory_usage(deep=deep)
+        if '_engine' in self._cache:
+            result += self._engine.sizeof(deep=deep)
+        return result
+
+    @final
+    def where(self, cond, other=None) -> Index:
+        if isinstance(self, ABCMultiIndex):
+            raise NotImplementedError('.where is not supported for MultiIndex operations')
+        cond = np.asarray(cond, dtype=bool)
+        return self.putmask(~cond, other)
+
+    @final
+    @classmethod
+    def _raise_scalar_data_error(cls, data):
+        raise TypeError(f'{cls.__name__}(...) must be called with a collection of some kind, {(repr(data) if not isinstance(data, np.generic) else str(data))} was passed')
+
+    def _validate_fill_value(self, value):
+        dtype = self.dtype
+        if isinstance(dtype, np.dtype) and dtype.kind not in 'mM':
+            try:
+                return np_can_hold_element(dtype, value)
+            except LossySetitemError as err:
+                raise TypeError from err
+        elif not can_hold_element(self._values, value):
+            raise TypeError
+        return value
+
+    @cache_readonly
+    def _is_memory_usage_qualified(self) -> bool:
+        return is_object_dtype(self.dtype)
+
+    def __contains__(self, key: Any) -> bool:
+        hash(key)
+        try:
+            return key in self._engine
+        except (OverflowError, TypeError, ValueError):
+            return False
+    __hash__: ClassVar[None]
+
+    @final
+    def __setitem__(self, key, value) -> None:
+        raise TypeError('Index does not support mutable operations')
+
+    def __getitem__(self, key):
+        getitem = self._data.__getitem__
+        if is_integer(key) or is_float(key):
+            key = com.cast_scalar_indexer(key)
+            return getitem(key)
+        if isinstance(key, slice):
+            return self._getitem_slice(key)
+        if com.is_bool_indexer(key):
+            if isinstance(getattr(key, 'dtype', None), ExtensionDtype):
+                key = key.to_numpy(dtype=bool, na_value=False)
+            else:
+                key = np.asarray(key, dtype=bool)
+            if not isinstance(self.dtype, ExtensionDtype):
+                if len(key) == 0 and len(key) != len(self):
+                    raise ValueError('The length of the boolean indexer cannot be 0 when the Index has length greater than 0.')
+        result = getitem(key)
+        if result.ndim > 1:
+            disallow_ndim_indexing(result)
+        return self._constructor._simple_new(result, name=self._name)
+
+    def _getitem_slice(self, slobj: slice) -> Self:
+        res = self._data[slobj]
+        result = type(self)._simple_new(res, name=self._name, refs=self._references)
+        if '_engine' in self._cache:
+            reverse = slobj.step is not None and slobj.step < 0
+            result._engine._update_from_sliced(self._engine, reverse=reverse)
+        return result
+
+    @final
+    def _can_hold_identifiers_and_holds_name(self, name) -> bool:
+        if is_object_dtype(self.dtype) or is_string_dtype(self.dtype) or isinstance(self.dtype, CategoricalDtype):
+            return name in self
+        return False
+
+    def append(self, other: Index | Sequence[Index]) -> Index:
+        to_concat = [self]
+        if isinstance(other, (list, tuple)):
+            to_concat += list(other)
+        else:
+            to_concat.append(other)
+        for obj in to_concat:
+            if not isinstance(obj, Index):
+                raise TypeError('all inputs must be Index')
+        names = {obj.name for obj in to_concat}
+        name = None if len(names) > 1 else self.name
+        return self._concat(to_concat, name)
+
+    def _concat(self, to_concat: list[Index], name: Hashable) -> Index:
+        to_concat_vals = [x._values for x in to_concat]
+        result = concat_compat(to_concat_vals)
+        return Index._with_infer(result, name=name)
+
+    def putmask(self, mask, value) -> Index:
+        (mask, noop) = validate_putmask(self._values, mask)
+        if noop:
+            return self.copy()
+        if self.dtype != object and is_valid_na_for_dtype(value, self.dtype):
+            value = self._na_value
+        try:
+            converted = self._validate_fill_value(value)
+        except (LossySetitemError, ValueError, TypeError) as err:
+            if is_object_dtype(self.dtype):
+                raise err
+            dtype = self._find_common_type_compat(value)
+            return self.astype(dtype).putmask(mask, value)
+        values = self._values.copy()
+        if isinstance(values, np.ndarray):
+            converted = setitem_datetimelike_compat(values, mask.sum(), converted)
+            np.putmask(values, mask, converted)
+        else:
+            values._putmask(mask, value)
+        return self._shallow_copy(values)
+
+    def equals(self, other: Any) -> bool:
+        if self.is_(other):
+            return True
+        if not isinstance(other, Index):
+            return False
+        if len(self) != len(other):
+            return False
+        if isinstance(self.dtype, StringDtype) and self.dtype.na_value is np.nan and (other.dtype != self.dtype):
+            return other.equals(self.astype(object))
+        if is_object_dtype(self.dtype) and (not is_object_dtype(other.dtype)):
+            return other.equals(self)
+        if isinstance(other, ABCMultiIndex):
+            return other.equals(self)
+        if isinstance(self._values, ExtensionArray):
+            if not isinstance(other, type(self)):
+                return False
+            earr = cast(ExtensionArray, self._data)
+            return earr.equals(other._data)
+        if isinstance(other.dtype, ExtensionDtype):
+            return other.equals(self)
+        return array_equivalent(self._values, other._values)
+
+    @final
+    def identical(self, other) -> bool:
+        return self.equals(other) and all((getattr(self, c, None) == getattr(other, c, None) for c in self._comparables)) and (type(self) == type(other)) and (self.dtype == other.dtype)
+
+    @final
+    def asof(self, label):
+        self._searchsorted_monotonic(label)
+        try:
+            loc = self.get_loc(label)
+        except (KeyError, TypeError) as err:
+            indexer = self.get_indexer([label], method='pad')
+            if indexer.ndim > 1 or indexer.size > 1:
+                raise TypeError('asof requires scalar valued input') from err
+            loc = indexer.item()
+            if loc == -1:
+                return self._na_value
+        else:
+            if isinstance(loc, slice):
+                loc = loc.indices(len(self))[-1]
+        return self[loc]
+
+    def asof_locs(self, where: Index, mask: npt.NDArray[np.bool_]) -> npt.NDArray[np.intp]:
+        locs = self._values[mask].searchsorted(where._values, side='right')
+        locs = np.where(locs > 0, locs - 1, 0)
+        result = np.arange(len(self), dtype=np.intp)[mask].take(locs)
+        first_value = self._values[mask.argmax()]
+        result[(locs == 0) & (where._values < first_value)] = -1
+        return result
+
+    @overload
+    def sort_values(self, *, return_indexer: Literal[False]=..., ascending: bool=..., na_position: NaPosition=..., key: Callable | None=...) -> Self:
+        ...
+
+    @overload
+    def sort_values(self, *, return_indexer: Literal[True], ascending: bool=..., na_position: NaPosition=..., key: Callable | None=...) -> tuple[Self, np.ndarray]:
+        ...
+
+    @overload
+    def sort_values(self, *, return_indexer: bool=..., ascending: bool=..., na_position: NaPosition=..., key: Callable | None=...) -> Self | tuple[Self, np.ndarray]:
+        ...
+
+    def sort_values(self, *, return_indexer: bool=False, ascending: bool=True, na_position: NaPosition='last', key: Callable | None=None) -> Self | tuple[Self, np.ndarray]:
+        if key is None and (ascending and self.is_monotonic_increasing or (not ascending and self.is_monotonic_decreasing)):
+            if return_indexer:
+                indexer = np.arange(len(self), dtype=np.intp)
+                return (self.copy(), indexer)
+            else:
+                return self.copy()
+        if not isinstance(self, ABCMultiIndex):
+            _as = nargsort(items=self, ascending=ascending, na_position=na_position, key=key)
+        else:
+            idx = cast(Index, ensure_key_mapped(self, key))
+            _as = idx.argsort(na_position=na_position)
+            if not ascending:
+                _as = _as[::-1]
+        sorted_index = self.take(_as)
+        if return_indexer:
+            return (sorted_index, _as)
+        else:
+            return sorted_index
+
+    def shift(self, periods: int=1, freq=None) -> Self:
+        raise NotImplementedError(f'This method is only implemented for DatetimeIndex, PeriodIndex and TimedeltaIndex; Got type {type(self).__name__}')
+
+    def argsort(self, *args, **kwargs) -> npt.NDArray[np.intp]:
+        return self._data.argsort(*args, **kwargs)
+
+    def _check_indexing_error(self, key) -> None:
+        if not is_scalar(key):
+            raise InvalidIndexError(key)
+
+    @cache_readonly
+    def _should_fallback_to_positional(self) -> bool:
+        return self.inferred_type not in {'integer', 'mixed-integer', 'floating', 'complex'}
+    _index_shared_docs['get_indexer_non_unique'] = "\n        Compute indexer and mask for new index given the current index.\n\n        The indexer should be then used as an input to ndarray.take to align the\n        current data to the new index.\n\n        Parameters\n        ----------\n        target : %(target_klass)s\n            An iterable containing the values to be used for computing indexer.\n\n        Returns\n        -------\n        indexer : np.ndarray[np.intp]\n            Integers from 0 to n - 1 indicating that the index at these\n            positions matches the corresponding target values. Missing values\n            in the target are marked by -1.\n        missing : np.ndarray[np.intp]\n            An indexer into the target of the values not found.\n            These correspond to the -1 in the indexer array.\n\n        See Also\n        --------\n        Index.get_indexer : Computes indexer and mask for new index given\n            the current index.\n        Index.get_indexer_for : Returns an indexer even when non-unique.\n\n        Examples\n        --------\n        >>> index = pd.Index(['c', 'b', 'a', 'b', 'b'])\n        >>> index.get_indexer_non_unique(['b', 'b'])\n        (array([1, 3, 4, 1, 3, 4]), array([], dtype=int64))\n\n        In the example below there are no matched values.\n\n        >>> index = pd.Index(['c', 'b', 'a', 'b', 'b'])\n        >>> index.get_indexer_non_unique(['q', 'r', 't'])\n        (array([-1, -1, -1]), array([0, 1, 2]))\n\n        For this reason, the returned ``indexer`` contains only integers equal to -1.\n        It demonstrates that there's no match between the index and the ``target``\n        values at these positions. The mask [0, 1, 2] in the return value shows that\n        the first, second, and third elements are missing.\n\n        Notice that the return value is a tuple contains two items. In the example\n        below the first item is an array of locations in ``index``. The second\n        item is a mask shows that the first and third elements are missing.\n\n        >>> index = pd.Index(['c', 'b', 'a', 'b', 'b'])\n        >>> index.get_indexer_non_unique(['f', 'b', 's'])\n        (array([-1,  1,  3,  4, -1]), array([0, 2]))\n        "
+
+    @Appender(_index_shared_docs['get_indexer_non_unique'] % _index_doc_kwargs)
+    def get_indexer_non_unique(self, target) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+        target = ensure_index(target)
+        target = self._maybe_cast_listlike_indexer(target)
+        if not self._should_compare(target) and (not self._should_partial_index(target)):
+            return self._get_indexer_non_comparable(target, method=None, unique=False)
+        (pself, ptarget) = self._maybe_downcast_for_indexing(target)
+        if pself is not self or ptarget is not target:
+            return pself.get_indexer_non_unique(ptarget)
+        if self.dtype != target.dtype:
+            dtype = self._find_common_type_compat(target)
+            this = self.astype(dtype, copy=False)
+            that = target.astype(dtype, copy=False)
+            return this.get_indexer_non_unique(that)
+        if self._is_multi and target._is_multi:
+            engine = self._engine
+            tgt_values = engine._extract_level_codes(target)
+        else:
+            tgt_values = target._get_engine_target()
+        (indexer, missing) = self._engine.get_indexer_non_unique(tgt_values)
+        return (ensure_platform_int(indexer), ensure_platform_int(missing))
+
+    @final
+    def get_indexer_for(self, target) -> npt.NDArray[np.intp]:
+        if self._index_as_unique:
+            return self.get_indexer(target)
+        (indexer, _) = self.get_indexer_non_unique(target)
+        return indexer
+
+    def _get_indexer_strict(self, key, axis_name: str_t) -> tuple[Index, np.ndarray]:
+        keyarr = key
+        if not isinstance(keyarr, Index):
+            keyarr = com.asarray_tuplesafe(keyarr)
+        if self._index_as_unique:
+            indexer = self.get_indexer_for(keyarr)
+            keyarr = self.reindex(keyarr)[0]
+        else:
+            (keyarr, indexer, new_indexer) = self._reindex_non_unique(keyarr)
+        self._raise_if_missing(keyarr, indexer, axis_name)
+        keyarr = self.take(indexer)
+        if isinstance(key, Index):
+            keyarr.name = key.name
+        if lib.is_np_dtype(keyarr.dtype, 'mM') or isinstance(keyarr.dtype, DatetimeTZDtype):
+            if isinstance(key, list) or (isinstance(key, type(self)) and key.freq is None):
+                keyarr = keyarr._with_freq(None)
+        return (keyarr, indexer)
+
+    def _raise_if_missing(self, key, indexer, axis_name: str_t) -> None:
+        if len(key) == 0:
+            return
+        missing_mask = indexer < 0
+        nmissing = missing_mask.sum()
+        if nmissing:
+            if nmissing == len(indexer):
+                raise KeyError(f'None of [{key}] are in the [{axis_name}]')
+            not_found = list(ensure_index(key)[missing_mask.nonzero()[0]].unique())
+            raise KeyError(f'{not_found} not in index')
+
+    @overload
+    def _get_indexer_non_comparable(self, target: Index, method, unique: Literal[True]=...) -> npt.NDArray[np.intp]:
+        ...
+
+    @overload
+    def _get_indexer_non_comparable(self, target: Index, method, unique: Literal[False]) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+        ...
+
+    @overload
+    def _get_indexer_non_comparable(self, target: Index, method, unique: bool=True) -> npt.NDArray[np.intp] | tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+        ...
+
+    @final
+    def _get_indexer_non_comparable(self, target: Index, method, unique: bool=True) -> npt.NDArray[np.intp] | tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+        if method is not None:
+            other_dtype = _unpack_nested_dtype(target)
+            raise TypeError(f'Cannot compare dtypes {self.dtype} and {other_dtype}')
+        no_matches = -1 * np.ones(target.shape, dtype=np.intp)
+        if unique:
+            return no_matches
+        else:
+            missing = np.arange(len(target), dtype=np.intp)
+            return (no_matches, missing)
+
+    @property
+    def _index_as_unique(self) -> bool:
+        return self.is_unique
+    _requires_unique_msg = 'Reindexing only valid with uniquely valued Index objects'
+
+    @final
+    def _maybe_downcast_for_indexing(self, other: Index) -> tuple[Index, Index]:
+        if isinstance(self, ABCDatetimeIndex) and isinstance(other, ABCDatetimeIndex):
+            if self.tz is not None and other.tz is not None and (not tz_compare(self.tz, other.tz)):
+                return (self.tz_convert('UTC'), other.tz_convert('UTC'))
+        elif self.inferred_type == 'date' and isinstance(other, ABCDatetimeIndex):
+            try:
+                return (type(other)(self), other)
+            except OutOfBoundsDatetime:
+                return (self, other)
+        elif self.inferred_type == 'timedelta' and isinstance(other, ABCTimedeltaIndex):
+            return (type(other)(self), other)
+        elif self.dtype.kind == 'u' and other.dtype.kind == 'i':
+            if other.min() >= 0:
+                return (self, other.astype(self.dtype))
+        elif self._is_multi and (not other._is_multi):
+            try:
+                other = type(self).from_tuples(other)
+            except (TypeError, ValueError):
+                self = Index(self._values)
+        if not is_object_dtype(self.dtype) and is_object_dtype(other.dtype):
+            (other, self) = other._maybe_downcast_for_indexing(self)
+        return (self, other)
+
+    @final
+    def _find_common_type_compat(self, target) -> DtypeObj:
+        (target_dtype, _) = infer_dtype_from(target)
+        if self.dtype == 'uint64' or target_dtype == 'uint64':
+            if is_signed_integer_dtype(self.dtype) or is_signed_integer_dtype(target_dtype):
+                return _dtype_obj
+        dtype = find_result_type(self.dtype, target)
+        dtype = common_dtype_categorical_compat([self, target], dtype)
+        return dtype
+
+    @final
+    def _should_compare(self, other: Index) -> bool:
+        if other.inferred_type == 'boolean' and is_any_real_numeric_dtype(self.dtype) or (self.inferred_type == 'boolean' and is_any_real_numeric_dtype(other.dtype)):
+            return False
+        dtype = _unpack_nested_dtype(other)
+        return self._is_comparable_dtype(dtype) or is_object_dtype(dtype)
+
+    def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
+        if self.dtype.kind == 'b':
+            return dtype.kind == 'b'
+        elif is_numeric_dtype(self.dtype):
+            return is_numeric_dtype(dtype)
+        return True
+
+    @final
+    def groupby(self, values) -> PrettyDict[Hashable, Index]:
+        if isinstance(values, ABCMultiIndex):
+            values = values._values
+        values = Categorical(values)
+        result = values._reverse_indexer()
+        result = {k: self.take(v) for (k, v) in result.items()}
+        return PrettyDict(result)
+
+    def map(self, mapper, na_action: Literal['ignore'] | None=None):
+        from pandas.core.indexes.multi import MultiIndex
+        new_values = self._map_values(mapper, na_action=na_action)
+        if new_values.size and isinstance(new_values[0], tuple):
+            if isinstance(self, MultiIndex):
+                names = self.names
+            elif self.name:
+                names = [self.name] * len(new_values[0])
+            else:
+                names = None
+            return MultiIndex.from_tuples(new_values, names=names)
+        dtype = None
+        if not new_values.size:
+            dtype = self.dtype
+        same_dtype = lib.infer_dtype(new_values, skipna=False) == self.inferred_type
+        if same_dtype:
+            new_values = maybe_cast_pointwise_result(new_values, self.dtype, same_dtype=same_dtype)
+        return Index._with_infer(new_values, dtype=dtype, copy=False, name=self.name)
+
+    @final
+    def _transform_index(self, func, *, level=None) -> Index:
+        if isinstance(self, ABCMultiIndex):
+            values = [self.get_level_values(i).map(func) if i == level or level is None else self.get_level_values(i) for i in range(self.nlevels)]
+            return type(self).from_arrays(values)
+        else:
+            items = [func(x) for x in self]
+            return Index(items, name=self.name, tupleize_cols=False)
+
+    def isin(self, values, level: str_t | int | None=None) -> npt.NDArray[np.bool_]:
+        if level is not None:
+            self._validate_index_level(level)
+        return algos.isin(self._values, values)
+
+    def _get_string_slice(self, key: str_t):
+        raise NotImplementedError
+
+    def slice_indexer(self, start: Hashable | None=None, end: Hashable | None=None, step: int | None=None) -> slice:
+        (start_slice, end_slice) = self.slice_locs(start, end, step=step)
+        if not is_scalar(start_slice):
+            raise AssertionError('Start slice bound is non-scalar')
+        if not is_scalar(end_slice):
+            raise AssertionError('End slice bound is non-scalar')
+        return slice(start_slice, end_slice, step)
+
+    def _maybe_cast_indexer(self, key):
+        return key
+
+    def _maybe_cast_listlike_indexer(self, target) -> Index:
+        return ensure_index(target)
+
+    @final
+    def _validate_indexer(self, form: Literal['positional', 'slice'], key, kind: Literal['getitem', 'iloc']) -> None:
+        if not lib.is_int_or_none(key):
+            self._raise_invalid_indexer(form, key)
+
+    def _maybe_cast_slice_bound(self, label, side: str_t):
+        if is_numeric_dtype(self.dtype):
+            return self._maybe_cast_indexer(label)
+        if (is_float(label) or is_integer(label)) and label not in self:
+            self._raise_invalid_indexer('slice', label)
+        return label
+
+    def _searchsorted_monotonic(self, label, side: Literal['left', 'right']='left'):
+        if self.is_monotonic_increasing:
+            return self.searchsorted(label, side=side)
+        elif self.is_monotonic_decreasing:
+            pos = self[::-1].searchsorted(label, side='right' if side == 'left' else 'left')
+            return len(self) - pos
+        raise ValueError('index must be monotonic increasing or decreasing')
+
+    def get_slice_bound(self, label, side: Literal['left', 'right']) -> int:
+        if side not in ('left', 'right'):
+            raise ValueError(f"Invalid value for side kwarg, must be either 'left' or 'right': {side}")
+        original_label = label
+        label = self._maybe_cast_slice_bound(label, side)
+        try:
+            slc = self.get_loc(label)
+        except KeyError as err:
+            try:
+                return self._searchsorted_monotonic(label, side)
+            except ValueError:
+                raise err from None
+        if isinstance(slc, np.ndarray):
+            assert is_bool_dtype(slc.dtype)
+            slc = lib.maybe_booleans_to_slice(slc.view('u1'))
+            if isinstance(slc, np.ndarray):
+                raise KeyError(f'Cannot get {side} slice bound for non-unique label: {original_label!r}')
+        if isinstance(slc, slice):
+            if side == 'left':
+                return slc.start
+            else:
+                return slc.stop
+        elif side == 'right':
+            return slc + 1
+        else:
+            return slc
+
+    def slice_locs(self, start: SliceType=None, end: SliceType=None, step: int | None=None) -> tuple[int, int]:
+        inc = step is None or step >= 0
+        if not inc:
+            (start, end) = (end, start)
+        if isinstance(start, (str, datetime)) and isinstance(end, (str, datetime)):
+            try:
+                ts_start = Timestamp(start)
+                ts_end = Timestamp(end)
+            except (ValueError, TypeError):
+                pass
+            else:
+                if not tz_compare(ts_start.tzinfo, ts_end.tzinfo):
+                    raise ValueError('Both dates must have the same UTC offset')
+        start_slice = None
+        if start is not None:
+            start_slice = self.get_slice_bound(start, 'left')
+        if start_slice is None:
+            start_slice = 0
+        end_slice = None
+        if end is not None:
+            end_slice = self.get_slice_bound(end, 'right')
+        if end_slice is None:
+            end_slice = len(self)
+        if not inc:
+            (end_slice, start_slice) = (start_slice - 1, end_slice - 1)
+            if end_slice == -1:
+                end_slice -= len(self)
+            if start_slice == -1:
+                start_slice -= len(self)
+        return (start_slice, end_slice)
+
+    def delete(self, loc: int | np.integer | list[int] | npt.NDArray[np.integer]) -> Self:
+        values = self._values
+        res_values: ArrayLike
+        if isinstance(values, np.ndarray):
+            res_values = np.delete(values, loc)
+        else:
+            res_values = values.delete(loc)
+        return self._constructor._simple_new(res_values, name=self.name)
+
+    def insert(self, loc: int, item) -> Index:
+        item = lib.item_from_zerodim(item)
+        if is_valid_na_for_dtype(item, self.dtype) and self.dtype != object:
+            item = self._na_value
+        arr = self._values
+        try:
+            if isinstance(arr, ExtensionArray):
+                res_values = arr.insert(loc, item)
+                return type(self)._simple_new(res_values, name=self.name)
+            else:
+                item = self._validate_fill_value(item)
+        except (TypeError, ValueError, LossySetitemError):
+            dtype = self._find_common_type_compat(item)
+            if dtype == self.dtype:
+                raise
+            return self.astype(dtype).insert(loc, item)
+        if arr.dtype != object or not isinstance(item, (tuple, np.datetime64, np.timedelta64)):
+            casted = arr.dtype.type(item)
+            new_values = np.insert(arr, loc, casted)
+        else:
+            new_values = np.insert(arr, loc, None)
+            loc = loc if loc >= 0 else loc - 1
+            new_values[loc] = item
+        out = Index(new_values, dtype=new_values.dtype, name=self.name)
+        return out
+
+    def drop(self, labels: Index | np.ndarray | Iterable[Hashable], errors: IgnoreRaise='raise') -> Index:
+        if not isinstance(labels, Index):
+            arr_dtype = 'object' if self.dtype == 'object' else None
+            labels = com.index_labels_to_array(labels, dtype=arr_dtype)
+        indexer = self.get_indexer_for(labels)
+        mask = indexer == -1
+        if mask.any():
+            if errors != 'ignore':
+                raise KeyError(f'{labels[mask].tolist()} not found in axis')
+            indexer = indexer[~mask]
+        return self.delete(indexer)
+
+    @final
+    def infer_objects(self, copy: bool=True) -> Index:
+        if self._is_multi:
+            raise NotImplementedError('infer_objects is not implemented for MultiIndex. Use index.to_frame().infer_objects() instead.')
+        if self.dtype != object:
+            return self.copy() if copy else self
+        values = self._values
+        values = cast('npt.NDArray[np.object_]', values)
+        res_values = lib.maybe_convert_objects(values, convert_non_numeric=True)
+        if copy and res_values is values:
+            return self.copy()
+        result = Index(res_values, name=self.name)
+        if not copy and res_values is values and (self._references is not None):
+            result._references = self._references
+            result._references.add_index_reference(result)
+        return result
+
+    @final
+    def diff(self, periods: int=1) -> Index:
+        return Index(self.to_series().diff(periods))
+
+    def round(self, decimals: int=0) -> Self:
+        return self._constructor(self.to_series().round(decimals))
+
+    def _cmp_method(self, other, op):
+        if self.is_(other):
+            if op in {operator.eq, operator.le, operator.ge}:
+                arr = np.ones(len(self), dtype=bool)
+                if self._can_hold_na and (not isinstance(self, ABCMultiIndex)):
+                    arr[self.isna()] = False
+                return arr
+            elif op is operator.ne:
+                arr = np.zeros(len(self), dtype=bool)
+                if self._can_hold_na and (not isinstance(self, ABCMultiIndex)):
+                    arr[self.isna()] = True
+                return arr
+        if isinstance(other, (np.ndarray, Index, ABCSeries, ExtensionArray)) and len(self) != len(other):
+            raise ValueError('Lengths must match to compare')
+        if not isinstance(other, ABCMultiIndex):
+            other = extract_array(other, extract_numpy=True)
+        else:
+            other = np.asarray(other)
+        if is_object_dtype(self.dtype) and isinstance(other, ExtensionArray):
+            result = op(self._values, other)
+        elif isinstance(self._values, ExtensionArray):
+            result = op(self._values, other)
+        elif is_object_dtype(self.dtype) and (not isinstance(self, ABCMultiIndex)):
+            result = ops.comp_method_OBJECT_ARRAY(op, self._values, other)
+        else:
+            result = ops.comparison_op(self._values, other, op)
+        return result
+
+    @final
+    def _logical_method(self, other, op):
+        res_name = ops.get_op_result_name(self, other)
+        lvalues = self._values
+        rvalues = extract_array(other, extract_numpy=True, extract_range=True)
+        res_values = ops.logical_op(lvalues, rvalues, op)
+        return self._construct_result(res_values, name=res_name)
+
+    @final
+    def _construct_result(self, result, name):
+        if isinstance(result, tuple):
+            return (Index(result[0], name=name, dtype=result[0].dtype), Index(result[1], name=name, dtype=result[1].dtype))
+        return Index(result, name=name, dtype=result.dtype)
+
+    def _arith_method(self, other, op):
+        if isinstance(other, Index) and is_object_dtype(other.dtype) and (type(other) is not Index):
+            return NotImplemented
+        return super()._arith_method(other, op)
+
+    @final
+    def _unary_method(self, op):
+        result = op(self._values)
+        return Index(result, name=self.name)
+
+    def __abs__(self) -> Index:
+        return self._unary_method(operator.abs)
+
+    def __neg__(self) -> Index:
+        return self._unary_method(operator.neg)
+
+    def __pos__(self) -> Index:
+        return self._unary_method(operator.pos)
+
+    def __invert__(self) -> Index:
+        return self._unary_method(operator.inv)
+
+    def any(self, *args, **kwargs):
+        nv.validate_any(args, kwargs)
+        self._maybe_disable_logical_methods('any')
+        vals = self._values
+        if not isinstance(vals, np.ndarray):
+            return vals._reduce('any')
+        return np.any(vals)
+
+    def all(self, *args, **kwargs):
+        nv.validate_all(args, kwargs)
+        self._maybe_disable_logical_methods('all')
+        vals = self._values
+        if not isinstance(vals, np.ndarray):
+            return vals._reduce('all')
+        return np.all(vals)
+
+    @final
+    def _maybe_disable_logical_methods(self, opname: str_t) -> None:
+        if isinstance(self, ABCMultiIndex):
+            raise TypeError(f'cannot perform {opname} with {type(self).__name__}')
+
+    @Appender(IndexOpsMixin.argmin.__doc__)
+    def argmin(self, axis: AxisInt | None=None, skipna: bool=True, *args, **kwargs) -> int:
+        nv.validate_argmin(args, kwargs)
+        nv.validate_minmax_axis(axis)
+        if not self._is_multi and self.hasnans:
+            if not skipna:
+                raise ValueError('Encountered an NA value with skipna=False')
+            elif self._isnan.all():
+                raise ValueError('Encountered all NA values')
+        return super().argmin(skipna=skipna)
+
+    @Appender(IndexOpsMixin.argmax.__doc__)
+    def argmax(self, axis: AxisInt | None=None, skipna: bool=True, *args, **kwargs) -> int:
+        nv.validate_argmax(args, kwargs)
+        nv.validate_minmax_axis(axis)
+        if not self._is_multi and self.hasnans:
+            if not skipna:
+                raise ValueError('Encountered an NA value with skipna=False')
+            elif self._isnan.all():
+                raise ValueError('Encountered all NA values')
+        return super().argmax(skipna=skipna)
+
+    def min(self, axis: AxisInt | None=None, skipna: bool=True, *args, **kwargs):
+        nv.validate_min(args, kwargs)
+        nv.validate_minmax_axis(axis)
+        if not len(self):
+            return self._na_value
+        if len(self) and self.is_monotonic_increasing:
+            first = self[0]
+            if not isna(first):
+                return first
+        if not self._is_multi and self.hasnans:
+            mask = self._isnan
+            if not skipna or mask.all():
+                return self._na_value
+        if not self._is_multi and (not isinstance(self._values, np.ndarray)):
+            return self._values._reduce(name='min', skipna=skipna)
+        return nanops.nanmin(self._values, skipna=skipna)
+
+    def max(self, axis: AxisInt | None=None, skipna: bool=True, *args, **kwargs):
+        nv.validate_max(args, kwargs)
+        nv.validate_minmax_axis(axis)
+        if not len(self):
+            return self._na_value
+        if len(self) and self.is_monotonic_increasing:
+            last = self[-1]
+            if not isna(last):
+                return last
+        if not self._is_multi and self.hasnans:
+            mask = self._isnan
+            if not skipna or mask.all():
+                return self._na_value
+        if not self._is_multi and (not isinstance(self._values, np.ndarray)):
+            return self._values._reduce(name='max', skipna=skipna)
+        return nanops.nanmax(self._values, skipna=skipna)
+
+    @final
+    @property
+    def shape(self) -> Shape:
+        return (len(self),)
+
+def maybe_sequence_to_range(sequence) -> Any | range:
+    if isinstance(sequence, (range, ExtensionArray)):
+        return sequence
+    elif len(sequence) == 1 or lib.infer_dtype(sequence, skipna=False) != 'integer':
+        return sequence
+    elif isinstance(sequence, (ABCSeries, Index)) and (not (isinstance(sequence.dtype, np.dtype) and sequence.dtype.kind == 'i')):
+        return sequence
+    if len(sequence) == 0:
+        return range(0)
+    try:
+        np_sequence = np.asarray(sequence, dtype=np.int64)
+    except OverflowError:
+        return sequence
+    diff = np_sequence[1] - np_sequence[0]
+    if diff == 0:
+        return sequence
+    elif len(sequence) == 2 or lib.is_sequence_range(np_sequence, diff):
+        return range(np_sequence[0], np_sequence[-1] + diff, diff)
+    else:
+        return sequence
+
+def ensure_index_from_sequences(sequences, names=None) -> Index:
+    from pandas.core.indexes.api import default_index
+    from pandas.core.indexes.multi import MultiIndex
+    if len(sequences) == 0:
+        return default_index(0)
+    elif len(sequences) == 1:
+        if names is not None:
+            names = names[0]
+        return Index(maybe_sequence_to_range(sequences[0]), name=names)
+    else:
+        return MultiIndex.from_arrays(sequences, names=names)
+
+def ensure_index(index_like: Axes, copy: bool=False) -> Index:
+    if isinstance(index_like, Index):
+        if copy:
+            index_like = index_like.copy()
+        return index_like
+    if isinstance(index_like, ABCSeries):
+        name = index_like.name
+        return Index(index_like, name=name, copy=copy)
+    if is_iterator(index_like):
+        index_like = list(index_like)
+    if isinstance(index_like, list):
+        if type(index_like) is not list:
+            index_like = list(index_like)
+        if len(index_like) and lib.is_all_arraylike(index_like):
+            from pandas.core.indexes.multi import MultiIndex
+            return MultiIndex.from_arrays(index_like)
+        else:
+            return Index(index_like, copy=copy, tupleize_cols=False)
+    else:
+        return Index(index_like, copy=copy)
+
+def ensure_has_len(seq):
+    try:
+        len(seq)
+    except TypeError:
+        return list(seq)
+    else:
+        return seq
+
+def trim_front(strings: list[str]) -> list[str]:
+    if not strings:
+        return strings
+    while all(strings) and all((x[0] == ' ' for x in strings)):
+        strings = [x[1:] for x in strings]
+    return strings
+
+def _validate_join_method(method: str) -> None:
+    if method not in ['left', 'right', 'inner', 'outer']:
+        raise ValueError(f'do not recognize join method {method}')
+
+def maybe_extract_name(name, obj, cls) -> Hashable:
+    if name is None and isinstance(obj, (Index, ABCSeries)):
+        name = obj.name
+    if not is_hashable(name):
+        raise TypeError(f'{cls.__name__}.name must be a hashable type')
+    return name
+
+def get_unanimous_names(*indexes: Index) -> tuple[Hashable, ...]:
+    name_tups = (tuple(i.names) for i in indexes)
+    name_sets = ({*ns} for ns in zip_longest(*name_tups))
+    names = tuple((ns.pop() if len(ns) == 1 else None for ns in name_sets))
+    return names
+
+def _unpack_nested_dtype(other: Index) -> DtypeObj:
+    dtype = other.dtype
+    if isinstance(dtype, CategoricalDtype):
+        return dtype.categories.dtype
+    elif isinstance(dtype, ArrowDtype):
+        import pyarrow as pa
+        if pa.types.is_dictionary(dtype.pyarrow_dtype):
+            other = other[:0].astype(ArrowDtype(dtype.pyarrow_dtype.value_type))
+    return other.dtype
+
+def _maybe_try_sort(result: Index | ArrayLike, sort: bool | None):
+    if sort is not False:
+        try:
+            result = algos.safe_sort(result)
+        except TypeError as err:
+            if sort is True:
+                raise
+            warnings.warn(f'{err}, sort order is undefined for incomparable objects.', RuntimeWarning, stacklevel=find_stack_level())
+    return result
+
+def get_values_for_csv(values: ArrayLike, *, date_format, na_rep: str='nan', quoting=None, float_format=None, decimal: str='.') -> npt.NDArray[np.object_]:
+    if isinstance(values, Categorical) and values.categories.dtype.kind in 'Mm':
+        values = algos.take_nd(values.categories._values, ensure_platform_int(values._codes), fill_value=na_rep)
+    values = ensure_wrapped_if_datetimelike(values)
+    if isinstance(values, (DatetimeArray, TimedeltaArray)):
+        if values.ndim == 1:
+            result = values._format_native_types(na_rep=na_rep, date_format=date_format)
+            result = result.astype(object, copy=False)
+            return result
+        results_converted = []
+        for i in range(len(values)):
+            result = values[i, :]._format_native_types(na_rep=na_rep, date_format=date_format)
+            results_converted.append(result.astype(object, copy=False))
+        return np.vstack(results_converted)
+    elif isinstance(values.dtype, PeriodDtype):
+        values = cast('PeriodArray', values)
+        res = values._format_native_types(na_rep=na_rep, date_format=date_format)
+        return res
+    elif isinstance(values.dtype, IntervalDtype):
+        values = cast('IntervalArray', values)
+        mask = values.isna()
+        if not quoting:
+            result = np.asarray(values).astype(str)
+        else:
+            result = np.array(values, dtype=object, copy=True)
+        result[mask] = na_rep
+        return result
+    elif values.dtype.kind == 'f' and (not isinstance(values.dtype, SparseDtype)):
+        if float_format is None and decimal == '.':
+            mask = isna(values)
+            if not quoting:
+                values = values.astype(str)
+            else:
+                values = np.array(values, dtype='object')
+            values[mask] = na_rep
+            values = values.astype(object, copy=False)
+            return values
+        from pandas.io.formats.format import FloatArrayFormatter
+        formatter = FloatArrayFormatter(values, na_rep=na_rep, float_format=float_format, decimal=decimal, quoting=quoting, fixed_width=False)
+        res = formatter.get_result_as_array()
+        res = res.astype(object, copy=False)
+        return res
+    elif isinstance(values, ExtensionArray):
+        mask = isna(values)
+        new_values = np.asarray(values.astype(object))
+        new_values[mask] = na_rep
+        return new_values
+    else:
+        mask = isna(values)
+        itemsize = writers.word_len(na_rep)
+        if values.dtype != _dtype_obj and (not quoting) and itemsize:
+            values = values.astype(str)
+            if values.dtype.itemsize / np.dtype('U1').itemsize < itemsize:
+                values = values.astype(f'<U{itemsize}')
+        else:
+            values = np.array(values, dtype='object')
+        values[mask] = na_rep
+        values = values.astype(object, copy=False)
+        return values
+
+# File: pandas-main/pandas/core/indexes/category.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Literal, cast
+import numpy as np
+from pandas._libs import index as libindex
+from pandas.util._decorators import cache_readonly, doc
+from pandas.core.dtypes.common import is_scalar
+from pandas.core.dtypes.concat import concat_compat
+from pandas.core.dtypes.dtypes import CategoricalDtype
+from pandas.core.dtypes.missing import is_valid_na_for_dtype, isna
+from pandas.core.arrays.categorical import Categorical, contains
+from pandas.core.construction import extract_array
+from pandas.core.indexes.base import Index, maybe_extract_name
+from pandas.core.indexes.extension import NDArrayBackedExtensionIndex, inherit_names
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+    from pandas._typing import Dtype, DtypeObj, Self, npt
+
+@inherit_names(['argsort', 'tolist', 'codes', 'categories', 'ordered', '_reverse_indexer', 'searchsorted', 'min', 'max'], Categorical)
+@inherit_names(['rename_categories', 'reorder_categories', 'add_categories', 'remove_categories', 'remove_unused_categories', 'set_categories', 'as_ordered', 'as_unordered'], Categorical, wrap=True)
+class CategoricalIndex(NDArrayBackedExtensionIndex):
+    _typ = 'categoricalindex'
+    _data_cls = Categorical
+
+    @property
+    def _can_hold_strings(self):
+        return self.categories._can_hold_strings
+
+    @cache_readonly
+    def _should_fallback_to_positional(self) -> bool:
+        return self.categories._should_fallback_to_positional
+    codes: np.ndarray
+    categories: Index
+    ordered: bool | None
+    _data: Categorical
+    _values: Categorical
+
+    @property
+    def _engine_type(self) -> type[libindex.IndexEngine]:
+        return {np.int8: libindex.Int8Engine, np.int16: libindex.Int16Engine, np.int32: libindex.Int32Engine, np.int64: libindex.Int64Engine}[self.codes.dtype.type]
+
+    def __new__(cls, data=None, categories=None, ordered=None, dtype: Dtype | None=None, copy: bool=False, name: Hashable | None=None) -> Self:
+        name = maybe_extract_name(name, data, cls)
+        if is_scalar(data):
+            cls._raise_scalar_data_error(data)
+        data = Categorical(data, categories=categories, ordered=ordered, dtype=dtype, copy=copy)
+        return cls._simple_new(data, name=name)
+
+    def _is_dtype_compat(self, other: Index) -> Categorical:
+        if isinstance(other.dtype, CategoricalDtype):
+            cat = extract_array(other)
+            cat = cast(Categorical, cat)
+            if not cat._categories_match_up_to_permutation(self._values):
+                raise TypeError('categories must match existing categories when appending')
+        elif other._is_multi:
+            raise TypeError('MultiIndex is not dtype-compatible with CategoricalIndex')
+        else:
+            values = other
+            cat = Categorical(other, dtype=self.dtype)
+            other = CategoricalIndex(cat)
+            if not other.isin(values).all():
+                raise TypeError('cannot append a non-category item to a CategoricalIndex')
+            cat = other._values
+            if not ((cat == values) | isna(cat) & isna(values)).all():
+                raise TypeError('categories must match existing categories when appending')
+        return cat
+
+    def equals(self, other: object) -> bool:
+        if self.is_(other):
+            return True
+        if not isinstance(other, Index):
+            return False
+        try:
+            other = self._is_dtype_compat(other)
+        except (TypeError, ValueError):
+            return False
+        return self._data.equals(other)
+
+    @property
+    def _formatter_func(self):
+        return self.categories._formatter_func
+
+    def _format_attrs(self):
+        attrs: list[tuple[str, str | int | bool | None]]
+        attrs = [('categories', f"[{', '.join(self._data._repr_categories())}]"), ('ordered', self.ordered)]
+        extra = super()._format_attrs()
+        return attrs + extra
+
+    @property
+    def inferred_type(self) -> str:
+        return 'categorical'
+
+    @doc(Index.__contains__)
+    def __contains__(self, key: Any) -> bool:
+        if is_valid_na_for_dtype(key, self.categories.dtype):
+            return self.hasnans
+        if self.categories._typ == 'rangeindex':
+            container: Index | libindex.IndexEngine | libindex.ExtensionEngine = self.categories
+        else:
+            container = self._engine
+        return contains(self, key, container=container)
+
+    def reindex(self, target, method=None, level=None, limit: int | None=None, tolerance=None) -> tuple[Index, npt.NDArray[np.intp] | None]:
+        if method is not None:
+            raise NotImplementedError('argument method is not implemented for CategoricalIndex.reindex')
+        if level is not None:
+            raise NotImplementedError('argument level is not implemented for CategoricalIndex.reindex')
+        if limit is not None:
+            raise NotImplementedError('argument limit is not implemented for CategoricalIndex.reindex')
+        return super().reindex(target)
+
+    def _maybe_cast_indexer(self, key) -> int:
+        try:
+            return self._data._unbox_scalar(key)
+        except KeyError:
+            if is_valid_na_for_dtype(key, self.categories.dtype):
+                return -1
+            raise
+
+    def _maybe_cast_listlike_indexer(self, values) -> CategoricalIndex:
+        if isinstance(values, CategoricalIndex):
+            values = values._data
+        if isinstance(values, Categorical):
+            cat = self._data._encode_with_my_categories(values)
+            codes = cat._codes
+        else:
+            codes = self.categories.get_indexer(values)
+            codes = codes.astype(self.codes.dtype, copy=False)
+            cat = self._data._from_backing_data(codes)
+        return type(self)._simple_new(cat)
+
+    def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
+        return self.categories._is_comparable_dtype(dtype)
+
+    def map(self, mapper, na_action: Literal['ignore'] | None=None):
+        mapped = self._values.map(mapper, na_action=na_action)
+        return Index(mapped, name=self.name)
+
+    def _concat(self, to_concat: list[Index], name: Hashable) -> Index:
+        try:
+            cat = Categorical._concat_same_type([self._is_dtype_compat(c) for c in to_concat])
+        except TypeError:
+            res = concat_compat([x._values for x in to_concat])
+            return Index(res, name=name)
+        else:
+            return type(self)._simple_new(cat, name=name)
+
+# File: pandas-main/pandas/core/indexes/datetimelike.py
+""""""
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, cast, final
+import numpy as np
+from pandas._libs import NaT, Timedelta, lib
+from pandas._libs.tslibs import BaseOffset, Resolution, Tick, parsing, to_offset
+from pandas.compat.numpy import function as nv
+from pandas.errors import InvalidIndexError, NullFrequencyError
+from pandas.util._decorators import Appender, cache_readonly, doc
+from pandas.core.dtypes.common import is_integer, is_list_like
+from pandas.core.dtypes.concat import concat_compat
+from pandas.core.dtypes.dtypes import CategoricalDtype, PeriodDtype
+from pandas.core.arrays import DatetimeArray, ExtensionArray, PeriodArray, TimedeltaArray
+from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
+import pandas.core.common as com
+import pandas.core.indexes.base as ibase
+from pandas.core.indexes.base import Index, _index_shared_docs
+from pandas.core.indexes.extension import NDArrayBackedExtensionIndex
+from pandas.core.indexes.range import RangeIndex
+from pandas.core.tools.timedeltas import to_timedelta
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from datetime import datetime
+    from pandas._typing import Axis, JoinHow, Self, npt
+    from pandas import CategoricalIndex
+_index_doc_kwargs = dict(ibase._index_doc_kwargs)
+
+class DatetimeIndexOpsMixin(NDArrayBackedExtensionIndex, ABC):
+    _can_hold_strings = False
+    _data: DatetimeArray | TimedeltaArray | PeriodArray
+
+    @doc(DatetimeLikeArrayMixin.mean)
+    def mean(self, *, skipna: bool=True, axis: int | None=0):
+        return self._data.mean(skipna=skipna, axis=axis)
+
+    @property
+    def freq(self) -> BaseOffset | None:
+        return self._data.freq
+
+    @freq.setter
+    def freq(self, value) -> None:
+        self._data.freq = value
+
+    @property
+    def asi8(self) -> npt.NDArray[np.int64]:
+        return self._data.asi8
+
+    @property
+    @doc(DatetimeLikeArrayMixin.freqstr)
+    def freqstr(self) -> str:
+        from pandas import PeriodIndex
+        if self._data.freqstr is not None and isinstance(self._data, (PeriodArray, PeriodIndex)):
+            freq = PeriodDtype(self._data.freq)._freqstr
+            return freq
+        else:
+            return self._data.freqstr
+
+    @cache_readonly
+    @abstractmethod
+    def _resolution_obj(self) -> Resolution:
+        ...
+
+    @cache_readonly
+    @doc(DatetimeLikeArrayMixin.resolution)
+    def resolution(self) -> str:
+        return self._data.resolution
+
+    @cache_readonly
+    def hasnans(self) -> bool:
+        return self._data._hasna
+
+    def equals(self, other: Any) -> bool:
+        if self.is_(other):
+            return True
+        if not isinstance(other, Index):
+            return False
+        elif other.dtype.kind in 'iufc':
+            return False
+        elif not isinstance(other, type(self)):
+            should_try = False
+            inferable = self._data._infer_matches
+            if other.dtype == object:
+                should_try = other.inferred_type in inferable
+            elif isinstance(other.dtype, CategoricalDtype):
+                other = cast('CategoricalIndex', other)
+                should_try = other.categories.inferred_type in inferable
+            if should_try:
+                try:
+                    other = type(self)(other)
+                except (ValueError, TypeError, OverflowError):
+                    return False
+        if self.dtype != other.dtype:
+            return False
+        return np.array_equal(self.asi8, other.asi8)
+
+    @Appender(Index.__contains__.__doc__)
+    def __contains__(self, key: Any) -> bool:
+        hash(key)
+        try:
+            self.get_loc(key)
+        except (KeyError, TypeError, ValueError, InvalidIndexError):
+            return False
+        return True
+
+    def _convert_tolerance(self, tolerance, target):
+        tolerance = np.asarray(to_timedelta(tolerance).to_numpy())
+        return super()._convert_tolerance(tolerance, target)
+    _default_na_rep = 'NaT'
+
+    def _format_with_header(self, *, header: list[str], na_rep: str, date_format: str | None=None) -> list[str]:
+        return header + list(self._get_values_for_csv(na_rep=na_rep, date_format=date_format))
+
+    @property
+    def _formatter_func(self):
+        return self._data._formatter()
+
+    def _format_attrs(self):
+        attrs = super()._format_attrs()
+        for attrib in self._attributes:
+            if attrib == 'freq':
+                freq = self.freqstr
+                if freq is not None:
+                    freq = repr(freq)
+                attrs.append(('freq', freq))
+        return attrs
+
+    @Appender(Index._summary.__doc__)
+    def _summary(self, name=None) -> str:
+        result = super()._summary(name=name)
+        if self.freq:
+            result += f'\nFreq: {self.freqstr}'
+        return result
+
+    @final
+    def _can_partial_date_slice(self, reso: Resolution) -> bool:
+        return reso > self._resolution_obj
+
+    def _parsed_string_to_bounds(self, reso: Resolution, parsed):
+        raise NotImplementedError
+
+    def _parse_with_reso(self, label: str) -> tuple[datetime, Resolution]:
+        try:
+            if self.freq is None or hasattr(self.freq, 'rule_code'):
+                freq = self.freq
+        except NotImplementedError:
+            freq = getattr(self, 'freqstr', getattr(self, 'inferred_freq', None))
+        freqstr: str | None
+        if freq is not None and (not isinstance(freq, str)):
+            freqstr = freq.rule_code
+        else:
+            freqstr = freq
+        if isinstance(label, np.str_):
+            label = str(label)
+        (parsed, reso_str) = parsing.parse_datetime_string_with_reso(label, freqstr)
+        reso = Resolution.from_attrname(reso_str)
+        return (parsed, reso)
+
+    def _get_string_slice(self, key: str) -> slice | npt.NDArray[np.intp]:
+        (parsed, reso) = self._parse_with_reso(key)
+        try:
+            return self._partial_date_slice(reso, parsed)
+        except KeyError as err:
+            raise KeyError(key) from err
+
+    @final
+    def _partial_date_slice(self, reso: Resolution, parsed: datetime) -> slice | npt.NDArray[np.intp]:
+        if not self._can_partial_date_slice(reso):
+            raise ValueError
+        (t1, t2) = self._parsed_string_to_bounds(reso, parsed)
+        vals = self._data._ndarray
+        unbox = self._data._unbox
+        if self.is_monotonic_increasing:
+            if len(self) and (t1 < self[0] and t2 < self[0] or (t1 > self[-1] and t2 > self[-1])):
+                raise KeyError
+            left = vals.searchsorted(unbox(t1), side='left')
+            right = vals.searchsorted(unbox(t2), side='right')
+            return slice(left, right)
+        else:
+            lhs_mask = vals >= unbox(t1)
+            rhs_mask = vals <= unbox(t2)
+            return (lhs_mask & rhs_mask).nonzero()[0]
+
+    def _maybe_cast_slice_bound(self, label, side: str):
+        if isinstance(label, str):
+            try:
+                (parsed, reso) = self._parse_with_reso(label)
+            except ValueError as err:
+                self._raise_invalid_indexer('slice', label, err)
+            (lower, upper) = self._parsed_string_to_bounds(reso, parsed)
+            return lower if side == 'left' else upper
+        elif not isinstance(label, self._data._recognized_scalars):
+            self._raise_invalid_indexer('slice', label)
+        return label
+
+    def shift(self, periods: int=1, freq=None) -> Self:
+        raise NotImplementedError
+
+    @doc(Index._maybe_cast_listlike_indexer)
+    def _maybe_cast_listlike_indexer(self, keyarr):
+        try:
+            res = self._data._validate_listlike(keyarr, allow_object=True)
+        except (ValueError, TypeError):
+            if not isinstance(keyarr, ExtensionArray):
+                res = com.asarray_tuplesafe(keyarr)
+            else:
+                res = keyarr
+        return Index(res, dtype=res.dtype)
+
+class DatetimeTimedeltaMixin(DatetimeIndexOpsMixin, ABC):
+    _data: DatetimeArray | TimedeltaArray
+    _comparables = ['name', 'freq']
+    _attributes = ['name', 'freq']
+    _is_monotonic_increasing = Index.is_monotonic_increasing
+    _is_monotonic_decreasing = Index.is_monotonic_decreasing
+    _is_unique = Index.is_unique
+
+    @property
+    def unit(self) -> str:
+        return self._data.unit
+
+    def as_unit(self, unit: str) -> Self:
+        arr = self._data.as_unit(unit)
+        return type(self)._simple_new(arr, name=self.name)
+
+    def _with_freq(self, freq):
+        arr = self._data._with_freq(freq)
+        return type(self)._simple_new(arr, name=self._name)
+
+    @property
+    def values(self) -> np.ndarray:
+        data = self._data._ndarray
+        data = data.view()
+        data.flags.writeable = False
+        return data
+
+    @doc(DatetimeIndexOpsMixin.shift)
+    def shift(self, periods: int=1, freq=None) -> Self:
+        if freq is not None and freq != self.freq:
+            if isinstance(freq, str):
+                freq = to_offset(freq)
+            offset = periods * freq
+            return self + offset
+        if periods == 0 or len(self) == 0:
+            return self.copy()
+        if self.freq is None:
+            raise NullFrequencyError('Cannot shift with no freq')
+        start = self[0] + periods * self.freq
+        end = self[-1] + periods * self.freq
+        result = self._data._generate_range(start=start, end=end, periods=None, freq=self.freq, unit=self.unit)
+        return type(self)._simple_new(result, name=self.name)
+
+    @cache_readonly
+    @doc(DatetimeLikeArrayMixin.inferred_freq)
+    def inferred_freq(self) -> str | None:
+        return self._data.inferred_freq
+
+    @cache_readonly
+    def _as_range_index(self) -> RangeIndex:
+        freq = cast(Tick, self.freq)
+        tick = Timedelta(freq).as_unit(self.unit)._value
+        rng = range(self[0]._value, self[-1]._value + tick, tick)
+        return RangeIndex(rng)
+
+    def _can_range_setop(self, other) -> bool:
+        return isinstance(self.freq, Tick) and isinstance(other.freq, Tick)
+
+    def _wrap_range_setop(self, other, res_i8) -> Self:
+        new_freq = None
+        if not len(res_i8):
+            new_freq = self.freq
+        elif isinstance(res_i8, RangeIndex):
+            new_freq = to_offset(Timedelta(res_i8.step, unit=self.unit).as_unit(self.unit))
+        res_values = res_i8.values.view(self._data._ndarray.dtype)
+        result = type(self._data)._simple_new(res_values, dtype=self.dtype, freq=new_freq)
+        return cast('Self', self._wrap_setop_result(other, result))
+
+    def _range_intersect(self, other, sort) -> Self:
+        left = self._as_range_index
+        right = other._as_range_index
+        res_i8 = left.intersection(right, sort=sort)
+        return self._wrap_range_setop(other, res_i8)
+
+    def _range_union(self, other, sort) -> Self:
+        left = self._as_range_index
+        right = other._as_range_index
+        res_i8 = left.union(right, sort=sort)
+        return self._wrap_range_setop(other, res_i8)
+
+    def _intersection(self, other: Index, sort: bool=False) -> Index:
+        other = cast('DatetimeTimedeltaMixin', other)
+        if self._can_range_setop(other):
+            return self._range_intersect(other, sort=sort)
+        if not self._can_fast_intersect(other):
+            result = Index._intersection(self, other, sort=sort)
+            result = self._wrap_setop_result(other, result)
+            return result._with_freq(None)._with_freq('infer')
+        else:
+            return self._fast_intersect(other, sort)
+
+    def _fast_intersect(self, other, sort):
+        if self[0] <= other[0]:
+            (left, right) = (self, other)
+        else:
+            (left, right) = (other, self)
+        end = min(left[-1], right[-1])
+        start = right[0]
+        if end < start:
+            result = self[:0]
+        else:
+            lslice = slice(*left.slice_locs(start, end))
+            result = left._values[lslice]
+        return result
+
+    def _can_fast_intersect(self, other: Self) -> bool:
+        if self.freq is None:
+            return False
+        elif other.freq != self.freq:
+            return False
+        elif not self.is_monotonic_increasing:
+            return False
+        return self.freq.n == 1
+
+    def _can_fast_union(self, other: Self) -> bool:
+        freq = self.freq
+        if freq is None or freq != other.freq:
+            return False
+        if not self.is_monotonic_increasing:
+            return False
+        if len(self) == 0 or len(other) == 0:
+            return True
+        if self[0] <= other[0]:
+            (left, right) = (self, other)
+        else:
+            (left, right) = (other, self)
+        right_start = right[0]
+        left_end = left[-1]
+        return right_start == left_end + freq or right_start in left
+
+    def _fast_union(self, other: Self, sort=None) -> Self:
+        if self[0] <= other[0]:
+            (left, right) = (self, other)
+        elif sort is False:
+            (left, right) = (self, other)
+            left_start = left[0]
+            loc = right.searchsorted(left_start, side='left')
+            right_chunk = right._values[:loc]
+            dates = concat_compat((left._values, right_chunk))
+            result = type(self)._simple_new(dates, name=self.name)
+            return result
+        else:
+            (left, right) = (other, self)
+        left_end = left[-1]
+        right_end = right[-1]
+        if left_end < right_end:
+            loc = right.searchsorted(left_end, side='right')
+            right_chunk = right._values[loc:]
+            dates = concat_compat([left._values, right_chunk])
+            assert isinstance(dates, type(self._data))
+            assert dates._freq == self.freq
+            result = type(self)._simple_new(dates)
+            return result
+        else:
+            return left
+
+    def _union(self, other, sort):
+        assert isinstance(other, type(self))
+        assert self.dtype == other.dtype
+        if self._can_range_setop(other):
+            return self._range_union(other, sort=sort)
+        if self._can_fast_union(other):
+            result = self._fast_union(other, sort=sort)
+            return result
+        else:
+            return super()._union(other, sort)._with_freq('infer')
+
+    def _get_join_freq(self, other):
+        freq = None
+        if self._can_fast_union(other):
+            freq = self.freq
+        return freq
+
+    def _wrap_join_result(self, joined, other, lidx: npt.NDArray[np.intp] | None, ridx: npt.NDArray[np.intp] | None, how: JoinHow) -> tuple[Self, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        assert other.dtype == self.dtype, (other.dtype, self.dtype)
+        (join_index, lidx, ridx) = super()._wrap_join_result(joined, other, lidx, ridx, how)
+        join_index._data._freq = self._get_join_freq(other)
+        return (join_index, lidx, ridx)
+
+    def _get_engine_target(self) -> np.ndarray:
+        return self._data._ndarray.view('i8')
+
+    def _from_join_target(self, result: np.ndarray):
+        result = result.view(self._data._ndarray.dtype)
+        return self._data._from_backing_data(result)
+
+    def _get_delete_freq(self, loc: int | slice | Sequence[int]):
+        freq = None
+        if self.freq is not None:
+            if is_integer(loc):
+                if loc in (0, -len(self), -1, len(self) - 1):
+                    freq = self.freq
+            else:
+                if is_list_like(loc):
+                    loc = lib.maybe_indices_to_slice(np.asarray(loc, dtype=np.intp), len(self))
+                if isinstance(loc, slice) and loc.step in (1, None):
+                    if loc.start in (0, None) or loc.stop in (len(self), None):
+                        freq = self.freq
+        return freq
+
+    def _get_insert_freq(self, loc: int, item):
+        value = self._data._validate_scalar(item)
+        item = self._data._box_func(value)
+        freq = None
+        if self.freq is not None:
+            if self.size:
+                if item is NaT:
+                    pass
+                elif loc in (0, -len(self)) and item + self.freq == self[0]:
+                    freq = self.freq
+                elif loc == len(self) and item - self.freq == self[-1]:
+                    freq = self.freq
+            elif isinstance(self.freq, Tick):
+                freq = self.freq
+            elif self.freq.is_on_offset(item):
+                freq = self.freq
+        return freq
+
+    @doc(NDArrayBackedExtensionIndex.delete)
+    def delete(self, loc) -> Self:
+        result = super().delete(loc)
+        result._data._freq = self._get_delete_freq(loc)
+        return result
+
+    @doc(NDArrayBackedExtensionIndex.insert)
+    def insert(self, loc: int, item):
+        result = super().insert(loc, item)
+        if isinstance(result, type(self)):
+            result._data._freq = self._get_insert_freq(loc, item)
+        return result
+
+    @Appender(_index_shared_docs['take'] % _index_doc_kwargs)
+    def take(self, indices, axis: Axis=0, allow_fill: bool=True, fill_value=None, **kwargs) -> Self:
+        nv.validate_take((), kwargs)
+        indices = np.asarray(indices, dtype=np.intp)
+        result = NDArrayBackedExtensionIndex.take(self, indices, axis, allow_fill, fill_value, **kwargs)
+        maybe_slice = lib.maybe_indices_to_slice(indices, len(self))
+        if isinstance(maybe_slice, slice):
+            freq = self._data._get_getitem_freq(maybe_slice)
+            result._data._freq = freq
+        return result
+
+# File: pandas-main/pandas/core/indexes/datetimes.py
+from __future__ import annotations
+import datetime as dt
+import operator
+from typing import TYPE_CHECKING
+import warnings
+import numpy as np
+from pandas._libs import NaT, Period, Timestamp, index as libindex, lib
+from pandas._libs.tslibs import Resolution, Tick, Timedelta, periods_per_day, timezones, to_offset
+from pandas._libs.tslibs.offsets import prefix_mapping
+from pandas.util._decorators import cache_readonly, doc
+from pandas.core.dtypes.common import is_scalar
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+from pandas.core.dtypes.generic import ABCSeries
+from pandas.core.dtypes.missing import is_valid_na_for_dtype
+from pandas.core.arrays.datetimes import DatetimeArray, tz_to_dtype
+import pandas.core.common as com
+from pandas.core.indexes.base import Index, maybe_extract_name
+from pandas.core.indexes.datetimelike import DatetimeTimedeltaMixin
+from pandas.core.indexes.extension import inherit_names
+from pandas.core.tools.times import to_time
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+    from pandas._typing import Dtype, DtypeObj, Frequency, IntervalClosedType, Self, TimeAmbiguous, TimeNonexistent, npt
+    from pandas.core.api import DataFrame, PeriodIndex
+from pandas._libs.tslibs.dtypes import OFFSET_TO_PERIOD_FREQSTR
+
+def _new_DatetimeIndex(cls, d):
+    if 'data' in d and (not isinstance(d['data'], DatetimeIndex)):
+        data = d.pop('data')
+        if not isinstance(data, DatetimeArray):
+            tz = d.pop('tz')
+            freq = d.pop('freq')
+            dta = DatetimeArray._simple_new(data, dtype=tz_to_dtype(tz), freq=freq)
+        else:
+            dta = data
+            for key in ['tz', 'freq']:
+                if key in d:
+                    assert d[key] == getattr(dta, key)
+                    d.pop(key)
+        result = cls._simple_new(dta, **d)
+    else:
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore')
+            result = cls.__new__(cls, **d)
+    return result
+
+@inherit_names(DatetimeArray._field_ops + [method for method in DatetimeArray._datetimelike_methods if method not in ('tz_localize', 'tz_convert', 'strftime')], DatetimeArray, wrap=True)
+@inherit_names(['is_normalized'], DatetimeArray, cache=True)
+@inherit_names(['tz', 'tzinfo', 'dtype', 'to_pydatetime', 'date', 'time', 'timetz', 'std'] + DatetimeArray._bool_ops, DatetimeArray)
+class DatetimeIndex(DatetimeTimedeltaMixin):
+    _typ = 'datetimeindex'
+    _data_cls = DatetimeArray
+    _supports_partial_string_indexing = True
+
+    @property
+    def _engine_type(self) -> type[libindex.DatetimeEngine]:
+        return libindex.DatetimeEngine
+    _data: DatetimeArray
+    _values: DatetimeArray
+    tz: dt.tzinfo | None
+
+    @doc(DatetimeArray.strftime)
+    def strftime(self, date_format) -> Index:
+        arr = self._data.strftime(date_format)
+        return Index(arr, name=self.name, dtype=arr.dtype)
+
+    @doc(DatetimeArray.tz_convert)
+    def tz_convert(self, tz) -> Self:
+        arr = self._data.tz_convert(tz)
+        return type(self)._simple_new(arr, name=self.name, refs=self._references)
+
+    @doc(DatetimeArray.tz_localize)
+    def tz_localize(self, tz, ambiguous: TimeAmbiguous='raise', nonexistent: TimeNonexistent='raise') -> Self:
+        arr = self._data.tz_localize(tz, ambiguous, nonexistent)
+        return type(self)._simple_new(arr, name=self.name)
+
+    @doc(DatetimeArray.to_period)
+    def to_period(self, freq=None) -> PeriodIndex:
+        from pandas.core.indexes.api import PeriodIndex
+        arr = self._data.to_period(freq)
+        return PeriodIndex._simple_new(arr, name=self.name)
+
+    @doc(DatetimeArray.to_julian_date)
+    def to_julian_date(self) -> Index:
+        arr = self._data.to_julian_date()
+        return Index._simple_new(arr, name=self.name)
+
+    @doc(DatetimeArray.isocalendar)
+    def isocalendar(self) -> DataFrame:
+        df = self._data.isocalendar()
+        return df.set_index(self)
+
+    @cache_readonly
+    def _resolution_obj(self) -> Resolution:
+        return self._data._resolution_obj
+
+    def __new__(cls, data=None, freq: Frequency | lib.NoDefault=lib.no_default, tz=lib.no_default, ambiguous: TimeAmbiguous='raise', dayfirst: bool=False, yearfirst: bool=False, dtype: Dtype | None=None, copy: bool=False, name: Hashable | None=None) -> Self:
+        if is_scalar(data):
+            cls._raise_scalar_data_error(data)
+        name = maybe_extract_name(name, data, cls)
+        if isinstance(data, DatetimeArray) and freq is lib.no_default and (tz is lib.no_default) and (dtype is None):
+            if copy:
+                data = data.copy()
+            return cls._simple_new(data, name=name)
+        dtarr = DatetimeArray._from_sequence_not_strict(data, dtype=dtype, copy=copy, tz=tz, freq=freq, dayfirst=dayfirst, yearfirst=yearfirst, ambiguous=ambiguous)
+        refs = None
+        if not copy and isinstance(data, (Index, ABCSeries)):
+            refs = data._references
+        subarr = cls._simple_new(dtarr, name=name, refs=refs)
+        return subarr
+
+    @cache_readonly
+    def _is_dates_only(self) -> bool:
+        if isinstance(self.freq, Tick):
+            delta = Timedelta(self.freq)
+            if delta % dt.timedelta(days=1) != dt.timedelta(days=0):
+                return False
+        return self._values._is_dates_only
+
+    def __reduce__(self):
+        d = {'data': self._data, 'name': self.name}
+        return (_new_DatetimeIndex, (type(self), d), None)
+
+    def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
+        if self.tz is not None:
+            return isinstance(dtype, DatetimeTZDtype)
+        return lib.is_np_dtype(dtype, 'M')
+
+    @cache_readonly
+    def _formatter_func(self):
+        from pandas.io.formats.format import get_format_datetime64
+        formatter = get_format_datetime64(is_dates_only=self._is_dates_only)
+        return lambda x: f"'{formatter(x)}'"
+
+    def _can_range_setop(self, other) -> bool:
+        if self.tz is not None and (not timezones.is_utc(self.tz)) and (not timezones.is_fixed_offset(self.tz)):
+            return False
+        if other.tz is not None and (not timezones.is_utc(other.tz)) and (not timezones.is_fixed_offset(other.tz)):
+            return False
+        return super()._can_range_setop(other)
+
+    def _get_time_micros(self) -> npt.NDArray[np.int64]:
+        values = self._data._local_timestamps()
+        ppd = periods_per_day(self._data._creso)
+        frac = values % ppd
+        if self.unit == 'ns':
+            micros = frac // 1000
+        elif self.unit == 'us':
+            micros = frac
+        elif self.unit == 'ms':
+            micros = frac * 1000
+        elif self.unit == 's':
+            micros = frac * 1000000
+        else:
+            raise NotImplementedError(self.unit)
+        micros[self._isnan] = -1
+        return micros
+
+    def snap(self, freq: Frequency='S') -> DatetimeIndex:
+        freq = to_offset(freq)
+        dta = self._data.copy()
+        for (i, v) in enumerate(self):
+            s = v
+            if not freq.is_on_offset(s):
+                t0 = freq.rollback(s)
+                t1 = freq.rollforward(s)
+                if abs(s - t0) < abs(t1 - s):
+                    s = t0
+                else:
+                    s = t1
+            dta[i] = s
+        return DatetimeIndex._simple_new(dta, name=self.name)
+
+    def _parsed_string_to_bounds(self, reso: Resolution, parsed: dt.datetime) -> tuple[Timestamp, Timestamp]:
+        freq = OFFSET_TO_PERIOD_FREQSTR.get(reso.attr_abbrev, reso.attr_abbrev)
+        per = Period(parsed, freq=freq)
+        (start, end) = (per.start_time, per.end_time)
+        start = start.as_unit(self.unit)
+        end = end.as_unit(self.unit)
+        start = start.tz_localize(parsed.tzinfo)
+        end = end.tz_localize(parsed.tzinfo)
+        if parsed.tzinfo is not None:
+            if self.tz is None:
+                raise ValueError('The index must be timezone aware when indexing with a date string with a UTC offset')
+        return (start, end)
+
+    def _parse_with_reso(self, label: str) -> tuple[Timestamp, Resolution]:
+        (parsed, reso) = super()._parse_with_reso(label)
+        parsed = Timestamp(parsed)
+        if self.tz is not None and parsed.tzinfo is None:
+            parsed = parsed.tz_localize(self.tz)
+        return (parsed, reso)
+
+    def _disallow_mismatched_indexing(self, key) -> None:
+        try:
+            self._data._assert_tzawareness_compat(key)
+        except TypeError as err:
+            raise KeyError(key) from err
+
+    def get_loc(self, key):
+        self._check_indexing_error(key)
+        orig_key = key
+        if is_valid_na_for_dtype(key, self.dtype):
+            key = NaT
+        if isinstance(key, self._data._recognized_scalars):
+            self._disallow_mismatched_indexing(key)
+            key = Timestamp(key)
+        elif isinstance(key, str):
+            try:
+                (parsed, reso) = self._parse_with_reso(key)
+            except ValueError as err:
+                raise KeyError(key) from err
+            self._disallow_mismatched_indexing(parsed)
+            if self._can_partial_date_slice(reso):
+                try:
+                    return self._partial_date_slice(reso, parsed)
+                except KeyError as err:
+                    raise KeyError(key) from err
+            key = parsed
+        elif isinstance(key, dt.timedelta):
+            raise TypeError(f'Cannot index {type(self).__name__} with {type(key).__name__}')
+        elif isinstance(key, dt.time):
+            return self.indexer_at_time(key)
+        else:
+            raise KeyError(key)
+        try:
+            return Index.get_loc(self, key)
+        except KeyError as err:
+            raise KeyError(orig_key) from err
+
+    @doc(DatetimeTimedeltaMixin._maybe_cast_slice_bound)
+    def _maybe_cast_slice_bound(self, label, side: str):
+        if isinstance(label, dt.date) and (not isinstance(label, dt.datetime)):
+            label = Timestamp(label).to_pydatetime()
+        label = super()._maybe_cast_slice_bound(label, side)
+        self._data._assert_tzawareness_compat(label)
+        return Timestamp(label)
+
+    def slice_indexer(self, start=None, end=None, step=None):
+        if isinstance(start, dt.time) and isinstance(end, dt.time):
+            if step is not None and step != 1:
+                raise ValueError('Must have step size of 1 with time slices')
+            return self.indexer_between_time(start, end)
+        if isinstance(start, dt.time) or isinstance(end, dt.time):
+            raise KeyError('Cannot mix time and non-time slice keys')
+
+        def check_str_or_none(point) -> bool:
+            return point is not None and (not isinstance(point, str))
+        if check_str_or_none(start) or check_str_or_none(end) or self.is_monotonic_increasing:
+            return Index.slice_indexer(self, start, end, step)
+        mask = np.array(True)
+        in_index = True
+        if start is not None:
+            start_casted = self._maybe_cast_slice_bound(start, 'left')
+            mask = start_casted <= self
+            in_index &= (start_casted == self).any()
+        if end is not None:
+            end_casted = self._maybe_cast_slice_bound(end, 'right')
+            mask = (self <= end_casted) & mask
+            in_index &= (end_casted == self).any()
+        if not in_index:
+            raise KeyError('Value based partial slicing on non-monotonic DatetimeIndexes with non-existing keys is not allowed.')
+        indexer = mask.nonzero()[0][::step]
+        if len(indexer) == len(self):
+            return slice(None)
+        else:
+            return indexer
+
+    @property
+    def inferred_type(self) -> str:
+        return 'datetime64'
+
+    def indexer_at_time(self, time, asof: bool=False) -> npt.NDArray[np.intp]:
+        if asof:
+            raise NotImplementedError("'asof' argument is not supported")
+        if isinstance(time, str):
+            from dateutil.parser import parse
+            time = parse(time).time()
+        if time.tzinfo:
+            if self.tz is None:
+                raise ValueError('Index must be timezone aware.')
+            time_micros = self.tz_convert(time.tzinfo)._get_time_micros()
+        else:
+            time_micros = self._get_time_micros()
+        micros = _time_to_micros(time)
+        return (time_micros == micros).nonzero()[0]
+
+    def indexer_between_time(self, start_time, end_time, include_start: bool=True, include_end: bool=True) -> npt.NDArray[np.intp]:
+        start_time = to_time(start_time)
+        end_time = to_time(end_time)
+        time_micros = self._get_time_micros()
+        start_micros = _time_to_micros(start_time)
+        end_micros = _time_to_micros(end_time)
+        if include_start and include_end:
+            lop = rop = operator.le
+        elif include_start:
+            lop = operator.le
+            rop = operator.lt
+        elif include_end:
+            lop = operator.lt
+            rop = operator.le
+        else:
+            lop = rop = operator.lt
+        if start_time <= end_time:
+            join_op = operator.and_
+        else:
+            join_op = operator.or_
+        mask = join_op(lop(start_micros, time_micros), rop(time_micros, end_micros))
+        return mask.nonzero()[0]
+
+def date_range(start=None, end=None, periods=None, freq=None, tz=None, normalize: bool=False, name: Hashable | None=None, inclusive: IntervalClosedType='both', *, unit: str | None=None, **kwargs) -> DatetimeIndex:
+    if freq is None and com.any_none(periods, start, end):
+        freq = 'D'
+    dtarr = DatetimeArray._generate_range(start=start, end=end, periods=periods, freq=freq, tz=tz, normalize=normalize, inclusive=inclusive, unit=unit, **kwargs)
+    return DatetimeIndex._simple_new(dtarr, name=name)
+
+def bdate_range(start=None, end=None, periods: int | None=None, freq: Frequency | dt.timedelta='B', tz=None, normalize: bool=True, name: Hashable | None=None, weekmask=None, holidays=None, inclusive: IntervalClosedType='both', **kwargs) -> DatetimeIndex:
+    if freq is None:
+        msg = 'freq must be specified for bdate_range; use date_range instead'
+        raise TypeError(msg)
+    if isinstance(freq, str) and freq.startswith('C'):
+        try:
+            weekmask = weekmask or 'Mon Tue Wed Thu Fri'
+            freq = prefix_mapping[freq](holidays=holidays, weekmask=weekmask)
+        except (KeyError, TypeError) as err:
+            msg = f'invalid custom frequency string: {freq}'
+            raise ValueError(msg) from err
+    elif holidays or weekmask:
+        msg = f'a custom frequency string is required when holidays or weekmask are passed, got frequency {freq}'
+        raise ValueError(msg)
+    return date_range(start=start, end=end, periods=periods, freq=freq, tz=tz, normalize=normalize, name=name, inclusive=inclusive, **kwargs)
+
+def _time_to_micros(time_obj: dt.time) -> int:
+    seconds = time_obj.hour * 60 * 60 + 60 * time_obj.minute + time_obj.second
+    return 1000000 * seconds + time_obj.microsecond
+
+# File: pandas-main/pandas/core/indexes/extension.py
+""""""
+from __future__ import annotations
+from inspect import signature
+from typing import TYPE_CHECKING, TypeVar
+from pandas.util._decorators import cache_readonly
+from pandas.core.dtypes.generic import ABCDataFrame
+from pandas.core.indexes.base import Index
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    import numpy as np
+    from pandas._typing import ArrayLike, npt
+    from pandas.core.arrays import IntervalArray
+    from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
+_ExtensionIndexT = TypeVar('_ExtensionIndexT', bound='ExtensionIndex')
+
+def _inherit_from_data(name: str, delegate: type, cache: bool=False, wrap: bool=False):
+    attr = getattr(delegate, name)
+    if isinstance(attr, property) or type(attr).__name__ == 'getset_descriptor':
+        if cache:
+
+            def cached(self):
+                return getattr(self._data, name)
+            cached.__name__ = name
+            cached.__doc__ = attr.__doc__
+            method = cache_readonly(cached)
+        else:
+
+            def fget(self):
+                result = getattr(self._data, name)
+                if wrap:
+                    if isinstance(result, type(self._data)):
+                        return type(self)._simple_new(result, name=self.name)
+                    elif isinstance(result, ABCDataFrame):
+                        return result.set_index(self)
+                    return Index(result, name=self.name, dtype=result.dtype)
+                return result
+
+            def fset(self, value) -> None:
+                setattr(self._data, name, value)
+            fget.__name__ = name
+            fget.__doc__ = attr.__doc__
+            method = property(fget, fset)
+    elif not callable(attr):
+        method = attr
+    else:
+
+        def method(self, *args, **kwargs):
+            if 'inplace' in kwargs:
+                raise ValueError(f'cannot use inplace with {type(self).__name__}')
+            result = attr(self._data, *args, **kwargs)
+            if wrap:
+                if isinstance(result, type(self._data)):
+                    return type(self)._simple_new(result, name=self.name)
+                elif isinstance(result, ABCDataFrame):
+                    return result.set_index(self)
+                return Index(result, name=self.name, dtype=result.dtype)
+            return result
+        method.__name__ = name
+        method.__doc__ = attr.__doc__
+        method.__signature__ = signature(attr)
+    return method
+
+def inherit_names(names: list[str], delegate: type, cache: bool=False, wrap: bool=False) -> Callable[[type[_ExtensionIndexT]], type[_ExtensionIndexT]]:
+
+    def wrapper(cls: type[_ExtensionIndexT]) -> type[_ExtensionIndexT]:
+        for name in names:
+            meth = _inherit_from_data(name, delegate, cache=cache, wrap=wrap)
+            setattr(cls, name, meth)
+        return cls
+    return wrapper
+
+class ExtensionIndex(Index):
+    _data: IntervalArray | NDArrayBackedExtensionArray
+
+    def _validate_fill_value(self, value):
+        return self._data._validate_setitem_value(value)
+
+    @cache_readonly
+    def _isnan(self) -> npt.NDArray[np.bool_]:
+        return self._data.isna()
+
+class NDArrayBackedExtensionIndex(ExtensionIndex):
+    _data: NDArrayBackedExtensionArray
+
+    def _get_engine_target(self) -> np.ndarray:
+        return self._data._ndarray
+
+    def _from_join_target(self, result: np.ndarray) -> ArrayLike:
+        assert result.dtype == self._data._ndarray.dtype
+        return self._data._from_backing_data(result)
+
+# File: pandas-main/pandas/core/indexes/frozen.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, NoReturn
+from pandas.core.base import PandasObject
+from pandas.io.formats.printing import pprint_thing
+if TYPE_CHECKING:
+    from pandas._typing import Self
+
+class FrozenList(PandasObject, list):
+
+    def union(self, other) -> FrozenList:
+        if isinstance(other, tuple):
+            other = list(other)
+        return type(self)(super().__add__(other))
+
+    def difference(self, other) -> FrozenList:
+        other = set(other)
+        temp = [x for x in self if x not in other]
+        return type(self)(temp)
+    __add__ = __iadd__ = union
+
+    def __getitem__(self, n):
+        if isinstance(n, slice):
+            return type(self)(super().__getitem__(n))
+        return super().__getitem__(n)
+
+    def __radd__(self, other) -> Self:
+        if isinstance(other, tuple):
+            other = list(other)
+        return type(self)(other + list(self))
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, (tuple, FrozenList)):
+            other = list(other)
+        return super().__eq__(other)
+    __req__ = __eq__
+
+    def __mul__(self, other) -> Self:
+        return type(self)(super().__mul__(other))
+    __imul__ = __mul__
+
+    def __reduce__(self):
+        return (type(self), (list(self),))
+
+    def __hash__(self) -> int:
+        return hash(tuple(self))
+
+    def _disabled(self, *args, **kwargs) -> NoReturn:
+        raise TypeError(f"'{type(self).__name__}' does not support mutable operations.")
+
+    def __str__(self) -> str:
+        return pprint_thing(self, quote_strings=True, escape_chars=('\t', '\r', '\n'))
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}({self!s})'
+    __setitem__ = __setslice__ = _disabled
+    __delitem__ = __delslice__ = _disabled
+    pop = append = extend = _disabled
+    remove = sort = insert = _disabled
+
+# File: pandas-main/pandas/core/indexes/interval.py
+""""""
+from __future__ import annotations
+from operator import le, lt
+import textwrap
+from typing import TYPE_CHECKING, Any, Literal
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.interval import Interval, IntervalMixin, IntervalTree
+from pandas._libs.tslibs import BaseOffset, Period, Timedelta, Timestamp, to_offset
+from pandas.errors import InvalidIndexError
+from pandas.util._decorators import Appender, cache_readonly
+from pandas.util._exceptions import rewrite_exception
+from pandas.core.dtypes.cast import find_common_type, infer_dtype_from_scalar, maybe_box_datetimelike, maybe_downcast_numeric, maybe_upcast_numeric_to_64bit
+from pandas.core.dtypes.common import ensure_platform_int, is_float_dtype, is_integer, is_integer_dtype, is_list_like, is_number, is_object_dtype, is_scalar, pandas_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype, IntervalDtype
+from pandas.core.dtypes.missing import is_valid_na_for_dtype
+from pandas.core.algorithms import unique
+from pandas.core.arrays.datetimelike import validate_periods
+from pandas.core.arrays.interval import IntervalArray, _interval_shared_docs
+import pandas.core.common as com
+from pandas.core.indexers import is_valid_positional_slice
+import pandas.core.indexes.base as ibase
+from pandas.core.indexes.base import Index, _index_shared_docs, ensure_index, maybe_extract_name
+from pandas.core.indexes.datetimes import DatetimeIndex, date_range
+from pandas.core.indexes.extension import ExtensionIndex, inherit_names
+from pandas.core.indexes.multi import MultiIndex
+from pandas.core.indexes.timedeltas import TimedeltaIndex, timedelta_range
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+    from pandas._typing import Dtype, DtypeObj, IntervalClosedType, Self, npt
+_index_doc_kwargs = dict(ibase._index_doc_kwargs)
+_index_doc_kwargs.update({'klass': 'IntervalIndex', 'qualname': 'IntervalIndex', 'target_klass': 'IntervalIndex or list of Intervals', 'name': textwrap.dedent('         name : object, optional\n              Name to be stored in the index.\n         ')})
+
+def _get_next_label(label):
+    dtype = getattr(label, 'dtype', type(label))
+    if isinstance(label, (Timestamp, Timedelta)):
+        dtype = 'datetime64[ns]'
+    dtype = pandas_dtype(dtype)
+    if lib.is_np_dtype(dtype, 'mM') or isinstance(dtype, DatetimeTZDtype):
+        return label + np.timedelta64(1, 'ns')
+    elif is_integer_dtype(dtype):
+        return label + 1
+    elif is_float_dtype(dtype):
+        return np.nextafter(label, np.inf)
+    else:
+        raise TypeError(f'cannot determine next label for type {type(label)!r}')
+
+def _get_prev_label(label):
+    dtype = getattr(label, 'dtype', type(label))
+    if isinstance(label, (Timestamp, Timedelta)):
+        dtype = 'datetime64[ns]'
+    dtype = pandas_dtype(dtype)
+    if lib.is_np_dtype(dtype, 'mM') or isinstance(dtype, DatetimeTZDtype):
+        return label - np.timedelta64(1, 'ns')
+    elif is_integer_dtype(dtype):
+        return label - 1
+    elif is_float_dtype(dtype):
+        return np.nextafter(label, -np.inf)
+    else:
+        raise TypeError(f'cannot determine next label for type {type(label)!r}')
+
+def _new_IntervalIndex(cls, d):
+    return cls.from_arrays(**d)
+
+@Appender(_interval_shared_docs['class'] % {'klass': 'IntervalIndex', 'summary': 'Immutable index of intervals that are closed on the same side.', 'name': _index_doc_kwargs['name'], 'extra_attributes': 'is_overlapping\nvalues\n', 'extra_methods': '', 'examples': textwrap.dedent("    Examples\n    --------\n    A new ``IntervalIndex`` is typically constructed using\n    :func:`interval_range`:\n\n    >>> pd.interval_range(start=0, end=5)\n    IntervalIndex([(0, 1], (1, 2], (2, 3], (3, 4], (4, 5]],\n                  dtype='interval[int64, right]')\n\n    It may also be constructed using one of the constructor\n    methods: :meth:`IntervalIndex.from_arrays`,\n    :meth:`IntervalIndex.from_breaks`, and :meth:`IntervalIndex.from_tuples`.\n\n    See further examples in the doc strings of ``interval_range`` and the\n    mentioned constructor methods.\n    ")})
+@inherit_names(['set_closed', 'to_tuples'], IntervalArray, wrap=True)
+@inherit_names(['__array__', 'overlaps', 'contains', 'closed_left', 'closed_right', 'open_left', 'open_right', 'is_empty'], IntervalArray)
+@inherit_names(['is_non_overlapping_monotonic', 'closed'], IntervalArray, cache=True)
+class IntervalIndex(ExtensionIndex):
+    _typ = 'intervalindex'
+    closed: IntervalClosedType
+    is_non_overlapping_monotonic: bool
+    closed_left: bool
+    closed_right: bool
+    open_left: bool
+    open_right: bool
+    _data: IntervalArray
+    _values: IntervalArray
+    _can_hold_strings = False
+    _data_cls = IntervalArray
+
+    def __new__(cls, data, closed: IntervalClosedType | None=None, dtype: Dtype | None=None, copy: bool=False, name: Hashable | None=None, verify_integrity: bool=True) -> Self:
+        name = maybe_extract_name(name, data, cls)
+        with rewrite_exception('IntervalArray', cls.__name__):
+            array = IntervalArray(data, closed=closed, copy=copy, dtype=dtype, verify_integrity=verify_integrity)
+        return cls._simple_new(array, name)
+
+    @classmethod
+    @Appender(_interval_shared_docs['from_breaks'] % {'klass': 'IntervalIndex', 'name': textwrap.dedent('\n             name : str, optional\n                  Name of the resulting IntervalIndex.'), 'examples': textwrap.dedent("        Examples\n        --------\n        >>> pd.IntervalIndex.from_breaks([0, 1, 2, 3])\n        IntervalIndex([(0, 1], (1, 2], (2, 3]],\n                      dtype='interval[int64, right]')\n        ")})
+    def from_breaks(cls, breaks, closed: IntervalClosedType | None='right', name: Hashable | None=None, copy: bool=False, dtype: Dtype | None=None) -> IntervalIndex:
+        with rewrite_exception('IntervalArray', cls.__name__):
+            array = IntervalArray.from_breaks(breaks, closed=closed, copy=copy, dtype=dtype)
+        return cls._simple_new(array, name=name)
+
+    @classmethod
+    @Appender(_interval_shared_docs['from_arrays'] % {'klass': 'IntervalIndex', 'name': textwrap.dedent('\n             name : str, optional\n                  Name of the resulting IntervalIndex.'), 'examples': textwrap.dedent("        Examples\n        --------\n        >>> pd.IntervalIndex.from_arrays([0, 1, 2], [1, 2, 3])\n        IntervalIndex([(0, 1], (1, 2], (2, 3]],\n                      dtype='interval[int64, right]')\n        ")})
+    def from_arrays(cls, left, right, closed: IntervalClosedType='right', name: Hashable | None=None, copy: bool=False, dtype: Dtype | None=None) -> IntervalIndex:
+        with rewrite_exception('IntervalArray', cls.__name__):
+            array = IntervalArray.from_arrays(left, right, closed, copy=copy, dtype=dtype)
+        return cls._simple_new(array, name=name)
+
+    @classmethod
+    @Appender(_interval_shared_docs['from_tuples'] % {'klass': 'IntervalIndex', 'name': textwrap.dedent('\n             name : str, optional\n                  Name of the resulting IntervalIndex.'), 'examples': textwrap.dedent("        Examples\n        --------\n        >>> pd.IntervalIndex.from_tuples([(0, 1), (1, 2)])\n        IntervalIndex([(0, 1], (1, 2]],\n                       dtype='interval[int64, right]')\n        ")})
+    def from_tuples(cls, data, closed: IntervalClosedType='right', name: Hashable | None=None, copy: bool=False, dtype: Dtype | None=None) -> IntervalIndex:
+        with rewrite_exception('IntervalArray', cls.__name__):
+            arr = IntervalArray.from_tuples(data, closed=closed, copy=copy, dtype=dtype)
+        return cls._simple_new(arr, name=name)
+
+    @cache_readonly
+    def _engine(self) -> IntervalTree:
+        left = self._maybe_convert_i8(self.left)
+        left = maybe_upcast_numeric_to_64bit(left)
+        right = self._maybe_convert_i8(self.right)
+        right = maybe_upcast_numeric_to_64bit(right)
+        return IntervalTree(left, right, closed=self.closed)
+
+    def __contains__(self, key: Any) -> bool:
+        hash(key)
+        if not isinstance(key, Interval):
+            if is_valid_na_for_dtype(key, self.dtype):
+                return self.hasnans
+            return False
+        try:
+            self.get_loc(key)
+            return True
+        except KeyError:
+            return False
+
+    def _getitem_slice(self, slobj: slice) -> IntervalIndex:
+        res = self._data[slobj]
+        return type(self)._simple_new(res, name=self._name)
+
+    @cache_readonly
+    def _multiindex(self) -> MultiIndex:
+        return MultiIndex.from_arrays([self.left, self.right], names=['left', 'right'])
+
+    def __reduce__(self):
+        d = {'left': self.left, 'right': self.right, 'closed': self.closed, 'name': self.name}
+        return (_new_IntervalIndex, (type(self), d), None)
+
+    @property
+    def inferred_type(self) -> str:
+        return 'interval'
+
+    @Appender(Index.memory_usage.__doc__)
+    def memory_usage(self, deep: bool=False) -> int:
+        return self.left.memory_usage(deep=deep) + self.right.memory_usage(deep=deep)
+
+    @cache_readonly
+    def is_monotonic_decreasing(self) -> bool:
+        return self[::-1].is_monotonic_increasing
+
+    @cache_readonly
+    def is_unique(self) -> bool:
+        left = self.left
+        right = self.right
+        if self.isna().sum() > 1:
+            return False
+        if left.is_unique or right.is_unique:
+            return True
+        seen_pairs = set()
+        check_idx = np.where(left.duplicated(keep=False))[0]
+        for idx in check_idx:
+            pair = (left[idx], right[idx])
+            if pair in seen_pairs:
+                return False
+            seen_pairs.add(pair)
+        return True
+
+    @property
+    def is_overlapping(self) -> bool:
+        return self._engine.is_overlapping
+
+    def _needs_i8_conversion(self, key) -> bool:
+        key_dtype = getattr(key, 'dtype', None)
+        if isinstance(key_dtype, IntervalDtype) or isinstance(key, Interval):
+            return self._needs_i8_conversion(key.left)
+        i8_types = (Timestamp, Timedelta, DatetimeIndex, TimedeltaIndex)
+        return isinstance(key, i8_types)
+
+    def _maybe_convert_i8(self, key):
+        if is_list_like(key):
+            key = ensure_index(key)
+            key = maybe_upcast_numeric_to_64bit(key)
+        if not self._needs_i8_conversion(key):
+            return key
+        scalar = is_scalar(key)
+        key_dtype = getattr(key, 'dtype', None)
+        if isinstance(key_dtype, IntervalDtype) or isinstance(key, Interval):
+            left = self._maybe_convert_i8(key.left)
+            right = self._maybe_convert_i8(key.right)
+            constructor = Interval if scalar else IntervalIndex.from_arrays
+            return constructor(left, right, closed=self.closed)
+        if scalar:
+            (key_dtype, key_i8) = infer_dtype_from_scalar(key)
+            if isinstance(key, Period):
+                key_i8 = key.ordinal
+            elif isinstance(key_i8, Timestamp):
+                key_i8 = key_i8._value
+            elif isinstance(key_i8, (np.datetime64, np.timedelta64)):
+                key_i8 = key_i8.view('i8')
+        else:
+            (key_dtype, key_i8) = (key.dtype, Index(key.asi8))
+            if key.hasnans:
+                key_i8 = key_i8.where(~key._isnan)
+        subtype = self.dtype.subtype
+        if subtype != key_dtype:
+            raise ValueError(f'Cannot index an IntervalIndex of subtype {subtype} with values of dtype {key_dtype}')
+        return key_i8
+
+    def _searchsorted_monotonic(self, label, side: Literal['left', 'right']='left'):
+        if not self.is_non_overlapping_monotonic:
+            raise KeyError('can only get slices from an IntervalIndex if bounds are non-overlapping and all monotonic increasing or decreasing')
+        if isinstance(label, (IntervalMixin, IntervalIndex)):
+            raise NotImplementedError('Interval objects are not currently supported')
+        if side == 'left' and self.left.is_monotonic_increasing or (side == 'right' and (not self.left.is_monotonic_increasing)):
+            sub_idx = self.right
+            if self.open_right:
+                label = _get_next_label(label)
+        else:
+            sub_idx = self.left
+            if self.open_left:
+                label = _get_prev_label(label)
+        return sub_idx._searchsorted_monotonic(label, side)
+
+    def get_loc(self, key) -> int | slice | np.ndarray:
+        self._check_indexing_error(key)
+        if isinstance(key, Interval):
+            if self.closed != key.closed:
+                raise KeyError(key)
+            mask = (self.left == key.left) & (self.right == key.right)
+        elif is_valid_na_for_dtype(key, self.dtype):
+            mask = self.isna()
+        else:
+            op_left = le if self.closed_left else lt
+            op_right = le if self.closed_right else lt
+            try:
+                mask = op_left(self.left, key) & op_right(key, self.right)
+            except TypeError as err:
+                raise KeyError(key) from err
+        matches = mask.sum()
+        if matches == 0:
+            raise KeyError(key)
+        if matches == 1:
+            return mask.argmax()
+        res = lib.maybe_booleans_to_slice(mask.view('u1'))
+        if isinstance(res, slice) and res.stop is None:
+            res = slice(res.start, len(self), res.step)
+        return res
+
+    def _get_indexer(self, target: Index, method: str | None=None, limit: int | None=None, tolerance: Any | None=None) -> npt.NDArray[np.intp]:
+        if isinstance(target, IntervalIndex):
+            indexer = self._get_indexer_unique_sides(target)
+        elif not is_object_dtype(target.dtype):
+            target = self._maybe_convert_i8(target)
+            indexer = self._engine.get_indexer(target.values)
+        else:
+            return self._get_indexer_pointwise(target)[0]
+        return ensure_platform_int(indexer)
+
+    @Appender(_index_shared_docs['get_indexer_non_unique'] % _index_doc_kwargs)
+    def get_indexer_non_unique(self, target: Index) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+        target = ensure_index(target)
+        if not self._should_compare(target) and (not self._should_partial_index(target)):
+            return self._get_indexer_non_comparable(target, None, unique=False)
+        elif isinstance(target, IntervalIndex):
+            if self.left.is_unique and self.right.is_unique:
+                indexer = self._get_indexer_unique_sides(target)
+                missing = (indexer == -1).nonzero()[0]
+            else:
+                return self._get_indexer_pointwise(target)
+        elif is_object_dtype(target.dtype) or not self._should_partial_index(target):
+            return self._get_indexer_pointwise(target)
+        else:
+            target = self._maybe_convert_i8(target)
+            (indexer, missing) = self._engine.get_indexer_non_unique(target.values)
+        return (ensure_platform_int(indexer), ensure_platform_int(missing))
+
+    def _get_indexer_unique_sides(self, target: IntervalIndex) -> npt.NDArray[np.intp]:
+        left_indexer = self.left.get_indexer(target.left)
+        right_indexer = self.right.get_indexer(target.right)
+        indexer = np.where(left_indexer == right_indexer, left_indexer, -1)
+        return indexer
+
+    def _get_indexer_pointwise(self, target: Index) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+        (indexer, missing) = ([], [])
+        for (i, key) in enumerate(target):
+            try:
+                locs = self.get_loc(key)
+                if isinstance(locs, slice):
+                    locs = np.arange(locs.start, locs.stop, locs.step, dtype='intp')
+                elif lib.is_integer(locs):
+                    locs = np.array(locs, ndmin=1)
+                else:
+                    locs = np.where(locs)[0]
+            except KeyError:
+                missing.append(i)
+                locs = np.array([-1])
+            except InvalidIndexError:
+                missing.append(i)
+                locs = np.array([-1])
+            indexer.append(locs)
+        indexer = np.concatenate(indexer)
+        return (ensure_platform_int(indexer), ensure_platform_int(missing))
+
+    @cache_readonly
+    def _index_as_unique(self) -> bool:
+        return not self.is_overlapping and self._engine._na_count < 2
+    _requires_unique_msg = 'cannot handle overlapping indices; use IntervalIndex.get_indexer_non_unique'
+
+    def _convert_slice_indexer(self, key: slice, kind: Literal['loc', 'getitem']):
+        if not (key.step is None or key.step == 1):
+            msg = 'label-based slicing with step!=1 is not supported for IntervalIndex'
+            if kind == 'loc':
+                raise ValueError(msg)
+            if kind == 'getitem':
+                if not is_valid_positional_slice(key):
+                    raise ValueError(msg)
+        return super()._convert_slice_indexer(key, kind)
+
+    @cache_readonly
+    def _should_fallback_to_positional(self) -> bool:
+        return self.dtype.subtype.kind in 'mM'
+
+    def _maybe_cast_slice_bound(self, label, side: str):
+        return getattr(self, side)._maybe_cast_slice_bound(label, side)
+
+    def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
+        if not isinstance(dtype, IntervalDtype):
+            return False
+        common_subtype = find_common_type([self.dtype, dtype])
+        return not is_object_dtype(common_subtype)
+
+    @cache_readonly
+    def left(self) -> Index:
+        return Index(self._data.left, copy=False)
+
+    @cache_readonly
+    def right(self) -> Index:
+        return Index(self._data.right, copy=False)
+
+    @cache_readonly
+    def mid(self) -> Index:
+        return Index(self._data.mid, copy=False)
+
+    @property
+    def length(self) -> Index:
+        return Index(self._data.length, copy=False)
+
+    def _intersection(self, other, sort):
+        if self.left.is_unique and self.right.is_unique:
+            taken = self._intersection_unique(other)
+        elif other.left.is_unique and other.right.is_unique and (self.isna().sum() <= 1):
+            taken = other._intersection_unique(self)
+        else:
+            taken = self._intersection_non_unique(other)
+        if sort is None:
+            taken = taken.sort_values()
+        return taken
+
+    def _intersection_unique(self, other: IntervalIndex) -> IntervalIndex:
+        lindexer = self.left.get_indexer(other.left)
+        rindexer = self.right.get_indexer(other.right)
+        match = (lindexer == rindexer) & (lindexer != -1)
+        indexer = lindexer.take(match.nonzero()[0])
+        indexer = unique(indexer)
+        return self.take(indexer)
+
+    def _intersection_non_unique(self, other: IntervalIndex) -> IntervalIndex:
+        mask = np.zeros(len(self), dtype=bool)
+        if self.hasnans and other.hasnans:
+            first_nan_loc = np.arange(len(self))[self.isna()][0]
+            mask[first_nan_loc] = True
+        other_tups = set(zip(other.left, other.right))
+        for (i, tup) in enumerate(zip(self.left, self.right)):
+            if tup in other_tups:
+                mask[i] = True
+        return self[mask]
+
+    def _get_engine_target(self) -> np.ndarray:
+        raise NotImplementedError('IntervalIndex does not use libjoin fastpaths or pass values to IndexEngine objects')
+
+    def _from_join_target(self, result):
+        raise NotImplementedError('IntervalIndex does not use libjoin fastpaths')
+
+def _is_valid_endpoint(endpoint) -> bool:
+    return any([is_number(endpoint), isinstance(endpoint, Timestamp), isinstance(endpoint, Timedelta), endpoint is None])
+
+def _is_type_compatible(a, b) -> bool:
+    is_ts_compat = lambda x: isinstance(x, (Timestamp, BaseOffset))
+    is_td_compat = lambda x: isinstance(x, (Timedelta, BaseOffset))
+    return is_number(a) and is_number(b) or (is_ts_compat(a) and is_ts_compat(b)) or (is_td_compat(a) and is_td_compat(b)) or com.any_none(a, b)
+
+def interval_range(start=None, end=None, periods=None, freq=None, name: Hashable | None=None, closed: IntervalClosedType='right') -> IntervalIndex:
+    start = maybe_box_datetimelike(start)
+    end = maybe_box_datetimelike(end)
+    endpoint = start if start is not None else end
+    if freq is None and com.any_none(periods, start, end):
+        freq = 1 if is_number(endpoint) else 'D'
+    if com.count_not_none(start, end, periods, freq) != 3:
+        raise ValueError('Of the four parameters: start, end, periods, and freq, exactly three must be specified')
+    if not _is_valid_endpoint(start):
+        raise ValueError(f'start must be numeric or datetime-like, got {start}')
+    if not _is_valid_endpoint(end):
+        raise ValueError(f'end must be numeric or datetime-like, got {end}')
+    periods = validate_periods(periods)
+    if freq is not None and (not is_number(freq)):
+        try:
+            freq = to_offset(freq)
+        except ValueError as err:
+            raise ValueError(f'freq must be numeric or convertible to DateOffset, got {freq}') from err
+    if not all([_is_type_compatible(start, end), _is_type_compatible(start, freq), _is_type_compatible(end, freq)]):
+        raise TypeError('start, end, freq need to be type compatible')
+    if periods is not None:
+        periods += 1
+    breaks: np.ndarray | TimedeltaIndex | DatetimeIndex
+    if is_number(endpoint):
+        dtype: np.dtype = np.dtype('int64')
+        if com.all_not_none(start, end, freq):
+            if isinstance(start, (float, np.float16)) or isinstance(end, (float, np.float16)) or isinstance(freq, (float, np.float16)):
+                dtype = np.dtype('float64')
+            elif isinstance(start, (np.integer, np.floating)) and isinstance(end, (np.integer, np.floating)) and (start.dtype == end.dtype):
+                dtype = start.dtype
+            breaks = np.arange(start, end + freq * 0.1, freq)
+            breaks = maybe_downcast_numeric(breaks, dtype)
+        else:
+            if periods is None:
+                periods = int((end - start) // freq) + 1
+            elif start is None:
+                start = end - (periods - 1) * freq
+            elif end is None:
+                end = start + (periods - 1) * freq
+            breaks = np.linspace(start, end, periods)
+        if all((is_integer(x) for x in com.not_none(start, end, freq))):
+            breaks = maybe_downcast_numeric(breaks, dtype)
+    elif isinstance(endpoint, Timestamp):
+        breaks = date_range(start=start, end=end, periods=periods, freq=freq)
+    else:
+        breaks = timedelta_range(start=start, end=end, periods=periods, freq=freq)
+    return IntervalIndex.from_breaks(breaks, name=name, closed=closed, dtype=IntervalDtype(subtype=breaks.dtype, closed=closed))
+
+# File: pandas-main/pandas/core/indexes/multi.py
+from __future__ import annotations
+from collections.abc import Callable, Collection, Generator, Hashable, Iterable, Sequence
+from functools import wraps
+from sys import getsizeof
+from typing import TYPE_CHECKING, Any, Literal, cast
+import warnings
+import numpy as np
+from pandas._config import get_option
+from pandas._libs import algos as libalgos, index as libindex, lib
+from pandas._libs.hashtable import duplicated
+from pandas._typing import AnyAll, AnyArrayLike, Axis, DropKeep, DtypeObj, F, IgnoreRaise, IndexLabel, IndexT, Scalar, Self, Shape, npt
+from pandas.compat.numpy import function as nv
+from pandas.errors import InvalidIndexError, PerformanceWarning, UnsortedIndexError
+from pandas.util._decorators import Appender, cache_readonly, doc
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.cast import coerce_indexer_dtype
+from pandas.core.dtypes.common import ensure_int64, ensure_platform_int, is_hashable, is_integer, is_iterator, is_list_like, is_object_dtype, is_scalar, pandas_dtype
+from pandas.core.dtypes.dtypes import CategoricalDtype, ExtensionDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.dtypes.inference import is_array_like
+from pandas.core.dtypes.missing import array_equivalent, isna
+import pandas.core.algorithms as algos
+from pandas.core.array_algos.putmask import validate_putmask
+from pandas.core.arrays import Categorical, ExtensionArray
+from pandas.core.arrays.categorical import factorize_from_iterables, recode_for_categories
+import pandas.core.common as com
+from pandas.core.construction import sanitize_array
+import pandas.core.indexes.base as ibase
+from pandas.core.indexes.base import Index, _index_shared_docs, ensure_index, get_unanimous_names
+from pandas.core.indexes.frozen import FrozenList
+from pandas.core.ops.invalid import make_invalid_op
+from pandas.core.sorting import get_group_index, lexsort_indexer
+from pandas.io.formats.printing import pprint_thing
+if TYPE_CHECKING:
+    from pandas import CategoricalIndex, DataFrame, Series
+_index_doc_kwargs = dict(ibase._index_doc_kwargs)
+_index_doc_kwargs.update({'klass': 'MultiIndex', 'target_klass': 'MultiIndex or list of tuples'})
+
+class MultiIndexUInt64Engine(libindex.BaseMultiIndexCodesEngine, libindex.UInt64Engine):
+    _base = libindex.UInt64Engine
+    _codes_dtype = 'uint64'
+
+class MultiIndexUInt32Engine(libindex.BaseMultiIndexCodesEngine, libindex.UInt32Engine):
+    _base = libindex.UInt32Engine
+    _codes_dtype = 'uint32'
+
+class MultiIndexUInt16Engine(libindex.BaseMultiIndexCodesEngine, libindex.UInt16Engine):
+    _base = libindex.UInt16Engine
+    _codes_dtype = 'uint16'
+
+class MultiIndexUInt8Engine(libindex.BaseMultiIndexCodesEngine, libindex.UInt8Engine):
+    _base = libindex.UInt8Engine
+    _codes_dtype = 'uint8'
+
+class MultiIndexPyIntEngine(libindex.BaseMultiIndexCodesEngine, libindex.ObjectEngine):
+    _base = libindex.ObjectEngine
+    _codes_dtype = 'object'
+
+def names_compat(meth: F) -> F:
+
+    @wraps(meth)
+    def new_meth(self_or_cls, *args, **kwargs):
+        if 'name' in kwargs and 'names' in kwargs:
+            raise TypeError('Can only provide one of `names` and `name`')
+        if 'name' in kwargs:
+            kwargs['names'] = kwargs.pop('name')
+        return meth(self_or_cls, *args, **kwargs)
+    return cast(F, new_meth)
+
+class MultiIndex(Index):
+    _hidden_attrs = Index._hidden_attrs | frozenset()
+    _typ = 'multiindex'
+    _names: list[Hashable | None] = []
+    _levels = FrozenList()
+    _codes = FrozenList()
+    _comparables = ['names']
+    sortorder: int | None
+
+    def __new__(cls, levels=None, codes=None, sortorder=None, names=None, dtype=None, copy: bool=False, name=None, verify_integrity: bool=True) -> Self:
+        if name is not None:
+            names = name
+        if levels is None or codes is None:
+            raise TypeError('Must pass both levels and codes')
+        if len(levels) != len(codes):
+            raise ValueError('Length of levels and codes must be the same.')
+        if len(levels) == 0:
+            raise ValueError('Must pass non-zero number of levels/codes')
+        result = object.__new__(cls)
+        result._cache = {}
+        result._set_levels(levels, copy=copy, validate=False)
+        result._set_codes(codes, copy=copy, validate=False)
+        result._names = [None] * len(levels)
+        if names is not None:
+            result._set_names(names)
+        if sortorder is not None:
+            result.sortorder = int(sortorder)
+        else:
+            result.sortorder = sortorder
+        if verify_integrity:
+            new_codes = result._verify_integrity()
+            result._codes = new_codes
+        result._reset_identity()
+        result._references = None
+        return result
+
+    def _validate_codes(self, level: Index, code: np.ndarray) -> np.ndarray:
+        null_mask = isna(level)
+        if np.any(null_mask):
+            code = np.where(null_mask[code], -1, code)
+        return code
+
+    def _verify_integrity(self, codes: list | None=None, levels: list | None=None, levels_to_verify: list[int] | range | None=None) -> FrozenList:
+        codes = codes or self.codes
+        levels = levels or self.levels
+        if levels_to_verify is None:
+            levels_to_verify = range(len(levels))
+        if len(levels) != len(codes):
+            raise ValueError('Length of levels and codes must match. NOTE: this index is in an inconsistent state.')
+        codes_length = len(codes[0])
+        for i in levels_to_verify:
+            level = levels[i]
+            level_codes = codes[i]
+            if len(level_codes) != codes_length:
+                raise ValueError(f'Unequal code lengths: {[len(code_) for code_ in codes]}')
+            if len(level_codes) and level_codes.max() >= len(level):
+                raise ValueError(f'On level {i}, code max ({level_codes.max()}) >= length of level ({len(level)}). NOTE: this index is in an inconsistent state')
+            if len(level_codes) and level_codes.min() < -1:
+                raise ValueError(f'On level {i}, code value ({level_codes.min()}) < -1')
+            if not level.is_unique:
+                raise ValueError(f'Level values must be unique: {list(level)} on level {i}')
+        if self.sortorder is not None:
+            if self.sortorder > _lexsort_depth(self.codes, self.nlevels):
+                raise ValueError(f'Value for sortorder must be inferior or equal to actual lexsort_depth: sortorder {self.sortorder} with lexsort_depth {_lexsort_depth(self.codes, self.nlevels)}')
+        result_codes = []
+        for i in range(len(levels)):
+            if i in levels_to_verify:
+                result_codes.append(self._validate_codes(levels[i], codes[i]))
+            else:
+                result_codes.append(codes[i])
+        new_codes = FrozenList(result_codes)
+        return new_codes
+
+    @classmethod
+    def from_arrays(cls, arrays, sortorder: int | None=None, names: Sequence[Hashable] | Hashable | lib.NoDefault=lib.no_default) -> MultiIndex:
+        error_msg = 'Input must be a list / sequence of array-likes.'
+        if not is_list_like(arrays):
+            raise TypeError(error_msg)
+        if is_iterator(arrays):
+            arrays = list(arrays)
+        for array in arrays:
+            if not is_list_like(array):
+                raise TypeError(error_msg)
+        for i in range(1, len(arrays)):
+            if len(arrays[i]) != len(arrays[i - 1]):
+                raise ValueError('all arrays must be same length')
+        (codes, levels) = factorize_from_iterables(arrays)
+        if names is lib.no_default:
+            names = [getattr(arr, 'name', None) for arr in arrays]
+        return cls(levels=levels, codes=codes, sortorder=sortorder, names=names, verify_integrity=False)
+
+    @classmethod
+    @names_compat
+    def from_tuples(cls, tuples: Iterable[tuple[Hashable, ...]], sortorder: int | None=None, names: Sequence[Hashable] | Hashable | None=None) -> MultiIndex:
+        if not is_list_like(tuples):
+            raise TypeError('Input must be a list / sequence of tuple-likes.')
+        if is_iterator(tuples):
+            tuples = list(tuples)
+        tuples = cast(Collection[tuple[Hashable, ...]], tuples)
+        if len(tuples) and all((isinstance(e, tuple) and (not e) for e in tuples)):
+            codes = [np.zeros(len(tuples))]
+            levels = [Index(com.asarray_tuplesafe(tuples, dtype=np.dtype('object')))]
+            return cls(levels=levels, codes=codes, sortorder=sortorder, names=names, verify_integrity=False)
+        arrays: list[Sequence[Hashable]]
+        if len(tuples) == 0:
+            if names is None:
+                raise TypeError('Cannot infer number of levels from empty list')
+            arrays = [[]] * len(names)
+        elif isinstance(tuples, (np.ndarray, Index)):
+            if isinstance(tuples, Index):
+                tuples = np.asarray(tuples._values)
+            arrays = list(lib.tuples_to_object_array(tuples).T)
+        elif isinstance(tuples, list):
+            arrays = list(lib.to_object_array_tuples(tuples).T)
+        else:
+            arrs = zip(*tuples)
+            arrays = cast(list[Sequence[Hashable]], arrs)
+        return cls.from_arrays(arrays, sortorder=sortorder, names=names)
+
+    @classmethod
+    def from_product(cls, iterables: Sequence[Iterable[Hashable]], sortorder: int | None=None, names: Sequence[Hashable] | Hashable | lib.NoDefault=lib.no_default) -> MultiIndex:
+        if not is_list_like(iterables):
+            raise TypeError('Input must be a list / sequence of iterables.')
+        if is_iterator(iterables):
+            iterables = list(iterables)
+        (codes, levels) = factorize_from_iterables(iterables)
+        if names is lib.no_default:
+            names = [getattr(it, 'name', None) for it in iterables]
+        codes = cartesian_product(codes)
+        return cls(levels, codes, sortorder=sortorder, names=names)
+
+    @classmethod
+    def from_frame(cls, df: DataFrame, sortorder: int | None=None, names: Sequence[Hashable] | Hashable | None=None) -> MultiIndex:
+        if not isinstance(df, ABCDataFrame):
+            raise TypeError('Input must be a DataFrame')
+        (column_names, columns) = zip(*df.items())
+        names = column_names if names is None else names
+        return cls.from_arrays(columns, sortorder=sortorder, names=names)
+
+    @cache_readonly
+    def _values(self) -> np.ndarray:
+        values = []
+        for i in range(self.nlevels):
+            index = self.levels[i]
+            codes = self.codes[i]
+            vals = index
+            if isinstance(vals.dtype, CategoricalDtype):
+                vals = cast('CategoricalIndex', vals)
+                vals = vals._data._internal_get_values()
+            if isinstance(vals.dtype, ExtensionDtype) or lib.is_np_dtype(vals.dtype, 'mM'):
+                vals = vals.astype(object)
+            array_vals = np.asarray(vals)
+            array_vals = algos.take_nd(array_vals, codes, fill_value=index._na_value)
+            values.append(array_vals)
+        arr = lib.fast_zip(values)
+        return arr
+
+    @property
+    def values(self) -> np.ndarray:
+        return self._values
+
+    @property
+    def array(self):
+        raise ValueError("MultiIndex has no single backing array. Use 'MultiIndex.to_numpy()' to get a NumPy array of tuples.")
+
+    @cache_readonly
+    def dtypes(self) -> Series:
+        from pandas import Series
+        names = com.fill_missing_names(self.names)
+        return Series([level.dtype for level in self.levels], index=Index(names))
+
+    def __len__(self) -> int:
+        return len(self.codes[0])
+
+    @property
+    def size(self) -> int:
+        return len(self)
+
+    @cache_readonly
+    def levels(self) -> FrozenList:
+        result = [x._rename(name=name) for (x, name) in zip(self._levels, self._names)]
+        for level in result:
+            level._no_setting_name = True
+        return FrozenList(result)
+
+    def _set_levels(self, levels, *, level=None, copy: bool=False, validate: bool=True, verify_integrity: bool=False) -> None:
+        if validate:
+            if len(levels) == 0:
+                raise ValueError('Must set non-zero number of levels.')
+            if level is None and len(levels) != self.nlevels:
+                raise ValueError('Length of levels must match number of levels.')
+            if level is not None and len(levels) != len(level):
+                raise ValueError('Length of levels must match length of level.')
+        if level is None:
+            new_levels = FrozenList((ensure_index(lev, copy=copy)._view() for lev in levels))
+            level_numbers: range | list[int] = range(len(new_levels))
+        else:
+            level_numbers = [self._get_level_number(lev) for lev in level]
+            new_levels_list = list(self._levels)
+            for (lev_num, lev) in zip(level_numbers, levels):
+                new_levels_list[lev_num] = ensure_index(lev, copy=copy)._view()
+            new_levels = FrozenList(new_levels_list)
+        if verify_integrity:
+            new_codes = self._verify_integrity(levels=new_levels, levels_to_verify=level_numbers)
+            self._codes = new_codes
+        names = self.names
+        self._levels = new_levels
+        if any(names):
+            self._set_names(names)
+        self._reset_cache()
+
+    def set_levels(self, levels, *, level=None, verify_integrity: bool=True) -> MultiIndex:
+        if isinstance(levels, Index):
+            pass
+        elif is_array_like(levels):
+            levels = Index(levels)
+        elif is_list_like(levels):
+            levels = list(levels)
+        (level, levels) = _require_listlike(level, levels, 'Levels')
+        idx = self._view()
+        idx._reset_identity()
+        idx._set_levels(levels, level=level, validate=True, verify_integrity=verify_integrity)
+        return idx
+
+    @property
+    def nlevels(self) -> int:
+        return len(self._levels)
+
+    @property
+    def levshape(self) -> Shape:
+        return tuple((len(x) for x in self.levels))
+
+    @property
+    def codes(self) -> FrozenList:
+        return self._codes
+
+    def _set_codes(self, codes, *, level=None, copy: bool=False, validate: bool=True, verify_integrity: bool=False) -> None:
+        if validate:
+            if level is None and len(codes) != self.nlevels:
+                raise ValueError('Length of codes must match number of levels')
+            if level is not None and len(codes) != len(level):
+                raise ValueError('Length of codes must match length of levels.')
+        level_numbers: list[int] | range
+        if level is None:
+            new_codes = FrozenList((_coerce_indexer_frozen(level_codes, lev, copy=copy).view() for (lev, level_codes) in zip(self._levels, codes)))
+            level_numbers = range(len(new_codes))
+        else:
+            level_numbers = [self._get_level_number(lev) for lev in level]
+            new_codes_list = list(self._codes)
+            for (lev_num, level_codes) in zip(level_numbers, codes):
+                lev = self.levels[lev_num]
+                new_codes_list[lev_num] = _coerce_indexer_frozen(level_codes, lev, copy=copy)
+            new_codes = FrozenList(new_codes_list)
+        if verify_integrity:
+            new_codes = self._verify_integrity(codes=new_codes, levels_to_verify=level_numbers)
+        self._codes = new_codes
+        self._reset_cache()
+
+    def set_codes(self, codes, *, level=None, verify_integrity: bool=True) -> MultiIndex:
+        (level, codes) = _require_listlike(level, codes, 'Codes')
+        idx = self._view()
+        idx._reset_identity()
+        idx._set_codes(codes, level=level, verify_integrity=verify_integrity)
+        return idx
+
+    @cache_readonly
+    def _engine(self):
+        sizes = np.ceil(np.log2([len(level) + libindex.multiindex_nulls_shift for level in self.levels]))
+        lev_bits = np.cumsum(sizes[::-1])[::-1]
+        offsets = np.concatenate([lev_bits[1:], [0]])
+        offsets = offsets.astype(np.min_scalar_type(int(offsets[0])))
+        if lev_bits[0] > 64:
+            return MultiIndexPyIntEngine(self.levels, self.codes, offsets)
+        if lev_bits[0] > 32:
+            return MultiIndexUInt64Engine(self.levels, self.codes, offsets)
+        if lev_bits[0] > 16:
+            return MultiIndexUInt32Engine(self.levels, self.codes, offsets)
+        if lev_bits[0] > 8:
+            return MultiIndexUInt16Engine(self.levels, self.codes, offsets)
+        return MultiIndexUInt8Engine(self.levels, self.codes, offsets)
+
+    @property
+    def _constructor(self) -> Callable[..., MultiIndex]:
+        return type(self).from_tuples
+
+    @doc(Index._shallow_copy)
+    def _shallow_copy(self, values: np.ndarray, name=lib.no_default) -> MultiIndex:
+        names = name if name is not lib.no_default else self.names
+        return type(self).from_tuples(values, sortorder=None, names=names)
+
+    def _view(self) -> MultiIndex:
+        result = type(self)(levels=self.levels, codes=self.codes, sortorder=self.sortorder, names=self.names, verify_integrity=False)
+        result._cache = self._cache.copy()
+        result._reset_cache('levels')
+        return result
+
+    def copy(self, names=None, deep: bool=False, name=None) -> Self:
+        names = self._validate_names(name=name, names=names, deep=deep)
+        keep_id = not deep
+        (levels, codes) = (None, None)
+        if deep:
+            from copy import deepcopy
+            levels = deepcopy(self.levels)
+            codes = deepcopy(self.codes)
+        levels = levels if levels is not None else self.levels
+        codes = codes if codes is not None else self.codes
+        new_index = type(self)(levels=levels, codes=codes, sortorder=self.sortorder, names=names, verify_integrity=False)
+        new_index._cache = self._cache.copy()
+        new_index._reset_cache('levels')
+        if keep_id:
+            new_index._id = self._id
+        return new_index
+
+    def __array__(self, dtype=None, copy=None) -> np.ndarray:
+        return self.values
+
+    def view(self, cls=None) -> Self:
+        result = self.copy()
+        result._id = self._id
+        return result
+
+    @doc(Index.__contains__)
+    def __contains__(self, key: Any) -> bool:
+        hash(key)
+        try:
+            self.get_loc(key)
+            return True
+        except (LookupError, TypeError, ValueError):
+            return False
+
+    @cache_readonly
+    def dtype(self) -> np.dtype:
+        return np.dtype('O')
+
+    @cache_readonly
+    def _is_memory_usage_qualified(self) -> bool:
+
+        def f(level) -> bool:
+            return 'mixed' in level or 'string' in level or 'unicode' in level
+        return any((f(level.inferred_type) for level in self.levels))
+
+    @doc(Index.memory_usage)
+    def memory_usage(self, deep: bool=False) -> int:
+        return self._nbytes(deep)
+
+    @cache_readonly
+    def nbytes(self) -> int:
+        return self._nbytes(False)
+
+    def _nbytes(self, deep: bool=False) -> int:
+        objsize = 24
+        level_nbytes = sum((i.memory_usage(deep=deep) for i in self.levels))
+        label_nbytes = sum((i.nbytes for i in self.codes))
+        names_nbytes = sum((getsizeof(i, objsize) for i in self.names))
+        result = level_nbytes + label_nbytes + names_nbytes
+        if '_engine' in self._cache:
+            result += self._engine.sizeof(deep=deep)
+        return result
+
+    def _formatter_func(self, tup):
+        formatter_funcs = (level._formatter_func for level in self.levels)
+        return tuple((func(val) for (func, val) in zip(formatter_funcs, tup)))
+
+    def _get_values_for_csv(self, *, na_rep: str='nan', **kwargs) -> npt.NDArray[np.object_]:
+        new_levels = []
+        new_codes = []
+        for (level, level_codes) in zip(self.levels, self.codes):
+            level_strs = level._get_values_for_csv(na_rep=na_rep, **kwargs)
+            mask = level_codes == -1
+            if mask.any():
+                nan_index = len(level_strs)
+                level_strs = level_strs.astype(str)
+                level_strs = np.append(level_strs, na_rep)
+                assert not level_codes.flags.writeable
+                level_codes = level_codes.copy()
+                level_codes[mask] = nan_index
+            new_levels.append(level_strs)
+            new_codes.append(level_codes)
+        if len(new_levels) == 1:
+            return Index(new_levels[0].take(new_codes[0]))._get_values_for_csv()
+        else:
+            mi = MultiIndex(levels=new_levels, codes=new_codes, names=self.names, sortorder=self.sortorder, verify_integrity=False)
+            return mi._values
+
+    def _format_multi(self, *, include_names: bool, sparsify: bool | None | lib.NoDefault, formatter: Callable | None=None) -> list:
+        if len(self) == 0:
+            return []
+        stringified_levels = []
+        for (lev, level_codes) in zip(self.levels, self.codes):
+            na = _get_na_rep(lev.dtype)
+            if len(lev) > 0:
+                taken = formatted = lev.take(level_codes)
+                formatted = taken._format_flat(include_name=False, formatter=formatter)
+                mask = level_codes == -1
+                if mask.any():
+                    formatted = np.array(formatted, dtype=object)
+                    formatted[mask] = na
+                    formatted = formatted.tolist()
+            else:
+                formatted = [pprint_thing(na if isna(x) else x, escape_chars=('\t', '\r', '\n')) for x in algos.take_nd(lev._values, level_codes)]
+            stringified_levels.append(formatted)
+        result_levels = []
+        for (lev, lev_name) in zip(stringified_levels, self.names):
+            level = []
+            if include_names:
+                level.append(pprint_thing(lev_name, escape_chars=('\t', '\r', '\n')) if lev_name is not None else '')
+            level.extend(np.array(lev, dtype=object))
+            result_levels.append(level)
+        if sparsify is None:
+            sparsify = get_option('display.multi_sparse')
+        if sparsify:
+            sentinel: Literal[''] | bool | lib.NoDefault = ''
+            assert isinstance(sparsify, bool) or sparsify is lib.no_default
+            if sparsify is lib.no_default:
+                sentinel = sparsify
+            result_levels = sparsify_labels(result_levels, start=int(include_names), sentinel=sentinel)
+        return result_levels
+
+    def _get_names(self) -> FrozenList:
+        return FrozenList(self._names)
+
+    def _set_names(self, names, *, level=None) -> None:
+        if names is not None and (not is_list_like(names)):
+            raise ValueError('Names should be list-like for a MultiIndex')
+        names = list(names)
+        if level is not None and len(names) != len(level):
+            raise ValueError('Length of names must match length of level.')
+        if level is None and len(names) != self.nlevels:
+            raise ValueError('Length of names must match number of levels in MultiIndex.')
+        if level is None:
+            level = range(self.nlevels)
+        else:
+            level = (self._get_level_number(lev) for lev in level)
+        for (lev, name) in zip(level, names):
+            if name is not None:
+                if not is_hashable(name):
+                    raise TypeError(f'{type(self).__name__}.name must be a hashable type')
+            self._names[lev] = name
+        self._reset_cache('levels')
+    names = property(fset=_set_names, fget=_get_names, doc="\n        Names of levels in MultiIndex.\n\n        This attribute provides access to the names of the levels in a `MultiIndex`.\n        The names are stored as a `FrozenList`, which is an immutable list-like\n        container. Each name corresponds to a level in the `MultiIndex`, and can be\n        used to identify or manipulate the levels individually.\n\n        See Also\n        --------\n        MultiIndex.set_names : Set Index or MultiIndex name.\n        MultiIndex.rename : Rename specific levels in a MultiIndex.\n        Index.names : Get names on index.\n\n        Examples\n        --------\n        >>> mi = pd.MultiIndex.from_arrays(\n        ...     [[1, 2], [3, 4], [5, 6]], names=['x', 'y', 'z']\n        ... )\n        >>> mi\n        MultiIndex([(1, 3, 5),\n                    (2, 4, 6)],\n                   names=['x', 'y', 'z'])\n        >>> mi.names\n        FrozenList(['x', 'y', 'z'])\n        ")
+
+    @cache_readonly
+    def inferred_type(self) -> str:
+        return 'mixed'
+
+    def _get_level_number(self, level) -> int:
+        count = self.names.count(level)
+        if count > 1 and (not is_integer(level)):
+            raise ValueError(f'The name {level} occurs multiple times, use a level number')
+        try:
+            level = self.names.index(level)
+        except ValueError as err:
+            if not is_integer(level):
+                raise KeyError(f'Level {level} not found') from err
+            if level < 0:
+                level += self.nlevels
+                if level < 0:
+                    orig_level = level - self.nlevels
+                    raise IndexError(f'Too many levels: Index has only {self.nlevels} levels, {orig_level} is not a valid level number') from err
+            elif level >= self.nlevels:
+                raise IndexError(f'Too many levels: Index has only {self.nlevels} levels, not {level + 1}') from err
+        return level
+
+    @cache_readonly
+    def is_monotonic_increasing(self) -> bool:
+        if any((-1 in code for code in self.codes)):
+            return False
+        if all((level.is_monotonic_increasing for level in self.levels)):
+            return libalgos.is_lexsorted([x.astype('int64', copy=False) for x in self.codes])
+        values = [self._get_level_values(i)._values for i in reversed(range(len(self.levels)))]
+        try:
+            sort_order = np.lexsort(values)
+            return Index(sort_order).is_monotonic_increasing
+        except TypeError:
+            return Index(self._values).is_monotonic_increasing
+
+    @cache_readonly
+    def is_monotonic_decreasing(self) -> bool:
+        return self[::-1].is_monotonic_increasing
+
+    @doc(Index.duplicated)
+    def duplicated(self, keep: DropKeep='first') -> npt.NDArray[np.bool_]:
+        shape = tuple((len(lev) for lev in self.levels))
+        ids = get_group_index(self.codes, shape, sort=False, xnull=False)
+        return duplicated(ids, keep)
+    _duplicated = duplicated
+
+    def fillna(self, value):
+        raise NotImplementedError('isna is not defined for MultiIndex')
+
+    @doc(Index.dropna)
+    def dropna(self, how: AnyAll='any') -> MultiIndex:
+        nans = [level_codes == -1 for level_codes in self.codes]
+        if how == 'any':
+            indexer = np.any(nans, axis=0)
+        elif how == 'all':
+            indexer = np.all(nans, axis=0)
+        else:
+            raise ValueError(f'invalid how option: {how}')
+        new_codes = [level_codes[~indexer] for level_codes in self.codes]
+        return self.set_codes(codes=new_codes)
+
+    def _get_level_values(self, level: int, unique: bool=False) -> Index:
+        lev = self.levels[level]
+        level_codes = self.codes[level]
+        name = self._names[level]
+        if unique:
+            level_codes = algos.unique(level_codes)
+        filled = algos.take_nd(lev._values, level_codes, fill_value=lev._na_value)
+        return lev._shallow_copy(filled, name=name)
+
+    def get_level_values(self, level) -> Index:
+        level = self._get_level_number(level)
+        values = self._get_level_values(level)
+        return values
+
+    @doc(Index.unique)
+    def unique(self, level=None):
+        if level is None:
+            return self.drop_duplicates()
+        else:
+            level = self._get_level_number(level)
+            return self._get_level_values(level=level, unique=True)
+
+    def to_frame(self, index: bool=True, name=lib.no_default, allow_duplicates: bool=False) -> DataFrame:
+        from pandas import DataFrame
+        if name is not lib.no_default:
+            if not is_list_like(name):
+                raise TypeError("'name' must be a list / sequence of column names.")
+            if len(name) != len(self.levels):
+                raise ValueError("'name' should have same length as number of levels on index.")
+            idx_names = name
+        else:
+            idx_names = self._get_level_names()
+        if not allow_duplicates and len(set(idx_names)) != len(idx_names):
+            raise ValueError('Cannot create duplicate column labels if allow_duplicates is False')
+        result = DataFrame({level: self._get_level_values(level) for level in range(len(self.levels))}, copy=False)
+        result.columns = idx_names
+        if index:
+            result.index = self
+        return result
+
+    def to_flat_index(self) -> Index:
+        return Index(self._values, tupleize_cols=False)
+
+    def _is_lexsorted(self) -> bool:
+        return self._lexsort_depth == self.nlevels
+
+    @cache_readonly
+    def _lexsort_depth(self) -> int:
+        if self.sortorder is not None:
+            return self.sortorder
+        return _lexsort_depth(self.codes, self.nlevels)
+
+    def _sort_levels_monotonic(self, raise_if_incomparable: bool=False) -> MultiIndex:
+        if self._is_lexsorted() and self.is_monotonic_increasing:
+            return self
+        new_levels = []
+        new_codes = []
+        for (lev, level_codes) in zip(self.levels, self.codes):
+            if not lev.is_monotonic_increasing:
+                try:
+                    indexer = lev.argsort()
+                except TypeError:
+                    if raise_if_incomparable:
+                        raise
+                else:
+                    lev = lev.take(indexer)
+                    indexer = ensure_platform_int(indexer)
+                    ri = lib.get_reverse_indexer(indexer, len(indexer))
+                    level_codes = algos.take_nd(ri, level_codes, fill_value=-1)
+            new_levels.append(lev)
+            new_codes.append(level_codes)
+        return MultiIndex(new_levels, new_codes, names=self.names, sortorder=self.sortorder, verify_integrity=False)
+
+    def remove_unused_levels(self) -> MultiIndex:
+        new_levels = []
+        new_codes = []
+        changed = False
+        for (lev, level_codes) in zip(self.levels, self.codes):
+            uniques = np.where(np.bincount(level_codes + 1) > 0)[0] - 1
+            has_na = int(len(uniques) and uniques[0] == -1)
+            if len(uniques) != len(lev) + has_na:
+                if lev.isna().any() and len(uniques) == len(lev):
+                    break
+                changed = True
+                uniques = algos.unique(level_codes)
+                if has_na:
+                    na_idx = np.where(uniques == -1)[0]
+                    uniques[[0, na_idx[0]]] = uniques[[na_idx[0], 0]]
+                code_mapping = np.zeros(len(lev) + has_na)
+                code_mapping[uniques] = np.arange(len(uniques)) - has_na
+                level_codes = code_mapping[level_codes]
+                lev = lev.take(uniques[has_na:])
+            new_levels.append(lev)
+            new_codes.append(level_codes)
+        result = self.view()
+        if changed:
+            result._reset_identity()
+            result._set_levels(new_levels, validate=False)
+            result._set_codes(new_codes, validate=False)
+        return result
+
+    def __reduce__(self):
+        d = {'levels': list(self.levels), 'codes': list(self.codes), 'sortorder': self.sortorder, 'names': list(self.names)}
+        return (ibase._new_Index, (type(self), d), None)
+
+    def __getitem__(self, key):
+        if is_scalar(key):
+            key = com.cast_scalar_indexer(key)
+            retval = []
+            for (lev, level_codes) in zip(self.levels, self.codes):
+                if level_codes[key] == -1:
+                    retval.append(np.nan)
+                else:
+                    retval.append(lev[level_codes[key]])
+            return tuple(retval)
+        else:
+            sortorder = None
+            if com.is_bool_indexer(key):
+                key = np.asarray(key, dtype=bool)
+                sortorder = self.sortorder
+            elif isinstance(key, slice):
+                if key.step is None or key.step > 0:
+                    sortorder = self.sortorder
+            elif isinstance(key, Index):
+                key = np.asarray(key)
+            new_codes = [level_codes[key] for level_codes in self.codes]
+            return MultiIndex(levels=self.levels, codes=new_codes, names=self.names, sortorder=sortorder, verify_integrity=False)
+
+    def _getitem_slice(self: MultiIndex, slobj: slice) -> MultiIndex:
+        sortorder = None
+        if slobj.step is None or slobj.step > 0:
+            sortorder = self.sortorder
+        new_codes = [level_codes[slobj] for level_codes in self.codes]
+        return type(self)(levels=self.levels, codes=new_codes, names=self._names, sortorder=sortorder, verify_integrity=False)
+
+    @Appender(_index_shared_docs['take'] % _index_doc_kwargs)
+    def take(self: MultiIndex, indices, axis: Axis=0, allow_fill: bool=True, fill_value=None, **kwargs) -> MultiIndex:
+        nv.validate_take((), kwargs)
+        indices = ensure_platform_int(indices)
+        allow_fill = self._maybe_disallow_fill(allow_fill, fill_value, indices)
+        if indices.ndim == 1 and lib.is_range_indexer(indices, len(self)):
+            return self.copy()
+        na_value = -1
+        taken = [lab.take(indices) for lab in self.codes]
+        if allow_fill:
+            mask = indices == -1
+            if mask.any():
+                masked = []
+                for new_label in taken:
+                    label_values = new_label
+                    label_values[mask] = na_value
+                    masked.append(np.asarray(label_values))
+                taken = masked
+        return MultiIndex(levels=self.levels, codes=taken, names=self.names, verify_integrity=False)
+
+    def append(self, other):
+        if not isinstance(other, (list, tuple)):
+            other = [other]
+        if all((isinstance(o, MultiIndex) and o.nlevels >= self.nlevels for o in other)):
+            codes = []
+            levels = []
+            names = []
+            for i in range(self.nlevels):
+                level_values = self.levels[i]
+                for mi in other:
+                    level_values = level_values.union(mi.levels[i])
+                level_codes = [recode_for_categories(mi.codes[i], mi.levels[i], level_values, copy=False) for mi in [self, *other]]
+                level_name = self.names[i]
+                if any((mi.names[i] != level_name for mi in other)):
+                    level_name = None
+                codes.append(np.concatenate(level_codes))
+                levels.append(level_values)
+                names.append(level_name)
+            return MultiIndex(codes=codes, levels=levels, names=names, verify_integrity=False)
+        to_concat = (self._values,) + tuple((k._values for k in other))
+        new_tuples = np.concatenate(to_concat)
+        try:
+            return MultiIndex.from_tuples(new_tuples)
+        except (TypeError, IndexError):
+            return Index(new_tuples)
+
+    def argsort(self, *args, na_position: str='last', **kwargs) -> npt.NDArray[np.intp]:
+        target = self._sort_levels_monotonic(raise_if_incomparable=True)
+        keys = [lev.codes for lev in target._get_codes_for_sorting()]
+        return lexsort_indexer(keys, na_position=na_position, codes_given=True)
+
+    @Appender(_index_shared_docs['repeat'] % _index_doc_kwargs)
+    def repeat(self, repeats: int, axis=None) -> MultiIndex:
+        nv.validate_repeat((), {'axis': axis})
+        repeats = ensure_platform_int(repeats)
+        return MultiIndex(levels=self.levels, codes=[level_codes.view(np.ndarray).astype(np.intp, copy=False).repeat(repeats) for level_codes in self.codes], names=self.names, sortorder=self.sortorder, verify_integrity=False)
+
+    def drop(self, codes, level: Index | np.ndarray | Iterable[Hashable] | None=None, errors: IgnoreRaise='raise') -> MultiIndex:
+        if level is not None:
+            return self._drop_from_level(codes, level, errors)
+        if not isinstance(codes, (np.ndarray, Index)):
+            try:
+                codes = com.index_labels_to_array(codes, dtype=np.dtype('object'))
+            except ValueError:
+                pass
+        inds = []
+        for level_codes in codes:
+            try:
+                loc = self.get_loc(level_codes)
+                if isinstance(loc, int):
+                    inds.append(loc)
+                elif isinstance(loc, slice):
+                    step = loc.step if loc.step is not None else 1
+                    inds.extend(range(loc.start, loc.stop, step))
+                elif com.is_bool_indexer(loc):
+                    if get_option('performance_warnings') and self._lexsort_depth == 0:
+                        warnings.warn('dropping on a non-lexsorted multi-index without a level parameter may impact performance.', PerformanceWarning, stacklevel=find_stack_level())
+                    loc = loc.nonzero()[0]
+                    inds.extend(loc)
+                else:
+                    msg = f'unsupported indexer of type {type(loc)}'
+                    raise AssertionError(msg)
+            except KeyError:
+                if errors != 'ignore':
+                    raise
+        return self.delete(inds)
+
+    def _drop_from_level(self, codes, level, errors: IgnoreRaise='raise') -> MultiIndex:
+        codes = com.index_labels_to_array(codes)
+        i = self._get_level_number(level)
+        index = self.levels[i]
+        values = index.get_indexer(codes)
+        nan_codes = isna(codes)
+        values[np.equal(nan_codes, False) & (values == -1)] = -2
+        if index.shape[0] == self.shape[0]:
+            values[np.equal(nan_codes, True)] = -2
+        not_found = codes[values == -2]
+        if len(not_found) != 0 and errors != 'ignore':
+            raise KeyError(f'labels {not_found} not found in level')
+        mask = ~algos.isin(self.codes[i], values)
+        return self[mask]
+
+    def swaplevel(self, i=-2, j=-1) -> MultiIndex:
+        new_levels = list(self.levels)
+        new_codes = list(self.codes)
+        new_names = list(self.names)
+        i = self._get_level_number(i)
+        j = self._get_level_number(j)
+        (new_levels[i], new_levels[j]) = (new_levels[j], new_levels[i])
+        (new_codes[i], new_codes[j]) = (new_codes[j], new_codes[i])
+        (new_names[i], new_names[j]) = (new_names[j], new_names[i])
+        return MultiIndex(levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False)
+
+    def reorder_levels(self, order) -> MultiIndex:
+        order = [self._get_level_number(i) for i in order]
+        result = self._reorder_ilevels(order)
+        return result
+
+    def _reorder_ilevels(self, order) -> MultiIndex:
+        if len(order) != self.nlevels:
+            raise AssertionError(f'Length of order must be same as number of levels ({self.nlevels}), got {len(order)}')
+        new_levels = [self.levels[i] for i in order]
+        new_codes = [self.codes[i] for i in order]
+        new_names = [self.names[i] for i in order]
+        return MultiIndex(levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False)
+
+    def _recode_for_new_levels(self, new_levels, copy: bool=True) -> Generator[np.ndarray, None, None]:
+        if len(new_levels) > self.nlevels:
+            raise AssertionError(f'Length of new_levels ({len(new_levels)}) must be <= self.nlevels ({self.nlevels})')
+        for i in range(len(new_levels)):
+            yield recode_for_categories(self.codes[i], self.levels[i], new_levels[i], copy=copy)
+
+    def _get_codes_for_sorting(self) -> list[Categorical]:
+
+        def cats(level_codes: np.ndarray) -> np.ndarray:
+            return np.arange(level_codes.max() + 1 if len(level_codes) else 0, dtype=level_codes.dtype)
+        return [Categorical.from_codes(level_codes, cats(level_codes), True, validate=False) for level_codes in self.codes]
+
+    def sortlevel(self, level: IndexLabel=0, ascending: bool | list[bool]=True, sort_remaining: bool=True, na_position: str='first') -> tuple[MultiIndex, npt.NDArray[np.intp]]:
+        if not is_list_like(level):
+            level = [level]
+        level = [self._get_level_number(lev) for lev in level]
+        sortorder = None
+        codes = [self.codes[lev] for lev in level]
+        if isinstance(ascending, list):
+            if not len(level) == len(ascending):
+                raise ValueError('level must have same length as ascending')
+        elif sort_remaining:
+            codes.extend([self.codes[lev] for lev in range(len(self.levels)) if lev not in level])
+        else:
+            sortorder = level[0]
+        indexer = lexsort_indexer(codes, orders=ascending, na_position=na_position, codes_given=True)
+        indexer = ensure_platform_int(indexer)
+        new_codes = [level_codes.take(indexer) for level_codes in self.codes]
+        new_index = MultiIndex(codes=new_codes, levels=self.levels, names=self.names, sortorder=sortorder, verify_integrity=False)
+        return (new_index, indexer)
+
+    def _wrap_reindex_result(self, target, indexer, preserve_names: bool):
+        if not isinstance(target, MultiIndex):
+            if indexer is None:
+                target = self
+            elif (indexer >= 0).all():
+                target = self.take(indexer)
+            else:
+                try:
+                    target = MultiIndex.from_tuples(target)
+                except TypeError:
+                    return target
+        target = self._maybe_preserve_names(target, preserve_names)
+        return target
+
+    def _maybe_preserve_names(self, target: IndexT, preserve_names: bool) -> IndexT:
+        if preserve_names and target.nlevels == self.nlevels and (target.names != self.names):
+            target = target.copy(deep=False)
+            target.names = self.names
+        return target
+
+    def _check_indexing_error(self, key) -> None:
+        if not is_hashable(key) or is_iterator(key):
+            raise InvalidIndexError(key)
+
+    @cache_readonly
+    def _should_fallback_to_positional(self) -> bool:
+        return self.levels[0]._should_fallback_to_positional
+
+    def _get_indexer_strict(self, key, axis_name: str) -> tuple[Index, npt.NDArray[np.intp]]:
+        keyarr = key
+        if not isinstance(keyarr, Index):
+            keyarr = com.asarray_tuplesafe(keyarr)
+        if len(keyarr) and (not isinstance(keyarr[0], tuple)):
+            indexer = self._get_indexer_level_0(keyarr)
+            self._raise_if_missing(key, indexer, axis_name)
+            return (self[indexer], indexer)
+        return super()._get_indexer_strict(key, axis_name)
+
+    def _raise_if_missing(self, key, indexer, axis_name: str) -> None:
+        keyarr = key
+        if not isinstance(key, Index):
+            keyarr = com.asarray_tuplesafe(key)
+        if len(keyarr) and (not isinstance(keyarr[0], tuple)):
+            mask = indexer == -1
+            if mask.any():
+                check = self.levels[0].get_indexer(keyarr)
+                cmask = check == -1
+                if cmask.any():
+                    raise KeyError(f'{keyarr[cmask]} not in index')
+                raise KeyError(f'{keyarr} not in index')
+        else:
+            return super()._raise_if_missing(key, indexer, axis_name)
+
+    def _get_indexer_level_0(self, target) -> npt.NDArray[np.intp]:
+        lev = self.levels[0]
+        codes = self._codes[0]
+        cat = Categorical.from_codes(codes=codes, categories=lev, validate=False)
+        ci = Index(cat)
+        return ci.get_indexer_for(target)
+
+    def get_slice_bound(self, label: Hashable | Sequence[Hashable], side: Literal['left', 'right']) -> int:
+        if not isinstance(label, tuple):
+            label = (label,)
+        return self._partial_tup_index(label, side=side)
+
+    def slice_locs(self, start=None, end=None, step=None) -> tuple[int, int]:
+        return super().slice_locs(start, end, step)
+
+    def _partial_tup_index(self, tup: tuple, side: Literal['left', 'right']='left'):
+        if len(tup) > self._lexsort_depth:
+            raise UnsortedIndexError(f'Key length ({len(tup)}) was greater than MultiIndex lexsort depth ({self._lexsort_depth})')
+        n = len(tup)
+        (start, end) = (0, len(self))
+        zipped = zip(tup, self.levels, self.codes)
+        for (k, (lab, lev, level_codes)) in enumerate(zipped):
+            section = level_codes[start:end]
+            loc: npt.NDArray[np.intp] | np.intp | int
+            if lab not in lev and (not isna(lab)):
+                try:
+                    loc = algos.searchsorted(lev, lab, side=side)
+                except TypeError as err:
+                    raise TypeError(f'Level type mismatch: {lab}') from err
+                if not is_integer(loc):
+                    raise TypeError(f'Level type mismatch: {lab}')
+                if side == 'right' and loc >= 0:
+                    loc -= 1
+                return start + algos.searchsorted(section, loc, side=side)
+            idx = self._get_loc_single_level_index(lev, lab)
+            if isinstance(idx, slice) and k < n - 1:
+                start = idx.start
+                end = idx.stop
+            elif k < n - 1:
+                end = start + algos.searchsorted(section, idx, side='right')
+                start = start + algos.searchsorted(section, idx, side='left')
+            elif isinstance(idx, slice):
+                idx = idx.start
+                return start + algos.searchsorted(section, idx, side=side)
+            else:
+                return start + algos.searchsorted(section, idx, side=side)
+
+    def _get_loc_single_level_index(self, level_index: Index, key: Hashable) -> int:
+        if is_scalar(key) and isna(key):
+            return -1
+        else:
+            return level_index.get_loc(key)
+
+    def get_loc(self, key):
+        self._check_indexing_error(key)
+
+        def _maybe_to_slice(loc):
+            if not isinstance(loc, np.ndarray) or loc.dtype != np.intp:
+                return loc
+            loc = lib.maybe_indices_to_slice(loc, len(self))
+            if isinstance(loc, slice):
+                return loc
+            mask = np.empty(len(self), dtype='bool')
+            mask.fill(False)
+            mask[loc] = True
+            return mask
+        if not isinstance(key, tuple):
+            loc = self._get_level_indexer(key, level=0)
+            return _maybe_to_slice(loc)
+        keylen = len(key)
+        if self.nlevels < keylen:
+            raise KeyError(f'Key length ({keylen}) exceeds index depth ({self.nlevels})')
+        if keylen == self.nlevels and self.is_unique:
+            try:
+                return self._engine.get_loc(key)
+            except KeyError as err:
+                raise KeyError(key) from err
+            except TypeError:
+                (loc, _) = self.get_loc_level(key, range(self.nlevels))
+                return loc
+        i = self._lexsort_depth
+        (lead_key, follow_key) = (key[:i], key[i:])
+        if not lead_key:
+            start = 0
+            stop = len(self)
+        else:
+            try:
+                (start, stop) = self.slice_locs(lead_key, lead_key)
+            except TypeError as err:
+                raise KeyError(key) from err
+        if start == stop:
+            raise KeyError(key)
+        if not follow_key:
+            return slice(start, stop)
+        if get_option('performance_warnings'):
+            warnings.warn('indexing past lexsort depth may impact performance.', PerformanceWarning, stacklevel=find_stack_level())
+        loc = np.arange(start, stop, dtype=np.intp)
+        for (i, k) in enumerate(follow_key, len(lead_key)):
+            mask = self.codes[i][loc] == self._get_loc_single_level_index(self.levels[i], k)
+            if not mask.all():
+                loc = loc[mask]
+            if not len(loc):
+                raise KeyError(key)
+        return _maybe_to_slice(loc) if len(loc) != stop - start else slice(start, stop)
+
+    def get_loc_level(self, key, level: IndexLabel=0, drop_level: bool=True):
+        if not isinstance(level, (range, list, tuple)):
+            level = self._get_level_number(level)
+        else:
+            level = [self._get_level_number(lev) for lev in level]
+        (loc, mi) = self._get_loc_level(key, level=level)
+        if not drop_level:
+            if lib.is_integer(loc):
+                mi = self[loc:loc + 1]
+            else:
+                mi = self[loc]
+        return (loc, mi)
+
+    def _get_loc_level(self, key, level: int | list[int]=0):
+
+        def maybe_mi_droplevels(indexer, levels):
+            new_index = self[indexer]
+            for i in sorted(levels, reverse=True):
+                new_index = new_index._drop_level_numbers([i])
+            return new_index
+        if isinstance(level, (tuple, list)):
+            if len(key) != len(level):
+                raise AssertionError('Key for location must have same length as number of levels')
+            result = None
+            for (lev, k) in zip(level, key):
+                (loc, new_index) = self._get_loc_level(k, level=lev)
+                if isinstance(loc, slice):
+                    mask = np.zeros(len(self), dtype=bool)
+                    mask[loc] = True
+                    loc = mask
+                result = loc if result is None else result & loc
+            try:
+                mi = maybe_mi_droplevels(result, level)
+            except ValueError:
+                mi = self[result]
+            return (result, mi)
+        if isinstance(key, list):
+            key = tuple(key)
+        if isinstance(key, tuple) and level == 0:
+            try:
+                if key in self.levels[0]:
+                    indexer = self._get_level_indexer(key, level=level)
+                    new_index = maybe_mi_droplevels(indexer, [0])
+                    return (indexer, new_index)
+            except (TypeError, InvalidIndexError):
+                pass
+            if not any((isinstance(k, slice) for k in key)):
+                if len(key) == self.nlevels and self.is_unique:
+                    try:
+                        return (self._engine.get_loc(key), None)
+                    except KeyError as err:
+                        raise KeyError(key) from err
+                    except TypeError:
+                        pass
+                indexer = self.get_loc(key)
+                ilevels = [i for i in range(len(key)) if key[i] != slice(None, None)]
+                if len(ilevels) == self.nlevels:
+                    if is_integer(indexer):
+                        return (indexer, None)
+                    ilevels = [i for i in range(len(key)) if (not isinstance(key[i], str) or not self.levels[i]._supports_partial_string_indexing) and key[i] != slice(None, None)]
+                    if len(ilevels) == self.nlevels:
+                        ilevels = []
+                return (indexer, maybe_mi_droplevels(indexer, ilevels))
+            else:
+                indexer = None
+                for (i, k) in enumerate(key):
+                    if not isinstance(k, slice):
+                        loc_level = self._get_level_indexer(k, level=i)
+                        if isinstance(loc_level, slice):
+                            if com.is_null_slice(loc_level) or com.is_full_slice(loc_level, len(self)):
+                                continue
+                            k_index = np.zeros(len(self), dtype=bool)
+                            k_index[loc_level] = True
+                        else:
+                            k_index = loc_level
+                    elif com.is_null_slice(k):
+                        continue
+                    else:
+                        raise TypeError(f'Expected label or tuple of labels, got {key}')
+                    if indexer is None:
+                        indexer = k_index
+                    else:
+                        indexer &= k_index
+                if indexer is None:
+                    indexer = slice(None, None)
+                ilevels = [i for i in range(len(key)) if key[i] != slice(None, None)]
+                return (indexer, maybe_mi_droplevels(indexer, ilevels))
+        else:
+            indexer = self._get_level_indexer(key, level=level)
+            if isinstance(key, str) and self.levels[level]._supports_partial_string_indexing:
+                check = self.levels[level].get_loc(key)
+                if not is_integer(check):
+                    return (indexer, self[indexer])
+            try:
+                result_index = maybe_mi_droplevels(indexer, [level])
+            except ValueError:
+                result_index = self[indexer]
+            return (indexer, result_index)
+
+    def _get_level_indexer(self, key, level: int=0, indexer: npt.NDArray[np.bool_] | None=None):
+        level_index = self.levels[level]
+        level_codes = self.codes[level]
+
+        def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
+            if indexer is not None:
+                codes = codes[indexer]
+            if step is None or step == 1:
+                new_indexer = (codes >= start) & (codes < stop)
+            else:
+                r = np.arange(start, stop, step, dtype=codes.dtype)
+                new_indexer = algos.isin(codes, r)
+            if indexer is None:
+                return new_indexer
+            indexer = indexer.copy()
+            indexer[indexer] = new_indexer
+            return indexer
+        if isinstance(key, slice):
+            step = key.step
+            is_negative_step = step is not None and step < 0
+            try:
+                if key.start is not None:
+                    start = level_index.get_loc(key.start)
+                elif is_negative_step:
+                    start = len(level_index) - 1
+                else:
+                    start = 0
+                if key.stop is not None:
+                    stop = level_index.get_loc(key.stop)
+                elif is_negative_step:
+                    stop = 0
+                elif isinstance(start, slice):
+                    stop = len(level_index)
+                else:
+                    stop = len(level_index) - 1
+            except KeyError:
+                start = stop = level_index.slice_indexer(key.start, key.stop, key.step)
+                step = start.step
+            if isinstance(start, slice) or isinstance(stop, slice):
+                start = getattr(start, 'start', start)
+                stop = getattr(stop, 'stop', stop)
+                return convert_indexer(start, stop, step)
+            elif level > 0 or self._lexsort_depth == 0 or step is not None:
+                stop = stop - 1 if is_negative_step else stop + 1
+                return convert_indexer(start, stop, step)
+            else:
+                i = algos.searchsorted(level_codes, start, side='left')
+                j = algos.searchsorted(level_codes, stop, side='right')
+                return slice(i, j, step)
+        else:
+            idx = self._get_loc_single_level_index(level_index, key)
+            if level > 0 or self._lexsort_depth == 0:
+                if isinstance(idx, slice):
+                    locs = (level_codes >= idx.start) & (level_codes < idx.stop)
+                    return locs
+                locs = np.asarray(level_codes == idx, dtype=bool)
+                if not locs.any():
+                    raise KeyError(key)
+                return locs
+            if isinstance(idx, slice):
+                start = algos.searchsorted(level_codes, idx.start, side='left')
+                end = algos.searchsorted(level_codes, idx.stop, side='left')
+            else:
+                start = algos.searchsorted(level_codes, idx, side='left')
+                end = algos.searchsorted(level_codes, idx, side='right')
+            if start == end:
+                raise KeyError(key)
+            return slice(start, end)
+
+    def get_locs(self, seq) -> npt.NDArray[np.intp]:
+        true_slices = [i for (i, s) in enumerate(com.is_true_slices(seq)) if s]
+        if true_slices and true_slices[-1] >= self._lexsort_depth:
+            raise UnsortedIndexError(f'MultiIndex slicing requires the index to be lexsorted: slicing on levels {true_slices}, lexsort depth {self._lexsort_depth}')
+        if any((x is Ellipsis for x in seq)):
+            raise NotImplementedError('MultiIndex does not support indexing with Ellipsis')
+        n = len(self)
+
+        def _to_bool_indexer(indexer) -> npt.NDArray[np.bool_]:
+            if isinstance(indexer, slice):
+                new_indexer = np.zeros(n, dtype=np.bool_)
+                new_indexer[indexer] = True
+                return new_indexer
+            return indexer
+        indexer: npt.NDArray[np.bool_] | None = None
+        for (i, k) in enumerate(seq):
+            lvl_indexer: npt.NDArray[np.bool_] | slice | None = None
+            if com.is_bool_indexer(k):
+                if len(k) != n:
+                    raise ValueError('cannot index with a boolean indexer that is not the same length as the index')
+                if isinstance(k, (ABCSeries, Index)):
+                    k = k._values
+                lvl_indexer = np.asarray(k)
+                if indexer is None:
+                    lvl_indexer = lvl_indexer.copy()
+            elif is_list_like(k):
+                try:
+                    lvl_indexer = self._get_level_indexer(k, level=i, indexer=indexer)
+                except (InvalidIndexError, TypeError, KeyError) as err:
+                    for x in k:
+                        if not is_hashable(x):
+                            raise err
+                        item_indexer = self._get_level_indexer(x, level=i, indexer=indexer)
+                        if lvl_indexer is None:
+                            lvl_indexer = _to_bool_indexer(item_indexer)
+                        elif isinstance(item_indexer, slice):
+                            lvl_indexer[item_indexer] = True
+                        else:
+                            lvl_indexer |= item_indexer
+                if lvl_indexer is None:
+                    return np.array([], dtype=np.intp)
+            elif com.is_null_slice(k):
+                if indexer is None and i == len(seq) - 1:
+                    return np.arange(n, dtype=np.intp)
+                continue
+            else:
+                lvl_indexer = self._get_level_indexer(k, level=i, indexer=indexer)
+            lvl_indexer = _to_bool_indexer(lvl_indexer)
+            if indexer is None:
+                indexer = lvl_indexer
+            else:
+                indexer &= lvl_indexer
+                if not np.any(indexer) and np.any(lvl_indexer):
+                    raise KeyError(seq)
+        if indexer is None:
+            return np.array([], dtype=np.intp)
+        pos_indexer = indexer.nonzero()[0]
+        return self._reorder_indexer(seq, pos_indexer)
+
+    def _reorder_indexer(self, seq: tuple[Scalar | Iterable | AnyArrayLike, ...], indexer: npt.NDArray[np.intp]) -> npt.NDArray[np.intp]:
+        need_sort = False
+        for (i, k) in enumerate(seq):
+            if com.is_null_slice(k) or com.is_bool_indexer(k) or is_scalar(k):
+                pass
+            elif is_list_like(k):
+                if len(k) <= 1:
+                    pass
+                elif self._is_lexsorted():
+                    k_codes = self.levels[i].get_indexer(k)
+                    k_codes = k_codes[k_codes >= 0]
+                    need_sort = (k_codes[:-1] > k_codes[1:]).any()
+                else:
+                    need_sort = True
+            elif isinstance(k, slice):
+                if self._is_lexsorted():
+                    need_sort = k.step is not None and k.step < 0
+                else:
+                    need_sort = True
+            else:
+                need_sort = True
+            if need_sort:
+                break
+        if not need_sort:
+            return indexer
+        n = len(self)
+        keys: tuple[np.ndarray, ...] = ()
+        for (i, k) in enumerate(seq):
+            if is_scalar(k):
+                k = [k]
+            if com.is_bool_indexer(k):
+                new_order = np.arange(n)[indexer]
+            elif is_list_like(k):
+                if not isinstance(k, (np.ndarray, ExtensionArray, Index, ABCSeries)):
+                    k = sanitize_array(k, None)
+                k = algos.unique(k)
+                key_order_map = np.ones(len(self.levels[i]), dtype=np.uint64) * len(self.levels[i])
+                level_indexer = self.levels[i].get_indexer(k)
+                level_indexer = level_indexer[level_indexer >= 0]
+                key_order_map[level_indexer] = np.arange(len(level_indexer))
+                new_order = key_order_map[self.codes[i][indexer]]
+            elif isinstance(k, slice) and k.step is not None and (k.step < 0):
+                new_order = np.arange(n - 1, -1, -1)[indexer]
+            elif isinstance(k, slice) and k.start is None and (k.stop is None):
+                new_order = np.ones((n,), dtype=np.intp)[indexer]
+            else:
+                new_order = np.arange(n)[indexer]
+            keys = (new_order,) + keys
+        ind = np.lexsort(keys)
+        return indexer[ind]
+
+    def truncate(self, before=None, after=None) -> MultiIndex:
+        if after and before and (after < before):
+            raise ValueError('after < before')
+        (i, j) = self.levels[0].slice_locs(before, after)
+        (left, right) = self.slice_locs(before, after)
+        new_levels = list(self.levels)
+        new_levels[0] = new_levels[0][i:j]
+        new_codes = [level_codes[left:right] for level_codes in self.codes]
+        new_codes[0] = new_codes[0] - i
+        return MultiIndex(levels=new_levels, codes=new_codes, names=self._names, verify_integrity=False)
+
+    def equals(self, other: object) -> bool:
+        if self.is_(other):
+            return True
+        if not isinstance(other, Index):
+            return False
+        if len(self) != len(other):
+            return False
+        if not isinstance(other, MultiIndex):
+            if not self._should_compare(other):
+                return False
+            return array_equivalent(self._values, other._values)
+        if self.nlevels != other.nlevels:
+            return False
+        for i in range(self.nlevels):
+            self_codes = self.codes[i]
+            other_codes = other.codes[i]
+            self_mask = self_codes == -1
+            other_mask = other_codes == -1
+            if not np.array_equal(self_mask, other_mask):
+                return False
+            self_level = self.levels[i]
+            other_level = other.levels[i]
+            new_codes = recode_for_categories(other_codes, other_level, self_level, copy=False)
+            if not np.array_equal(self_codes, new_codes):
+                return False
+            if not self_level[:0].equals(other_level[:0]):
+                return False
+        return True
+
+    def equal_levels(self, other: MultiIndex) -> bool:
+        if self.nlevels != other.nlevels:
+            return False
+        for i in range(self.nlevels):
+            if not self.levels[i].equals(other.levels[i]):
+                return False
+        return True
+
+    def _union(self, other, sort) -> MultiIndex:
+        (other, result_names) = self._convert_can_do_setop(other)
+        if other.has_duplicates:
+            result = super()._union(other, sort)
+            if isinstance(result, MultiIndex):
+                return result
+            return MultiIndex.from_arrays(zip(*result), sortorder=None, names=result_names)
+        else:
+            right_missing = other.difference(self, sort=False)
+            if len(right_missing):
+                result = self.append(right_missing)
+            else:
+                result = self._get_reconciled_name_object(other)
+            if sort is not False:
+                try:
+                    result = result.sort_values()
+                except TypeError:
+                    if sort is True:
+                        raise
+                    warnings.warn('The values in the array are unorderable. Pass `sort=False` to suppress this warning.', RuntimeWarning, stacklevel=find_stack_level())
+            return result
+
+    def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
+        return is_object_dtype(dtype)
+
+    def _get_reconciled_name_object(self, other) -> MultiIndex:
+        names = self._maybe_match_names(other)
+        if self.names != names:
+            return self.rename(names)
+        return self
+
+    def _maybe_match_names(self, other):
+        if len(self.names) != len(other.names):
+            return [None] * len(self.names)
+        names = []
+        for (a_name, b_name) in zip(self.names, other.names):
+            if a_name == b_name:
+                names.append(a_name)
+            else:
+                names.append(None)
+        return names
+
+    def _wrap_intersection_result(self, other, result) -> MultiIndex:
+        (_, result_names) = self._convert_can_do_setop(other)
+        return result.set_names(result_names)
+
+    def _wrap_difference_result(self, other, result: MultiIndex) -> MultiIndex:
+        (_, result_names) = self._convert_can_do_setop(other)
+        if len(result) == 0:
+            return result.remove_unused_levels().set_names(result_names)
+        else:
+            return result.set_names(result_names)
+
+    def _convert_can_do_setop(self, other):
+        result_names = self.names
+        if not isinstance(other, Index):
+            if len(other) == 0:
+                return (self[:0], self.names)
+            else:
+                msg = 'other must be a MultiIndex or a list of tuples'
+                try:
+                    other = MultiIndex.from_tuples(other, names=self.names)
+                except (ValueError, TypeError) as err:
+                    raise TypeError(msg) from err
+        else:
+            result_names = get_unanimous_names(self, other)
+        return (other, result_names)
+
+    @doc(Index.astype)
+    def astype(self, dtype, copy: bool=True):
+        dtype = pandas_dtype(dtype)
+        if isinstance(dtype, CategoricalDtype):
+            msg = '> 1 ndim Categorical are not supported at this time'
+            raise NotImplementedError(msg)
+        if not is_object_dtype(dtype):
+            raise TypeError('Setting a MultiIndex dtype to anything other than object is not supported')
+        if copy is True:
+            return self._view()
+        return self
+
+    def _validate_fill_value(self, item):
+        if isinstance(item, MultiIndex):
+            if item.nlevels != self.nlevels:
+                raise ValueError('Item must have length equal to number of levels.')
+            return item._values
+        elif not isinstance(item, tuple):
+            item = (item,) + ('',) * (self.nlevels - 1)
+        elif len(item) != self.nlevels:
+            raise ValueError('Item must have length equal to number of levels.')
+        return item
+
+    def putmask(self, mask, value: MultiIndex) -> MultiIndex:
+        (mask, noop) = validate_putmask(self, mask)
+        if noop:
+            return self.copy()
+        if len(mask) == len(value):
+            subset = value[mask].remove_unused_levels()
+        else:
+            subset = value.remove_unused_levels()
+        new_levels = []
+        new_codes = []
+        for (i, (value_level, level, level_codes)) in enumerate(zip(subset.levels, self.levels, self.codes)):
+            new_level = level.union(value_level, sort=False)
+            value_codes = new_level.get_indexer_for(subset.get_level_values(i))
+            new_code = ensure_int64(level_codes)
+            new_code[mask] = value_codes
+            new_levels.append(new_level)
+            new_codes.append(new_code)
+        return MultiIndex(levels=new_levels, codes=new_codes, names=self.names, verify_integrity=False)
+
+    def insert(self, loc: int, item) -> MultiIndex:
+        item = self._validate_fill_value(item)
+        new_levels = []
+        new_codes = []
+        for (k, level, level_codes) in zip(item, self.levels, self.codes):
+            if k not in level:
+                if isna(k):
+                    lev_loc = -1
+                else:
+                    lev_loc = len(level)
+                    level = level.insert(lev_loc, k)
+            else:
+                lev_loc = level.get_loc(k)
+            new_levels.append(level)
+            new_codes.append(np.insert(ensure_int64(level_codes), loc, lev_loc))
+        return MultiIndex(levels=new_levels, codes=new_codes, names=self.names, verify_integrity=False)
+
+    def delete(self, loc) -> MultiIndex:
+        new_codes = [np.delete(level_codes, loc) for level_codes in self.codes]
+        return MultiIndex(levels=self.levels, codes=new_codes, names=self.names, verify_integrity=False)
+
+    @doc(Index.isin)
+    def isin(self, values, level=None) -> npt.NDArray[np.bool_]:
+        if isinstance(values, Generator):
+            values = list(values)
+        if level is None:
+            if len(values) == 0:
+                return np.zeros((len(self),), dtype=np.bool_)
+            if not isinstance(values, MultiIndex):
+                values = MultiIndex.from_tuples(values)
+            return values.unique().get_indexer_for(self) != -1
+        else:
+            num = self._get_level_number(level)
+            levs = self.get_level_values(num)
+            if levs.size == 0:
+                return np.zeros(len(levs), dtype=np.bool_)
+            return levs.isin(values)
+    rename = Index.set_names
+    __add__ = make_invalid_op('__add__')
+    __radd__ = make_invalid_op('__radd__')
+    __iadd__ = make_invalid_op('__iadd__')
+    __sub__ = make_invalid_op('__sub__')
+    __rsub__ = make_invalid_op('__rsub__')
+    __isub__ = make_invalid_op('__isub__')
+    __pow__ = make_invalid_op('__pow__')
+    __rpow__ = make_invalid_op('__rpow__')
+    __mul__ = make_invalid_op('__mul__')
+    __rmul__ = make_invalid_op('__rmul__')
+    __floordiv__ = make_invalid_op('__floordiv__')
+    __rfloordiv__ = make_invalid_op('__rfloordiv__')
+    __truediv__ = make_invalid_op('__truediv__')
+    __rtruediv__ = make_invalid_op('__rtruediv__')
+    __mod__ = make_invalid_op('__mod__')
+    __rmod__ = make_invalid_op('__rmod__')
+    __divmod__ = make_invalid_op('__divmod__')
+    __rdivmod__ = make_invalid_op('__rdivmod__')
+    __neg__ = make_invalid_op('__neg__')
+    __pos__ = make_invalid_op('__pos__')
+    __abs__ = make_invalid_op('__abs__')
+    __invert__ = make_invalid_op('__invert__')
+
+def _lexsort_depth(codes: list[np.ndarray], nlevels: int) -> int:
+    int64_codes = [ensure_int64(level_codes) for level_codes in codes]
+    for k in range(nlevels, 0, -1):
+        if libalgos.is_lexsorted(int64_codes[:k]):
+            return k
+    return 0
+
+def sparsify_labels(label_list, start: int=0, sentinel: object=''):
+    pivoted = list(zip(*label_list))
+    k = len(label_list)
+    result = pivoted[:start + 1]
+    prev = pivoted[start]
+    for cur in pivoted[start + 1:]:
+        sparse_cur = []
+        for (i, (p, t)) in enumerate(zip(prev, cur)):
+            if i == k - 1:
+                sparse_cur.append(t)
+                result.append(sparse_cur)
+                break
+            if p == t:
+                sparse_cur.append(sentinel)
+            else:
+                sparse_cur.extend(cur[i:])
+                result.append(sparse_cur)
+                break
+        prev = cur
+    return list(zip(*result))
+
+def _get_na_rep(dtype: DtypeObj) -> str:
+    if isinstance(dtype, ExtensionDtype):
+        return f'{dtype.na_value}'
+    else:
+        dtype_type = dtype.type
+    return {np.datetime64: 'NaT', np.timedelta64: 'NaT'}.get(dtype_type, 'NaN')
+
+def maybe_droplevels(index: Index, key) -> Index:
+    original_index = index
+    if isinstance(key, tuple):
+        for _ in key:
+            try:
+                index = index._drop_level_numbers([0])
+            except ValueError:
+                return original_index
+    else:
+        try:
+            index = index._drop_level_numbers([0])
+        except ValueError:
+            pass
+    return index
+
+def _coerce_indexer_frozen(array_like, categories, copy: bool=False) -> np.ndarray:
+    array_like = coerce_indexer_dtype(array_like, categories)
+    if copy:
+        array_like = array_like.copy()
+    array_like.flags.writeable = False
+    return array_like
+
+def _require_listlike(level, arr, arrname: str):
+    if level is not None and (not is_list_like(level)):
+        if not is_list_like(arr):
+            raise TypeError(f'{arrname} must be list-like')
+        if len(arr) > 0 and is_list_like(arr[0]):
+            raise TypeError(f'{arrname} must be list-like')
+        level = [level]
+        arr = [arr]
+    elif level is None or is_list_like(level):
+        if not is_list_like(arr) or not is_list_like(arr[0]):
+            raise TypeError(f'{arrname} must be list of lists-like')
+    return (level, arr)
+
+def cartesian_product(X: list[np.ndarray]) -> list[np.ndarray]:
+    msg = 'Input must be a list-like of list-likes'
+    if not is_list_like(X):
+        raise TypeError(msg)
+    for x in X:
+        if not is_list_like(x):
+            raise TypeError(msg)
+    if len(X) == 0:
+        return []
+    lenX = np.fromiter((len(x) for x in X), dtype=np.intp)
+    cumprodX = np.cumprod(lenX)
+    if np.any(cumprodX < 0):
+        raise ValueError('Product space too large to allocate arrays!')
+    a = np.roll(cumprodX, 1)
+    a[0] = 1
+    if cumprodX[-1] != 0:
+        b = cumprodX[-1] / cumprodX
+    else:
+        b = np.zeros_like(cumprodX)
+    return [np.tile(np.repeat(x, b[i]), np.prod(a[i])) for (i, x) in enumerate(X)]
+
+# File: pandas-main/pandas/core/indexes/period.py
+from __future__ import annotations
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs import index as libindex
+from pandas._libs.tslibs import BaseOffset, NaT, Period, Resolution, Tick
+from pandas._libs.tslibs.dtypes import OFFSET_TO_PERIOD_FREQSTR
+from pandas.util._decorators import cache_readonly, doc
+from pandas.core.dtypes.common import is_integer
+from pandas.core.dtypes.dtypes import PeriodDtype
+from pandas.core.dtypes.generic import ABCSeries
+from pandas.core.dtypes.missing import is_valid_na_for_dtype
+from pandas.core.arrays.period import PeriodArray, period_array, raise_on_incompatible, validate_dtype_freq
+import pandas.core.common as com
+import pandas.core.indexes.base as ibase
+from pandas.core.indexes.base import maybe_extract_name
+from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
+from pandas.core.indexes.datetimes import DatetimeIndex, Index
+from pandas.core.indexes.extension import inherit_names
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+    from pandas._typing import Dtype, DtypeObj, Self, npt
+_index_doc_kwargs = dict(ibase._index_doc_kwargs)
+_index_doc_kwargs.update({'target_klass': 'PeriodIndex or list of Periods'})
+_shared_doc_kwargs = {'klass': 'PeriodArray'}
+
+def _new_PeriodIndex(cls, **d):
+    values = d.pop('data')
+    if values.dtype == 'int64':
+        freq = d.pop('freq', None)
+        dtype = PeriodDtype(freq)
+        values = PeriodArray(values, dtype=dtype)
+        return cls._simple_new(values, **d)
+    else:
+        return cls(values, **d)
+
+@inherit_names(['strftime', 'start_time', 'end_time'] + PeriodArray._field_ops, PeriodArray, wrap=True)
+@inherit_names(['is_leap_year'], PeriodArray)
+class PeriodIndex(DatetimeIndexOpsMixin):
+    _typ = 'periodindex'
+    _data: PeriodArray
+    freq: BaseOffset
+    dtype: PeriodDtype
+    _data_cls = PeriodArray
+    _supports_partial_string_indexing = True
+
+    @property
+    def _engine_type(self) -> type[libindex.PeriodEngine]:
+        return libindex.PeriodEngine
+
+    @cache_readonly
+    def _resolution_obj(self) -> Resolution:
+        return self.dtype._resolution_obj
+
+    @doc(PeriodArray.asfreq, other='arrays.PeriodArray', other_name='PeriodArray', **_shared_doc_kwargs)
+    def asfreq(self, freq=None, how: str='E') -> Self:
+        arr = self._data.asfreq(freq, how)
+        return type(self)._simple_new(arr, name=self.name)
+
+    @doc(PeriodArray.to_timestamp)
+    def to_timestamp(self, freq=None, how: str='start') -> DatetimeIndex:
+        arr = self._data.to_timestamp(freq, how)
+        return DatetimeIndex._simple_new(arr, name=self.name)
+
+    @property
+    @doc(PeriodArray.hour.fget)
+    def hour(self) -> Index:
+        return Index(self._data.hour, name=self.name)
+
+    @property
+    @doc(PeriodArray.minute.fget)
+    def minute(self) -> Index:
+        return Index(self._data.minute, name=self.name)
+
+    @property
+    @doc(PeriodArray.second.fget)
+    def second(self) -> Index:
+        return Index(self._data.second, name=self.name)
+
+    def __new__(cls, data=None, freq=None, dtype: Dtype | None=None, copy: bool=False, name: Hashable | None=None) -> Self:
+        refs = None
+        if not copy and isinstance(data, (Index, ABCSeries)):
+            refs = data._references
+        name = maybe_extract_name(name, data, cls)
+        freq = validate_dtype_freq(dtype, freq)
+        if freq and isinstance(data, cls) and (data.freq != freq):
+            data = data.asfreq(freq)
+        data = period_array(data=data, freq=freq)
+        if copy:
+            data = data.copy()
+        return cls._simple_new(data, name=name, refs=refs)
+
+    @classmethod
+    def from_fields(cls, *, year=None, quarter=None, month=None, day=None, hour=None, minute=None, second=None, freq=None) -> Self:
+        fields = {'year': year, 'quarter': quarter, 'month': month, 'day': day, 'hour': hour, 'minute': minute, 'second': second}
+        fields = {key: value for (key, value) in fields.items() if value is not None}
+        arr = PeriodArray._from_fields(fields=fields, freq=freq)
+        return cls._simple_new(arr)
+
+    @classmethod
+    def from_ordinals(cls, ordinals, *, freq, name=None) -> Self:
+        ordinals = np.asarray(ordinals, dtype=np.int64)
+        dtype = PeriodDtype(freq)
+        data = PeriodArray._simple_new(ordinals, dtype=dtype)
+        return cls._simple_new(data, name=name)
+
+    @property
+    def values(self) -> npt.NDArray[np.object_]:
+        return np.asarray(self, dtype=object)
+
+    def _maybe_convert_timedelta(self, other) -> int | npt.NDArray[np.int64]:
+        if isinstance(other, (timedelta, np.timedelta64, Tick, np.ndarray)):
+            if isinstance(self.freq, Tick):
+                delta = self._data._check_timedeltalike_freq_compat(other)
+                return delta
+        elif isinstance(other, BaseOffset):
+            if other.base == self.freq.base:
+                return other.n
+            raise raise_on_incompatible(self, other)
+        elif is_integer(other):
+            assert isinstance(other, int)
+            return other
+        raise raise_on_incompatible(self, None)
+
+    def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
+        return self.dtype == dtype
+
+    def asof_locs(self, where: Index, mask: npt.NDArray[np.bool_]) -> np.ndarray:
+        if isinstance(where, DatetimeIndex):
+            where = PeriodIndex(where._values, freq=self.freq)
+        elif not isinstance(where, PeriodIndex):
+            raise TypeError('asof_locs `where` must be DatetimeIndex or PeriodIndex')
+        return super().asof_locs(where, mask)
+
+    @property
+    def is_full(self) -> bool:
+        if len(self) == 0:
+            return True
+        if not self.is_monotonic_increasing:
+            raise ValueError('Index is not monotonic')
+        values = self.asi8
+        return bool((values[1:] - values[:-1] < 2).all())
+
+    @property
+    def inferred_type(self) -> str:
+        return 'period'
+
+    def _convert_tolerance(self, tolerance, target):
+        tolerance = super()._convert_tolerance(tolerance, target)
+        if self.dtype == target.dtype:
+            tolerance = self._maybe_convert_timedelta(tolerance)
+        return tolerance
+
+    def get_loc(self, key):
+        orig_key = key
+        self._check_indexing_error(key)
+        if is_valid_na_for_dtype(key, self.dtype):
+            key = NaT
+        elif isinstance(key, str):
+            try:
+                (parsed, reso) = self._parse_with_reso(key)
+            except ValueError as err:
+                raise KeyError(f"Cannot interpret '{key}' as period") from err
+            if self._can_partial_date_slice(reso):
+                try:
+                    return self._partial_date_slice(reso, parsed)
+                except KeyError as err:
+                    raise KeyError(key) from err
+            if reso == self._resolution_obj:
+                key = self._cast_partial_indexing_scalar(parsed)
+            else:
+                raise KeyError(key)
+        elif isinstance(key, Period):
+            self._disallow_mismatched_indexing(key)
+        elif isinstance(key, datetime):
+            key = self._cast_partial_indexing_scalar(key)
+        else:
+            raise KeyError(key)
+        try:
+            return Index.get_loc(self, key)
+        except KeyError as err:
+            raise KeyError(orig_key) from err
+
+    def _disallow_mismatched_indexing(self, key: Period) -> None:
+        if key._dtype != self.dtype:
+            raise KeyError(key)
+
+    def _cast_partial_indexing_scalar(self, label: datetime) -> Period:
+        try:
+            period = Period(label, freq=self.freq)
+        except ValueError as err:
+            raise KeyError(label) from err
+        return period
+
+    @doc(DatetimeIndexOpsMixin._maybe_cast_slice_bound)
+    def _maybe_cast_slice_bound(self, label, side: str):
+        if isinstance(label, datetime):
+            label = self._cast_partial_indexing_scalar(label)
+        return super()._maybe_cast_slice_bound(label, side)
+
+    def _parsed_string_to_bounds(self, reso: Resolution, parsed: datetime):
+        freq = OFFSET_TO_PERIOD_FREQSTR.get(reso.attr_abbrev, reso.attr_abbrev)
+        iv = Period(parsed, freq=freq)
+        return (iv.asfreq(self.freq, how='start'), iv.asfreq(self.freq, how='end'))
+
+    @doc(DatetimeIndexOpsMixin.shift)
+    def shift(self, periods: int=1, freq=None) -> Self:
+        if freq is not None:
+            raise TypeError(f'`freq` argument is not supported for {type(self).__name__}.shift')
+        return self + periods
+
+def period_range(start=None, end=None, periods: int | None=None, freq=None, name: Hashable | None=None) -> PeriodIndex:
+    if com.count_not_none(start, end, periods) != 2:
+        raise ValueError('Of the three parameters: start, end, and periods, exactly two must be specified')
+    if freq is None and (not isinstance(start, Period) and (not isinstance(end, Period))):
+        freq = 'D'
+    (data, freq) = PeriodArray._generate_range(start, end, periods, freq)
+    dtype = PeriodDtype(freq)
+    data = PeriodArray(data, dtype=dtype)
+    return PeriodIndex(data, name=name)
+
+# File: pandas-main/pandas/core/indexes/range.py
+from __future__ import annotations
+from collections.abc import Callable, Hashable, Iterator
+from datetime import timedelta
+import operator
+from sys import getsizeof
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
+import numpy as np
+from pandas._libs import index as libindex, lib
+from pandas._libs.lib import no_default
+from pandas.compat.numpy import function as nv
+from pandas.util._decorators import cache_readonly, doc
+from pandas.core.dtypes.base import ExtensionDtype
+from pandas.core.dtypes.common import ensure_platform_int, ensure_python_int, is_float, is_integer, is_scalar, is_signed_integer_dtype
+from pandas.core.dtypes.generic import ABCTimedeltaIndex
+from pandas.core import ops
+import pandas.core.common as com
+from pandas.core.construction import extract_array
+from pandas.core.indexers import check_array_indexer
+import pandas.core.indexes.base as ibase
+from pandas.core.indexes.base import Index, maybe_extract_name
+from pandas.core.ops.common import unpack_zerodim_and_defer
+if TYPE_CHECKING:
+    from pandas._typing import Axis, Dtype, JoinHow, NaPosition, NumpySorter, Self, npt
+    from pandas import Series
+_empty_range = range(0)
+_dtype_int64 = np.dtype(np.int64)
+
+def min_fitting_element(start: int, step: int, lower_limit: int) -> int:
+    no_steps = -(-(lower_limit - start) // abs(step))
+    return start + abs(step) * no_steps
+
+class RangeIndex(Index):
+    _typ = 'rangeindex'
+    _dtype_validation_metadata = (is_signed_integer_dtype, 'signed integer')
+    _range: range
+    _values: np.ndarray
+
+    @property
+    def _engine_type(self) -> type[libindex.Int64Engine]:
+        return libindex.Int64Engine
+
+    def __new__(cls, start=None, stop=None, step=None, dtype: Dtype | None=None, copy: bool=False, name: Hashable | None=None) -> Self:
+        cls._validate_dtype(dtype)
+        name = maybe_extract_name(name, start, cls)
+        if isinstance(start, cls):
+            return start.copy(name=name)
+        elif isinstance(start, range):
+            return cls._simple_new(start, name=name)
+        if com.all_none(start, stop, step):
+            raise TypeError('RangeIndex(...) must be called with integers')
+        start = ensure_python_int(start) if start is not None else 0
+        if stop is None:
+            (start, stop) = (0, start)
+        else:
+            stop = ensure_python_int(stop)
+        step = ensure_python_int(step) if step is not None else 1
+        if step == 0:
+            raise ValueError('Step must not be zero')
+        rng = range(start, stop, step)
+        return cls._simple_new(rng, name=name)
+
+    @classmethod
+    def from_range(cls, data: range, name=None, dtype: Dtype | None=None) -> Self:
+        if not isinstance(data, range):
+            raise TypeError(f'{cls.__name__}(...) must be called with object coercible to a range, {data!r} was passed')
+        cls._validate_dtype(dtype)
+        return cls._simple_new(data, name=name)
+
+    @classmethod
+    def _simple_new(cls, values: range, name: Hashable | None=None) -> Self:
+        result = object.__new__(cls)
+        assert isinstance(values, range)
+        result._range = values
+        result._name = name
+        result._cache = {}
+        result._reset_identity()
+        result._references = None
+        return result
+
+    @classmethod
+    def _validate_dtype(cls, dtype: Dtype | None) -> None:
+        if dtype is None:
+            return
+        (validation_func, expected) = cls._dtype_validation_metadata
+        if not validation_func(dtype):
+            raise ValueError(f'Incorrect `dtype` passed: expected {expected}, received {dtype}')
+
+    @cache_readonly
+    def _constructor(self) -> type[Index]:
+        return Index
+
+    @cache_readonly
+    def _data(self) -> np.ndarray:
+        return np.arange(self.start, self.stop, self.step, dtype=np.int64)
+
+    def _get_data_as_items(self) -> list[tuple[str, int]]:
+        rng = self._range
+        return [('start', rng.start), ('stop', rng.stop), ('step', rng.step)]
+
+    def __reduce__(self):
+        d = {'name': self._name}
+        d.update(dict(self._get_data_as_items()))
+        return (ibase._new_Index, (type(self), d), None)
+
+    def _format_attrs(self):
+        attrs = cast('list[tuple[str, str | int]]', self._get_data_as_items())
+        if self._name is not None:
+            attrs.append(('name', ibase.default_pprint(self._name)))
+        return attrs
+
+    def _format_with_header(self, *, header: list[str], na_rep: str) -> list[str]:
+        if not len(self._range):
+            return header
+        first_val_str = str(self._range[0])
+        last_val_str = str(self._range[-1])
+        max_length = max(len(first_val_str), len(last_val_str))
+        return header + [f'{x:<{max_length}}' for x in self._range]
+
+    @property
+    def start(self) -> int:
+        return self._range.start
+
+    @property
+    def stop(self) -> int:
+        return self._range.stop
+
+    @property
+    def step(self) -> int:
+        return self._range.step
+
+    @cache_readonly
+    def nbytes(self) -> int:
+        rng = self._range
+        return getsizeof(rng) + sum((getsizeof(getattr(rng, attr_name)) for attr_name in ['start', 'stop', 'step']))
+
+    def memory_usage(self, deep: bool=False) -> int:
+        return self.nbytes
+
+    @property
+    def dtype(self) -> np.dtype:
+        return _dtype_int64
+
+    @property
+    def is_unique(self) -> bool:
+        return True
+
+    @cache_readonly
+    def is_monotonic_increasing(self) -> bool:
+        return self._range.step > 0 or len(self) <= 1
+
+    @cache_readonly
+    def is_monotonic_decreasing(self) -> bool:
+        return self._range.step < 0 or len(self) <= 1
+
+    def __contains__(self, key: Any) -> bool:
+        hash(key)
+        try:
+            key = ensure_python_int(key)
+        except (TypeError, OverflowError):
+            return False
+        return key in self._range
+
+    @property
+    def inferred_type(self) -> str:
+        return 'integer'
+
+    @doc(Index.get_loc)
+    def get_loc(self, key) -> int:
+        if is_integer(key) or (is_float(key) and key.is_integer()):
+            new_key = int(key)
+            try:
+                return self._range.index(new_key)
+            except ValueError as err:
+                raise KeyError(key) from err
+        if isinstance(key, Hashable):
+            raise KeyError(key)
+        self._check_indexing_error(key)
+        raise KeyError(key)
+
+    def _get_indexer(self, target: Index, method: str | None=None, limit: int | None=None, tolerance=None) -> npt.NDArray[np.intp]:
+        if com.any_not_none(method, tolerance, limit):
+            return super()._get_indexer(target, method=method, tolerance=tolerance, limit=limit)
+        if self.step > 0:
+            (start, stop, step) = (self.start, self.stop, self.step)
+        else:
+            reverse = self._range[::-1]
+            (start, stop, step) = (reverse.start, reverse.stop, reverse.step)
+        target_array = np.asarray(target)
+        locs = target_array - start
+        valid = (locs % step == 0) & (locs >= 0) & (target_array < stop)
+        locs[~valid] = -1
+        locs[valid] = locs[valid] / step
+        if step != self.step:
+            locs[valid] = len(self) - 1 - locs[valid]
+        return ensure_platform_int(locs)
+
+    @cache_readonly
+    def _should_fallback_to_positional(self) -> bool:
+        return False
+
+    def tolist(self) -> list[int]:
+        return list(self._range)
+
+    @doc(Index.__iter__)
+    def __iter__(self) -> Iterator[int]:
+        yield from self._range
+
+    @doc(Index._shallow_copy)
+    def _shallow_copy(self, values, name: Hashable=no_default):
+        name = self._name if name is no_default else name
+        if values.dtype.kind == 'f':
+            return Index(values, name=name, dtype=np.float64)
+        if values.dtype.kind == 'i' and values.ndim == 1:
+            if len(values) == 1:
+                start = values[0]
+                new_range = range(start, start + self.step, self.step)
+                return type(self)._simple_new(new_range, name=name)
+            maybe_range = ibase.maybe_sequence_to_range(values)
+            if isinstance(maybe_range, range):
+                return type(self)._simple_new(maybe_range, name=name)
+        return self._constructor._simple_new(values, name=name)
+
+    def _view(self) -> Self:
+        result = type(self)._simple_new(self._range, name=self._name)
+        result._cache = self._cache
+        return result
+
+    def _wrap_reindex_result(self, target, indexer, preserve_names: bool):
+        if not isinstance(target, type(self)) and target.dtype.kind == 'i':
+            target = self._shallow_copy(target._values, name=target.name)
+        return super()._wrap_reindex_result(target, indexer, preserve_names)
+
+    @doc(Index.copy)
+    def copy(self, name: Hashable | None=None, deep: bool=False) -> Self:
+        name = self._validate_names(name=name, deep=deep)[0]
+        new_index = self._rename(name=name)
+        return new_index
+
+    def _minmax(self, meth: Literal['min', 'max']) -> int | float:
+        no_steps = len(self) - 1
+        if no_steps == -1:
+            return np.nan
+        elif meth == 'min' and self.step > 0 or (meth == 'max' and self.step < 0):
+            return self.start
+        return self.start + self.step * no_steps
+
+    def min(self, axis=None, skipna: bool=True, *args, **kwargs) -> int | float:
+        nv.validate_minmax_axis(axis)
+        nv.validate_min(args, kwargs)
+        return self._minmax('min')
+
+    def max(self, axis=None, skipna: bool=True, *args, **kwargs) -> int | float:
+        nv.validate_minmax_axis(axis)
+        nv.validate_max(args, kwargs)
+        return self._minmax('max')
+
+    def _argminmax(self, meth: Literal['min', 'max'], axis=None, skipna: bool=True) -> int:
+        nv.validate_minmax_axis(axis)
+        if len(self) == 0:
+            return getattr(super(), f'arg{meth}')(axis=axis, skipna=skipna)
+        elif meth == 'min':
+            if self.step > 0:
+                return 0
+            else:
+                return len(self) - 1
+        elif meth == 'max':
+            if self.step > 0:
+                return len(self) - 1
+            else:
+                return 0
+        else:
+            raise ValueError(f'meth={meth!r} must be max or min')
+
+    def argmin(self, axis=None, skipna: bool=True, *args, **kwargs) -> int:
+        nv.validate_argmin(args, kwargs)
+        return self._argminmax('min', axis=axis, skipna=skipna)
+
+    def argmax(self, axis=None, skipna: bool=True, *args, **kwargs) -> int:
+        nv.validate_argmax(args, kwargs)
+        return self._argminmax('max', axis=axis, skipna=skipna)
+
+    def argsort(self, *args, **kwargs) -> npt.NDArray[np.intp]:
+        ascending = kwargs.pop('ascending', True)
+        kwargs.pop('kind', None)
+        nv.validate_argsort(args, kwargs)
+        (start, stop, step) = (None, None, None)
+        if self._range.step > 0:
+            if ascending:
+                start = len(self)
+            else:
+                (start, stop, step) = (len(self) - 1, -1, -1)
+        elif ascending:
+            (start, stop, step) = (len(self) - 1, -1, -1)
+        else:
+            start = len(self)
+        return np.arange(start, stop, step, dtype=np.intp)
+
+    def factorize(self, sort: bool=False, use_na_sentinel: bool=True) -> tuple[npt.NDArray[np.intp], RangeIndex]:
+        if sort and self.step < 0:
+            codes = np.arange(len(self) - 1, -1, -1, dtype=np.intp)
+            uniques = self[::-1]
+        else:
+            codes = np.arange(len(self), dtype=np.intp)
+            uniques = self
+        return (codes, uniques)
+
+    def equals(self, other: object) -> bool:
+        if isinstance(other, RangeIndex):
+            return self._range == other._range
+        return super().equals(other)
+
+    @overload
+    def sort_values(self, *, return_indexer: Literal[False]=..., ascending: bool=..., na_position: NaPosition=..., key: Callable | None=...) -> Self:
+        ...
+
+    @overload
+    def sort_values(self, *, return_indexer: Literal[True], ascending: bool=..., na_position: NaPosition=..., key: Callable | None=...) -> tuple[Self, np.ndarray | RangeIndex]:
+        ...
+
+    @overload
+    def sort_values(self, *, return_indexer: bool=..., ascending: bool=..., na_position: NaPosition=..., key: Callable | None=...) -> Self | tuple[Self, np.ndarray | RangeIndex]:
+        ...
+
+    def sort_values(self, *, return_indexer: bool=False, ascending: bool=True, na_position: NaPosition='last', key: Callable | None=None) -> Self | tuple[Self, np.ndarray | RangeIndex]:
+        if key is not None:
+            return super().sort_values(return_indexer=return_indexer, ascending=ascending, na_position=na_position, key=key)
+        else:
+            sorted_index = self
+            inverse_indexer = False
+            if ascending:
+                if self.step < 0:
+                    sorted_index = self[::-1]
+                    inverse_indexer = True
+            elif self.step > 0:
+                sorted_index = self[::-1]
+                inverse_indexer = True
+        if return_indexer:
+            if inverse_indexer:
+                rng = range(len(self) - 1, -1, -1)
+            else:
+                rng = range(len(self))
+            return (sorted_index, RangeIndex(rng))
+        else:
+            return sorted_index
+
+    def _intersection(self, other: Index, sort: bool=False):
+        if not isinstance(other, RangeIndex):
+            return super()._intersection(other, sort=sort)
+        first = self._range[::-1] if self.step < 0 else self._range
+        second = other._range[::-1] if other.step < 0 else other._range
+        int_low = max(first.start, second.start)
+        int_high = min(first.stop, second.stop)
+        if int_high <= int_low:
+            return self._simple_new(_empty_range)
+        (gcd, s, _) = self._extended_gcd(first.step, second.step)
+        if (first.start - second.start) % gcd:
+            return self._simple_new(_empty_range)
+        tmp_start = first.start + (second.start - first.start) * first.step // gcd * s
+        new_step = first.step * second.step // gcd
+        new_start = min_fitting_element(tmp_start, new_step, int_low)
+        new_range = range(new_start, int_high, new_step)
+        if (self.step < 0 and other.step < 0) is not (new_range.step < 0):
+            new_range = new_range[::-1]
+        return self._simple_new(new_range)
+
+    def _extended_gcd(self, a: int, b: int) -> tuple[int, int, int]:
+        (s, old_s) = (0, 1)
+        (t, old_t) = (1, 0)
+        (r, old_r) = (b, a)
+        while r:
+            quotient = old_r // r
+            (old_r, r) = (r, old_r - quotient * r)
+            (old_s, s) = (s, old_s - quotient * s)
+            (old_t, t) = (t, old_t - quotient * t)
+        return (old_r, old_s, old_t)
+
+    def _range_in_self(self, other: range) -> bool:
+        if not other:
+            return True
+        if not self._range:
+            return False
+        if len(other) > 1 and other.step % self._range.step:
+            return False
+        return other.start in self._range and other[-1] in self._range
+
+    def _union(self, other: Index, sort: bool | None):
+        if isinstance(other, RangeIndex):
+            if sort in (None, True) or (sort is False and self.step > 0 and self._range_in_self(other._range)):
+                (start_s, step_s) = (self.start, self.step)
+                end_s = self.start + self.step * (len(self) - 1)
+                (start_o, step_o) = (other.start, other.step)
+                end_o = other.start + other.step * (len(other) - 1)
+                if self.step < 0:
+                    (start_s, step_s, end_s) = (end_s, -step_s, start_s)
+                if other.step < 0:
+                    (start_o, step_o, end_o) = (end_o, -step_o, start_o)
+                if len(self) == 1 and len(other) == 1:
+                    step_s = step_o = abs(self.start - other.start)
+                elif len(self) == 1:
+                    step_s = step_o
+                elif len(other) == 1:
+                    step_o = step_s
+                start_r = min(start_s, start_o)
+                end_r = max(end_s, end_o)
+                if step_o == step_s:
+                    if (start_s - start_o) % step_s == 0 and start_s - end_o <= step_s and (start_o - end_s <= step_s):
+                        return type(self)(start_r, end_r + step_s, step_s)
+                    if step_s % 2 == 0 and abs(start_s - start_o) == step_s / 2 and (abs(end_s - end_o) == step_s / 2):
+                        return type(self)(start_r, end_r + step_s / 2, step_s / 2)
+                elif step_o % step_s == 0:
+                    if (start_o - start_s) % step_s == 0 and start_o + step_s >= start_s and (end_o - step_s <= end_s):
+                        return type(self)(start_r, end_r + step_s, step_s)
+                elif step_s % step_o == 0:
+                    if (start_s - start_o) % step_o == 0 and start_s + step_o >= start_o and (end_s - step_o <= end_o):
+                        return type(self)(start_r, end_r + step_o, step_o)
+        return super()._union(other, sort=sort)
+
+    def _difference(self, other, sort=None):
+        self._validate_sort_keyword(sort)
+        self._assert_can_do_setop(other)
+        (other, result_name) = self._convert_can_do_setop(other)
+        if not isinstance(other, RangeIndex):
+            return super()._difference(other, sort=sort)
+        if sort is not False and self.step < 0:
+            return self[::-1]._difference(other)
+        res_name = ops.get_op_result_name(self, other)
+        first = self._range[::-1] if self.step < 0 else self._range
+        overlap = self.intersection(other)
+        if overlap.step < 0:
+            overlap = overlap[::-1]
+        if len(overlap) == 0:
+            return self.rename(name=res_name)
+        if len(overlap) == len(self):
+            return self[:0].rename(res_name)
+        if len(overlap) == 1:
+            if overlap[0] == self[0]:
+                return self[1:]
+            elif overlap[0] == self[-1]:
+                return self[:-1]
+            elif len(self) == 3 and overlap[0] == self[1]:
+                return self[::2]
+            else:
+                return super()._difference(other, sort=sort)
+        elif len(overlap) == 2 and overlap[0] == first[0] and (overlap[-1] == first[-1]):
+            return self[1:-1]
+        if overlap.step == first.step:
+            if overlap[0] == first.start:
+                new_rng = range(overlap[-1] + first.step, first.stop, first.step)
+            elif overlap[-1] == first[-1]:
+                new_rng = range(first.start, overlap[0], first.step)
+            elif overlap._range == first[1:-1]:
+                step = len(first) - 1
+                new_rng = first[::step]
+            else:
+                return super()._difference(other, sort=sort)
+        else:
+            assert len(self) > 1
+            if overlap.step == first.step * 2:
+                if overlap[0] == first[0] and overlap[-1] in (first[-1], first[-2]):
+                    new_rng = first[1::2]
+                elif overlap[0] == first[1] and overlap[-1] in (first[-1], first[-2]):
+                    new_rng = first[::2]
+                else:
+                    return super()._difference(other, sort=sort)
+            else:
+                return super()._difference(other, sort=sort)
+        if first is not self._range:
+            new_rng = new_rng[::-1]
+        new_index = type(self)._simple_new(new_rng, name=res_name)
+        return new_index
+
+    def symmetric_difference(self, other, result_name: Hashable | None=None, sort=None) -> Index:
+        if not isinstance(other, RangeIndex) or sort is not None:
+            return super().symmetric_difference(other, result_name, sort)
+        left = self.difference(other)
+        right = other.difference(self)
+        result = left.union(right)
+        if result_name is not None:
+            result = result.rename(result_name)
+        return result
+
+    def _join_empty(self, other: Index, how: JoinHow, sort: bool) -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        if not isinstance(other, RangeIndex) and other.dtype.kind == 'i':
+            other = self._shallow_copy(other._values, name=other.name)
+        return super()._join_empty(other, how=how, sort=sort)
+
+    def _join_monotonic(self, other: Index, how: JoinHow='left') -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        if not isinstance(other, type(self)):
+            maybe_ri = self._shallow_copy(other._values, name=other.name)
+            if not isinstance(maybe_ri, type(self)):
+                return super()._join_monotonic(other, how=how)
+            other = maybe_ri
+        if self.equals(other):
+            ret_index = other if how == 'right' else self
+            return (ret_index, None, None)
+        if how == 'left':
+            join_index = self
+            lidx = None
+            ridx = other.get_indexer(join_index)
+        elif how == 'right':
+            join_index = other
+            lidx = self.get_indexer(join_index)
+            ridx = None
+        elif how == 'inner':
+            join_index = self.intersection(other)
+            lidx = self.get_indexer(join_index)
+            ridx = other.get_indexer(join_index)
+        elif how == 'outer':
+            join_index = self.union(other)
+            lidx = self.get_indexer(join_index)
+            ridx = other.get_indexer(join_index)
+        lidx = None if lidx is None else ensure_platform_int(lidx)
+        ridx = None if ridx is None else ensure_platform_int(ridx)
+        return (join_index, lidx, ridx)
+
+    def delete(self, loc) -> Index:
+        if is_integer(loc):
+            if loc in (0, -len(self)):
+                return self[1:]
+            if loc in (-1, len(self) - 1):
+                return self[:-1]
+            if len(self) == 3 and loc in (1, -2):
+                return self[::2]
+        elif lib.is_list_like(loc):
+            slc = lib.maybe_indices_to_slice(np.asarray(loc, dtype=np.intp), len(self))
+            if isinstance(slc, slice):
+                other = self[slc]
+                return self.difference(other, sort=False)
+        return super().delete(loc)
+
+    def insert(self, loc: int, item) -> Index:
+        if is_integer(item) or is_float(item):
+            if len(self) == 0 and loc == 0 and is_integer(item):
+                new_rng = range(item, item + self.step, self.step)
+                return type(self)._simple_new(new_rng, name=self._name)
+            elif len(self):
+                rng = self._range
+                if loc == 0 and item == self[0] - self.step:
+                    new_rng = range(rng.start - rng.step, rng.stop, rng.step)
+                    return type(self)._simple_new(new_rng, name=self._name)
+                elif loc == len(self) and item == self[-1] + self.step:
+                    new_rng = range(rng.start, rng.stop + rng.step, rng.step)
+                    return type(self)._simple_new(new_rng, name=self._name)
+                elif len(self) == 2 and item == self[0] + self.step / 2:
+                    step = int(self.step / 2)
+                    new_rng = range(self.start, self.stop, step)
+                    return type(self)._simple_new(new_rng, name=self._name)
+        return super().insert(loc, item)
+
+    def _concat(self, indexes: list[Index], name: Hashable) -> Index:
+        if not all((isinstance(x, RangeIndex) for x in indexes)):
+            result = super()._concat(indexes, name)
+            if result.dtype.kind == 'i':
+                return self._shallow_copy(result._values)
+            return result
+        elif len(indexes) == 1:
+            return indexes[0]
+        rng_indexes = cast(list[RangeIndex], indexes)
+        start = step = next_ = None
+        non_empty_indexes = []
+        all_same_index = True
+        prev: RangeIndex | None = None
+        for obj in rng_indexes:
+            if len(obj):
+                non_empty_indexes.append(obj)
+                if all_same_index:
+                    if prev is not None:
+                        all_same_index = prev.equals(obj)
+                    else:
+                        prev = obj
+        for obj in non_empty_indexes:
+            rng = obj._range
+            if start is None:
+                start = rng.start
+                if step is None and len(rng) > 1:
+                    step = rng.step
+            elif step is None:
+                if rng.start == start:
+                    if all_same_index:
+                        values = np.tile(non_empty_indexes[0]._values, len(non_empty_indexes))
+                    else:
+                        values = np.concatenate([x._values for x in rng_indexes])
+                    result = self._constructor(values)
+                    return result.rename(name)
+                step = rng.start - start
+            non_consecutive = step != rng.step and len(rng) > 1 or (next_ is not None and rng.start != next_)
+            if non_consecutive:
+                if all_same_index:
+                    values = np.tile(non_empty_indexes[0]._values, len(non_empty_indexes))
+                else:
+                    values = np.concatenate([x._values for x in rng_indexes])
+                result = self._constructor(values)
+                return result.rename(name)
+            if step is not None:
+                next_ = rng[-1] + step
+        if non_empty_indexes:
+            stop = non_empty_indexes[-1].stop if next_ is None else next_
+            if len(non_empty_indexes) == 1:
+                step = non_empty_indexes[0].step
+            return RangeIndex(start, stop, step, name=name)
+        return RangeIndex(_empty_range, name=name)
+
+    def __len__(self) -> int:
+        return len(self._range)
+
+    @property
+    def size(self) -> int:
+        return len(self)
+
+    def __getitem__(self, key):
+        if key is Ellipsis:
+            key = slice(None)
+        if isinstance(key, slice):
+            return self._getitem_slice(key)
+        elif is_integer(key):
+            new_key = int(key)
+            try:
+                return self._range[new_key]
+            except IndexError as err:
+                raise IndexError(f'index {key} is out of bounds for axis 0 with size {len(self)}') from err
+        elif is_scalar(key):
+            raise IndexError('only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices')
+        elif com.is_bool_indexer(key):
+            if isinstance(getattr(key, 'dtype', None), ExtensionDtype):
+                key = key.to_numpy(dtype=bool, na_value=False)
+            else:
+                key = np.asarray(key, dtype=bool)
+            check_array_indexer(self._range, key)
+            key = np.flatnonzero(key)
+        try:
+            return self.take(key)
+        except (TypeError, ValueError):
+            return super().__getitem__(key)
+
+    def _getitem_slice(self, slobj: slice) -> Self:
+        res = self._range[slobj]
+        return type(self)._simple_new(res, name=self._name)
+
+    @unpack_zerodim_and_defer('__floordiv__')
+    def __floordiv__(self, other):
+        if is_integer(other) and other != 0:
+            if len(self) == 0 or (self.start % other == 0 and self.step % other == 0):
+                start = self.start // other
+                step = self.step // other
+                stop = start + len(self) * step
+                new_range = range(start, stop, step or 1)
+                return self._simple_new(new_range, name=self._name)
+            if len(self) == 1:
+                start = self.start // other
+                new_range = range(start, start + 1, 1)
+                return self._simple_new(new_range, name=self._name)
+        return super().__floordiv__(other)
+
+    def all(self, *args, **kwargs) -> bool:
+        return 0 not in self._range
+
+    def any(self, *args, **kwargs) -> bool:
+        return any(self._range)
+
+    def round(self, decimals: int=0) -> Self | Index:
+        if decimals >= 0:
+            return self.copy()
+        elif self.start % 10 ** (-decimals) == 0 and self.step % 10 ** (-decimals) == 0:
+            return self.copy()
+        else:
+            return super().round(decimals=decimals)
+
+    def _cmp_method(self, other, op):
+        if isinstance(other, RangeIndex) and self._range == other._range:
+            return super()._cmp_method(self, op)
+        return super()._cmp_method(other, op)
+
+    def _arith_method(self, other, op):
+        if isinstance(other, ABCTimedeltaIndex):
+            return NotImplemented
+        elif isinstance(other, (timedelta, np.timedelta64)):
+            return super()._arith_method(other, op)
+        elif lib.is_np_dtype(getattr(other, 'dtype', None), 'm'):
+            return super()._arith_method(other, op)
+        if op in [operator.pow, ops.rpow, operator.mod, ops.rmod, operator.floordiv, ops.rfloordiv, divmod, ops.rdivmod]:
+            return super()._arith_method(other, op)
+        step: Callable | None = None
+        if op in [operator.mul, ops.rmul, operator.truediv, ops.rtruediv]:
+            step = op
+        right = extract_array(other, extract_numpy=True, extract_range=True)
+        left = self
+        try:
+            if step:
+                with np.errstate(all='ignore'):
+                    rstep = step(left.step, right)
+                if not is_integer(rstep) or not rstep:
+                    raise ValueError
+            else:
+                rstep = -left.step if op == ops.rsub else left.step
+            with np.errstate(all='ignore'):
+                rstart = op(left.start, right)
+                rstop = op(left.stop, right)
+            res_name = ops.get_op_result_name(self, other)
+            result = type(self)(rstart, rstop, rstep, name=res_name)
+            if not all((is_integer(x) for x in [rstart, rstop, rstep])):
+                result = result.astype('float64')
+            return result
+        except (ValueError, TypeError, ZeroDivisionError):
+            return super()._arith_method(other, op)
+
+    def __abs__(self) -> Self | Index:
+        if len(self) == 0 or self.min() >= 0:
+            return self.copy()
+        elif self.max() <= 0:
+            return -self
+        else:
+            return super().__abs__()
+
+    def __neg__(self) -> Self:
+        rng = range(-self.start, -self.stop, -self.step)
+        return self._simple_new(rng, name=self.name)
+
+    def __pos__(self) -> Self:
+        return self.copy()
+
+    def __invert__(self) -> Self:
+        if len(self) == 0:
+            return self.copy()
+        rng = range(~self.start, ~self.stop, -self.step)
+        return self._simple_new(rng, name=self.name)
+
+    def take(self, indices, axis: Axis=0, allow_fill: bool=True, fill_value=None, **kwargs) -> Self | Index:
+        if kwargs:
+            nv.validate_take((), kwargs)
+        if is_scalar(indices):
+            raise TypeError('Expected indices to be array-like')
+        indices = ensure_platform_int(indices)
+        self._maybe_disallow_fill(allow_fill, fill_value, indices)
+        if len(indices) == 0:
+            return type(self)(_empty_range, name=self.name)
+        else:
+            ind_max = indices.max()
+            if ind_max >= len(self):
+                raise IndexError(f'index {ind_max} is out of bounds for axis 0 with size {len(self)}')
+            ind_min = indices.min()
+            if ind_min < -len(self):
+                raise IndexError(f'index {ind_min} is out of bounds for axis 0 with size {len(self)}')
+            taken = indices.astype(self.dtype, casting='safe')
+            if ind_min < 0:
+                taken %= len(self)
+            if self.step != 1:
+                taken *= self.step
+            if self.start != 0:
+                taken += self.start
+        return self._shallow_copy(taken, name=self.name)
+
+    def value_counts(self, normalize: bool=False, sort: bool=True, ascending: bool=False, bins=None, dropna: bool=True) -> Series:
+        from pandas import Series
+        if bins is not None:
+            return super().value_counts(normalize=normalize, sort=sort, ascending=ascending, bins=bins, dropna=dropna)
+        name = 'proportion' if normalize else 'count'
+        data: npt.NDArray[np.floating] | npt.NDArray[np.signedinteger] = np.ones(len(self), dtype=np.int64)
+        if normalize:
+            data = data / len(self)
+        return Series(data, index=self.copy(), name=name)
+
+    def searchsorted(self, value, side: Literal['left', 'right']='left', sorter: NumpySorter | None=None) -> npt.NDArray[np.intp] | np.intp:
+        if side not in {'left', 'right'} or sorter is not None:
+            return super().searchsorted(value=value, side=side, sorter=sorter)
+        was_scalar = False
+        if is_scalar(value):
+            was_scalar = True
+            array_value = np.array([value])
+        else:
+            array_value = np.asarray(value)
+        if array_value.dtype.kind not in 'iu':
+            return super().searchsorted(value=value, side=side, sorter=sorter)
+        if (flip := (self.step < 0)):
+            rng = self._range[::-1]
+            start = rng.start
+            step = rng.step
+            shift = side == 'right'
+        else:
+            start = self.start
+            step = self.step
+            shift = side == 'left'
+        result = (array_value - start - int(shift)) // step + 1
+        if flip:
+            result = len(self) - result
+        result = np.maximum(np.minimum(result, len(self)), 0)
+        if was_scalar:
+            return np.intp(result.item())
+        return result.astype(np.intp, copy=False)
+
+# File: pandas-main/pandas/core/indexes/timedeltas.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from pandas._libs import index as libindex, lib
+from pandas._libs.tslibs import Resolution, Timedelta, to_offset
+from pandas.core.dtypes.common import is_scalar, pandas_dtype
+from pandas.core.dtypes.generic import ABCSeries
+from pandas.core.arrays.timedeltas import TimedeltaArray
+import pandas.core.common as com
+from pandas.core.indexes.base import Index, maybe_extract_name
+from pandas.core.indexes.datetimelike import DatetimeTimedeltaMixin
+from pandas.core.indexes.extension import inherit_names
+if TYPE_CHECKING:
+    from pandas._libs import NaTType
+    from pandas._typing import DtypeObj
+
+@inherit_names(['__neg__', '__pos__', '__abs__', 'total_seconds', 'round', 'floor', 'ceil'] + TimedeltaArray._field_ops, TimedeltaArray, wrap=True)
+@inherit_names(['components', 'to_pytimedelta', 'sum', 'std', 'median'], TimedeltaArray)
+class TimedeltaIndex(DatetimeTimedeltaMixin):
+    _typ = 'timedeltaindex'
+    _data_cls = TimedeltaArray
+
+    @property
+    def _engine_type(self) -> type[libindex.TimedeltaEngine]:
+        return libindex.TimedeltaEngine
+    _data: TimedeltaArray
+    _get_string_slice = Index._get_string_slice
+
+    @property
+    def _resolution_obj(self) -> Resolution | None:
+        return self._data._resolution_obj
+
+    def __new__(cls, data=None, freq=lib.no_default, dtype=None, copy: bool=False, name=None):
+        name = maybe_extract_name(name, data, cls)
+        if is_scalar(data):
+            cls._raise_scalar_data_error(data)
+        if dtype is not None:
+            dtype = pandas_dtype(dtype)
+        if isinstance(data, TimedeltaArray) and freq is lib.no_default and (dtype is None or dtype == data.dtype):
+            if copy:
+                data = data.copy()
+            return cls._simple_new(data, name=name)
+        if isinstance(data, TimedeltaIndex) and freq is lib.no_default and (name is None) and (dtype is None or dtype == data.dtype):
+            if copy:
+                return data.copy()
+            else:
+                return data._view()
+        tdarr = TimedeltaArray._from_sequence_not_strict(data, freq=freq, unit=None, dtype=dtype, copy=copy)
+        refs = None
+        if not copy and isinstance(data, (ABCSeries, Index)):
+            refs = data._references
+        return cls._simple_new(tdarr, name=name, refs=refs)
+
+    def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
+        return lib.is_np_dtype(dtype, 'm')
+
+    def get_loc(self, key):
+        self._check_indexing_error(key)
+        try:
+            key = self._data._validate_scalar(key, unbox=False)
+        except TypeError as err:
+            raise KeyError(key) from err
+        return Index.get_loc(self, key)
+
+    def _parse_with_reso(self, label: str) -> tuple[Timedelta | NaTType, None]:
+        parsed = Timedelta(label)
+        return (parsed, None)
+
+    def _parsed_string_to_bounds(self, reso, parsed: Timedelta):
+        lbound = parsed.round(parsed.resolution_string)
+        rbound = lbound + to_offset(parsed.resolution_string) - Timedelta(1, 'ns')
+        return (lbound, rbound)
+
+    @property
+    def inferred_type(self) -> str:
+        return 'timedelta64'
+
+def timedelta_range(start=None, end=None, periods: int | None=None, freq=None, name=None, closed=None, *, unit: str | None=None) -> TimedeltaIndex:
+    if freq is None and com.any_none(periods, start, end):
+        freq = 'D'
+    freq = to_offset(freq)
+    tdarr = TimedeltaArray._generate_range(start, end, periods, freq, closed=closed, unit=unit)
+    return TimedeltaIndex._simple_new(tdarr, name=name)
+
+# File: pandas-main/pandas/core/indexing.py
+from __future__ import annotations
+from contextlib import suppress
+import sys
+from typing import TYPE_CHECKING, Any, TypeVar, cast, final
+import warnings
+import numpy as np
+from pandas._libs.indexing import NDFrameIndexerBase
+from pandas._libs.lib import item_from_zerodim
+from pandas.compat import PYPY
+from pandas.errors import AbstractMethodError, ChainedAssignmentError, IndexingError, InvalidIndexError, LossySetitemError
+from pandas.errors.cow import _chained_assignment_msg
+from pandas.util._decorators import doc
+from pandas.core.dtypes.cast import can_hold_element, maybe_promote
+from pandas.core.dtypes.common import is_array_like, is_bool_dtype, is_hashable, is_integer, is_iterator, is_list_like, is_numeric_dtype, is_object_dtype, is_scalar, is_sequence
+from pandas.core.dtypes.concat import concat_compat
+from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.dtypes.missing import construct_1d_array_from_inferred_fill_value, infer_fill_value, is_valid_na_for_dtype, isna, na_value_for_dtype
+from pandas.core import algorithms as algos
+import pandas.core.common as com
+from pandas.core.construction import array as pd_array, extract_array
+from pandas.core.indexers import check_array_indexer, is_list_like_indexer, is_scalar_indexer, length_of_indexer
+from pandas.core.indexes.api import Index, MultiIndex
+if TYPE_CHECKING:
+    from collections.abc import Hashable, Sequence
+    from pandas._typing import Axis, AxisInt, Self, npt
+    from pandas import DataFrame, Series
+T = TypeVar('T')
+_NS = slice(None, None)
+_one_ellipsis_message = "indexer may only contain one '...' entry"
+
+class _IndexSlice:
+
+    def __getitem__(self, arg):
+        return arg
+IndexSlice = _IndexSlice()
+
+class IndexingMixin:
+
+    @property
+    def iloc(self) -> _iLocIndexer:
+        return _iLocIndexer('iloc', self)
+
+    @property
+    def loc(self) -> _LocIndexer:
+        return _LocIndexer('loc', self)
+
+    @property
+    def at(self) -> _AtIndexer:
+        return _AtIndexer('at', self)
+
+    @property
+    def iat(self) -> _iAtIndexer:
+        return _iAtIndexer('iat', self)
+
+class _LocationIndexer(NDFrameIndexerBase):
+    _valid_types: str
+    axis: AxisInt | None = None
+    _takeable: bool
+
+    @final
+    def __call__(self, axis: Axis | None=None) -> Self:
+        new_self = type(self)(self.name, self.obj)
+        if axis is not None:
+            axis_int_none = self.obj._get_axis_number(axis)
+        else:
+            axis_int_none = axis
+        new_self.axis = axis_int_none
+        return new_self
+
+    def _get_setitem_indexer(self, key):
+        if self.name == 'loc':
+            self._ensure_listlike_indexer(key, axis=self.axis)
+        if isinstance(key, tuple):
+            for x in key:
+                check_dict_or_set_indexers(x)
+        if self.axis is not None:
+            key = _tupleize_axis_indexer(self.ndim, self.axis, key)
+        ax = self.obj._get_axis(0)
+        if isinstance(ax, MultiIndex) and self.name != 'iloc' and is_hashable(key) and (not isinstance(key, slice)):
+            with suppress(KeyError, InvalidIndexError):
+                return ax.get_loc(key)
+        if isinstance(key, tuple):
+            with suppress(IndexingError):
+                return self._convert_tuple(key)
+        if isinstance(key, range):
+            key = list(key)
+        return self._convert_to_indexer(key, axis=0)
+
+    @final
+    def _maybe_mask_setitem_value(self, indexer, value):
+        if isinstance(indexer, tuple) and len(indexer) == 2 and isinstance(value, (ABCSeries, ABCDataFrame)):
+            (pi, icols) = indexer
+            ndim = value.ndim
+            if com.is_bool_indexer(pi) and len(value) == len(pi):
+                newkey = pi.nonzero()[0]
+                if is_scalar_indexer(icols, self.ndim - 1) and ndim == 1:
+                    if len(newkey) == 0:
+                        value = value.iloc[:0]
+                    else:
+                        value = self.obj.iloc._align_series(indexer, value)
+                    indexer = (newkey, icols)
+                elif isinstance(icols, np.ndarray) and icols.dtype.kind == 'i' and (len(icols) == 1):
+                    if ndim == 1:
+                        value = self.obj.iloc._align_series(indexer, value)
+                        indexer = (newkey, icols)
+                    elif ndim == 2 and value.shape[1] == 1:
+                        if len(newkey) == 0:
+                            value = value.iloc[:0]
+                        else:
+                            value = self.obj.iloc._align_frame(indexer, value)
+                        indexer = (newkey, icols)
+        elif com.is_bool_indexer(indexer):
+            indexer = indexer.nonzero()[0]
+        return (indexer, value)
+
+    @final
+    def _ensure_listlike_indexer(self, key, axis=None, value=None) -> None:
+        column_axis = 1
+        if self.ndim != 2:
+            return
+        if isinstance(key, tuple) and len(key) > 1:
+            if axis is None:
+                axis = column_axis
+            key = key[axis]
+        if axis == column_axis and (not isinstance(self.obj.columns, MultiIndex)) and is_list_like_indexer(key) and (not com.is_bool_indexer(key)) and all((is_hashable(k) for k in key)):
+            keys = self.obj.columns.union(key, sort=False)
+            diff = Index(key).difference(self.obj.columns, sort=False)
+            if len(diff):
+                indexer = np.arange(len(keys), dtype=np.intp)
+                indexer[len(self.obj.columns):] = -1
+                new_mgr = self.obj._mgr.reindex_indexer(keys, indexer=indexer, axis=0, only_slice=True, use_na_proxy=True)
+                self.obj._mgr = new_mgr
+                return
+            self.obj._mgr = self.obj._mgr.reindex_axis(keys, axis=0, only_slice=True)
+
+    @final
+    def __setitem__(self, key, value) -> None:
+        if not PYPY:
+            if sys.getrefcount(self.obj) <= 2:
+                warnings.warn(_chained_assignment_msg, ChainedAssignmentError, stacklevel=2)
+        check_dict_or_set_indexers(key)
+        if isinstance(key, tuple):
+            key = (list(x) if is_iterator(x) else x for x in key)
+            key = tuple((com.apply_if_callable(x, self.obj) for x in key))
+        else:
+            maybe_callable = com.apply_if_callable(key, self.obj)
+            key = self._raise_callable_usage(key, maybe_callable)
+        indexer = self._get_setitem_indexer(key)
+        self._has_valid_setitem_indexer(key)
+        iloc = self if self.name == 'iloc' else self.obj.iloc
+        iloc._setitem_with_indexer(indexer, value, self.name)
+
+    def _validate_key(self, key, axis: AxisInt) -> None:
+        raise AbstractMethodError(self)
+
+    @final
+    def _expand_ellipsis(self, tup: tuple) -> tuple:
+        if any((x is Ellipsis for x in tup)):
+            if tup.count(Ellipsis) > 1:
+                raise IndexingError(_one_ellipsis_message)
+            if len(tup) == self.ndim:
+                i = tup.index(Ellipsis)
+                new_key = tup[:i] + (_NS,) + tup[i + 1:]
+                return new_key
+        return tup
+
+    @final
+    def _validate_tuple_indexer(self, key: tuple) -> tuple:
+        key = self._validate_key_length(key)
+        key = self._expand_ellipsis(key)
+        for (i, k) in enumerate(key):
+            try:
+                self._validate_key(k, i)
+            except ValueError as err:
+                raise ValueError(f'Location based indexing can only have [{self._valid_types}] types') from err
+        return key
+
+    @final
+    def _is_nested_tuple_indexer(self, tup: tuple) -> bool:
+        if any((isinstance(ax, MultiIndex) for ax in self.obj.axes)):
+            return any((is_nested_tuple(tup, ax) for ax in self.obj.axes))
+        return False
+
+    @final
+    def _convert_tuple(self, key: tuple) -> tuple:
+        self._validate_key_length(key)
+        keyidx = [self._convert_to_indexer(k, axis=i) for (i, k) in enumerate(key)]
+        return tuple(keyidx)
+
+    @final
+    def _validate_key_length(self, key: tuple) -> tuple:
+        if len(key) > self.ndim:
+            if key[0] is Ellipsis:
+                key = key[1:]
+                if Ellipsis in key:
+                    raise IndexingError(_one_ellipsis_message)
+                return self._validate_key_length(key)
+            raise IndexingError('Too many indexers')
+        return key
+
+    @final
+    def _getitem_tuple_same_dim(self, tup: tuple):
+        retval = self.obj
+        start_val = self.ndim - len(tup) + 1
+        for (i, key) in enumerate(reversed(tup)):
+            i = self.ndim - i - start_val
+            if com.is_null_slice(key):
+                continue
+            retval = getattr(retval, self.name)._getitem_axis(key, axis=i)
+            assert retval.ndim == self.ndim
+        if retval is self.obj:
+            retval = retval.copy(deep=False)
+        return retval
+
+    @final
+    def _getitem_lowerdim(self, tup: tuple):
+        if self.axis is not None:
+            axis = self.obj._get_axis_number(self.axis)
+            return self._getitem_axis(tup, axis=axis)
+        if self._is_nested_tuple_indexer(tup):
+            return self._getitem_nested_tuple(tup)
+        ax0 = self.obj._get_axis(0)
+        if isinstance(ax0, MultiIndex) and self.name != 'iloc' and (not any((isinstance(x, slice) for x in tup))):
+            with suppress(IndexingError):
+                return cast(_LocIndexer, self)._handle_lowerdim_multi_index_axis0(tup)
+        tup = self._validate_key_length(tup)
+        for (i, key) in enumerate(tup):
+            if is_label_like(key):
+                section = self._getitem_axis(key, axis=i)
+                if section.ndim == self.ndim:
+                    new_key = tup[:i] + (_NS,) + tup[i + 1:]
+                else:
+                    new_key = tup[:i] + tup[i + 1:]
+                    if len(new_key) == 1:
+                        new_key = new_key[0]
+                if com.is_null_slice(new_key):
+                    return section
+                return getattr(section, self.name)[new_key]
+        raise IndexingError('not applicable')
+
+    @final
+    def _getitem_nested_tuple(self, tup: tuple):
+
+        def _contains_slice(x: object) -> bool:
+            if isinstance(x, tuple):
+                return any((isinstance(v, slice) for v in x))
+            elif isinstance(x, slice):
+                return True
+            return False
+        for key in tup:
+            check_dict_or_set_indexers(key)
+        if len(tup) > self.ndim:
+            if self.name != 'loc':
+                raise ValueError('Too many indices')
+            if all((is_hashable(x) and (not _contains_slice(x)) or com.is_null_slice(x) for x in tup)):
+                with suppress(IndexingError):
+                    return cast(_LocIndexer, self)._handle_lowerdim_multi_index_axis0(tup)
+            elif isinstance(self.obj, ABCSeries) and any((isinstance(k, tuple) for k in tup)):
+                raise IndexingError('Too many indexers')
+            axis = self.axis or 0
+            return self._getitem_axis(tup, axis=axis)
+        obj = self.obj
+        axis = len(tup) - 1
+        for key in reversed(tup):
+            if com.is_null_slice(key):
+                axis -= 1
+                continue
+            obj = getattr(obj, self.name)._getitem_axis(key, axis=axis)
+            axis -= 1
+            if is_scalar(obj) or not hasattr(obj, 'ndim'):
+                break
+        return obj
+
+    def _convert_to_indexer(self, key, axis: AxisInt):
+        raise AbstractMethodError(self)
+
+    def _raise_callable_usage(self, key: Any, maybe_callable: T) -> T:
+        if self.name == 'iloc' and callable(key) and isinstance(maybe_callable, tuple):
+            raise ValueError('Returning a tuple from a callable with iloc is not allowed.')
+        return maybe_callable
+
+    @final
+    def __getitem__(self, key):
+        check_dict_or_set_indexers(key)
+        if type(key) is tuple:
+            key = (list(x) if is_iterator(x) else x for x in key)
+            key = tuple((com.apply_if_callable(x, self.obj) for x in key))
+            if self._is_scalar_access(key):
+                return self.obj._get_value(*key, takeable=self._takeable)
+            return self._getitem_tuple(key)
+        else:
+            axis = self.axis or 0
+            maybe_callable = com.apply_if_callable(key, self.obj)
+            maybe_callable = self._raise_callable_usage(key, maybe_callable)
+            return self._getitem_axis(maybe_callable, axis=axis)
+
+    def _is_scalar_access(self, key: tuple):
+        raise NotImplementedError
+
+    def _getitem_tuple(self, tup: tuple):
+        raise AbstractMethodError(self)
+
+    def _getitem_axis(self, key, axis: AxisInt):
+        raise NotImplementedError
+
+    def _has_valid_setitem_indexer(self, indexer) -> bool:
+        raise AbstractMethodError(self)
+
+    @final
+    def _getbool_axis(self, key, axis: AxisInt):
+        labels = self.obj._get_axis(axis)
+        key = check_bool_indexer(labels, key)
+        inds = key.nonzero()[0]
+        return self.obj.take(inds, axis=axis)
+
+@doc(IndexingMixin.loc)
+class _LocIndexer(_LocationIndexer):
+    _takeable: bool = False
+    _valid_types = 'labels (MUST BE IN THE INDEX), slices of labels (BOTH endpoints included! Can be slices of integers if the index is integers), listlike of labels, boolean'
+
+    @doc(_LocationIndexer._validate_key)
+    def _validate_key(self, key, axis: Axis) -> None:
+        ax = self.obj._get_axis(axis)
+        if isinstance(key, bool) and (not (is_bool_dtype(ax.dtype) or ax.dtype.name == 'boolean' or (isinstance(ax, MultiIndex) and is_bool_dtype(ax.get_level_values(0).dtype)))):
+            raise KeyError(f'{key}: boolean label can not be used without a boolean index')
+        if isinstance(key, slice) and (isinstance(key.start, bool) or isinstance(key.stop, bool)):
+            raise TypeError(f'{key}: boolean values can not be used in a slice')
+
+    def _has_valid_setitem_indexer(self, indexer) -> bool:
+        return True
+
+    def _is_scalar_access(self, key: tuple) -> bool:
+        if len(key) != self.ndim:
+            return False
+        for (i, k) in enumerate(key):
+            if not is_scalar(k):
+                return False
+            ax = self.obj.axes[i]
+            if isinstance(ax, MultiIndex):
+                return False
+            if isinstance(k, str) and ax._supports_partial_string_indexing:
+                return False
+            if not ax._index_as_unique:
+                return False
+        return True
+
+    def _multi_take_opportunity(self, tup: tuple) -> bool:
+        if not all((is_list_like_indexer(x) for x in tup)):
+            return False
+        return not any((com.is_bool_indexer(x) for x in tup))
+
+    def _multi_take(self, tup: tuple):
+        d = {axis: self._get_listlike_indexer(key, axis) for (key, axis) in zip(tup, self.obj._AXIS_ORDERS)}
+        return self.obj._reindex_with_indexers(d, allow_dups=True)
+
+    def _getitem_iterable(self, key, axis: AxisInt):
+        self._validate_key(key, axis)
+        (keyarr, indexer) = self._get_listlike_indexer(key, axis)
+        return self.obj._reindex_with_indexers({axis: [keyarr, indexer]}, allow_dups=True)
+
+    def _getitem_tuple(self, tup: tuple):
+        with suppress(IndexingError):
+            tup = self._expand_ellipsis(tup)
+            return self._getitem_lowerdim(tup)
+        tup = self._validate_tuple_indexer(tup)
+        if self._multi_take_opportunity(tup):
+            return self._multi_take(tup)
+        return self._getitem_tuple_same_dim(tup)
+
+    def _get_label(self, label, axis: AxisInt):
+        return self.obj.xs(label, axis=axis)
+
+    def _handle_lowerdim_multi_index_axis0(self, tup: tuple):
+        axis = self.axis or 0
+        try:
+            return self._get_label(tup, axis=axis)
+        except KeyError as ek:
+            if self.ndim < len(tup) <= self.obj.index.nlevels:
+                raise ek
+            raise IndexingError('No label returned') from ek
+
+    def _getitem_axis(self, key, axis: AxisInt):
+        key = item_from_zerodim(key)
+        if is_iterator(key):
+            key = list(key)
+        if key is Ellipsis:
+            key = slice(None)
+        labels = self.obj._get_axis(axis)
+        if isinstance(key, tuple) and isinstance(labels, MultiIndex):
+            key = tuple(key)
+        if isinstance(key, slice):
+            self._validate_key(key, axis)
+            return self._get_slice_axis(key, axis=axis)
+        elif com.is_bool_indexer(key):
+            return self._getbool_axis(key, axis=axis)
+        elif is_list_like_indexer(key):
+            if not (isinstance(key, tuple) and isinstance(labels, MultiIndex)):
+                if hasattr(key, 'ndim') and key.ndim > 1:
+                    raise ValueError('Cannot index with multidimensional key')
+                return self._getitem_iterable(key, axis=axis)
+            if is_nested_tuple(key, labels):
+                locs = labels.get_locs(key)
+                indexer: list[slice | npt.NDArray[np.intp]] = [slice(None)] * self.ndim
+                indexer[axis] = locs
+                return self.obj.iloc[tuple(indexer)]
+        self._validate_key(key, axis)
+        return self._get_label(key, axis=axis)
+
+    def _get_slice_axis(self, slice_obj: slice, axis: AxisInt):
+        obj = self.obj
+        if not need_slice(slice_obj):
+            return obj.copy(deep=False)
+        labels = obj._get_axis(axis)
+        indexer = labels.slice_indexer(slice_obj.start, slice_obj.stop, slice_obj.step)
+        if isinstance(indexer, slice):
+            return self.obj._slice(indexer, axis=axis)
+        else:
+            return self.obj.take(indexer, axis=axis)
+
+    def _convert_to_indexer(self, key, axis: AxisInt):
+        labels = self.obj._get_axis(axis)
+        if isinstance(key, slice):
+            return labels._convert_slice_indexer(key, kind='loc')
+        if isinstance(key, tuple) and (not isinstance(labels, MultiIndex)) and (self.ndim < 2) and (len(key) > 1):
+            raise IndexingError('Too many indexers')
+        contains_slice = False
+        if isinstance(key, tuple):
+            contains_slice = any((isinstance(v, slice) for v in key))
+        if is_scalar(key) or (isinstance(labels, MultiIndex) and is_hashable(key) and (not contains_slice)):
+            try:
+                return labels.get_loc(key)
+            except LookupError:
+                if isinstance(key, tuple) and isinstance(labels, MultiIndex):
+                    if len(key) == labels.nlevels:
+                        return {'key': key}
+                    raise
+            except InvalidIndexError:
+                if not isinstance(labels, MultiIndex):
+                    raise
+            except ValueError:
+                if not is_integer(key):
+                    raise
+                return {'key': key}
+        if is_nested_tuple(key, labels):
+            if self.ndim == 1 and any((isinstance(k, tuple) for k in key)):
+                raise IndexingError('Too many indexers')
+            return labels.get_locs(key)
+        elif is_list_like_indexer(key):
+            if is_iterator(key):
+                key = list(key)
+            if com.is_bool_indexer(key):
+                key = check_bool_indexer(labels, key)
+                return key
+            else:
+                return self._get_listlike_indexer(key, axis)[1]
+        else:
+            try:
+                return labels.get_loc(key)
+            except LookupError:
+                if not is_list_like_indexer(key):
+                    return {'key': key}
+                raise
+
+    def _get_listlike_indexer(self, key, axis: AxisInt):
+        ax = self.obj._get_axis(axis)
+        axis_name = self.obj._get_axis_name(axis)
+        (keyarr, indexer) = ax._get_indexer_strict(key, axis_name)
+        return (keyarr, indexer)
+
+@doc(IndexingMixin.iloc)
+class _iLocIndexer(_LocationIndexer):
+    _valid_types = 'integer, integer slice (START point is INCLUDED, END point is EXCLUDED), listlike of integers, boolean array'
+    _takeable = True
+
+    def _validate_key(self, key, axis: AxisInt) -> None:
+        if com.is_bool_indexer(key):
+            if hasattr(key, 'index') and isinstance(key.index, Index):
+                if key.index.inferred_type == 'integer':
+                    raise NotImplementedError('iLocation based boolean indexing on an integer type is not available')
+                raise ValueError('iLocation based boolean indexing cannot use an indexable as a mask')
+            return
+        if isinstance(key, slice):
+            return
+        elif is_integer(key):
+            self._validate_integer(key, axis)
+        elif isinstance(key, tuple):
+            raise IndexingError('Too many indexers')
+        elif is_list_like_indexer(key):
+            if isinstance(key, ABCSeries):
+                arr = key._values
+            elif is_array_like(key):
+                arr = key
+            else:
+                arr = np.array(key)
+            len_axis = len(self.obj._get_axis(axis))
+            if not is_numeric_dtype(arr.dtype):
+                raise IndexError(f'.iloc requires numeric indexers, got {arr}')
+            if len(arr) and (arr.max() >= len_axis or arr.min() < -len_axis):
+                raise IndexError('positional indexers are out-of-bounds')
+        else:
+            raise ValueError(f'Can only index by location with a [{self._valid_types}]')
+
+    def _has_valid_setitem_indexer(self, indexer) -> bool:
+        if isinstance(indexer, dict):
+            raise IndexError('iloc cannot enlarge its target object')
+        if isinstance(indexer, ABCDataFrame):
+            raise TypeError('DataFrame indexer for .iloc is not supported. Consider using .loc with a DataFrame indexer for automatic alignment.')
+        if not isinstance(indexer, tuple):
+            indexer = _tuplify(self.ndim, indexer)
+        for (ax, i) in zip(self.obj.axes, indexer):
+            if isinstance(i, slice):
+                pass
+            elif is_list_like_indexer(i):
+                pass
+            elif is_integer(i):
+                if i >= len(ax):
+                    raise IndexError('iloc cannot enlarge its target object')
+            elif isinstance(i, dict):
+                raise IndexError('iloc cannot enlarge its target object')
+        return True
+
+    def _is_scalar_access(self, key: tuple) -> bool:
+        if len(key) != self.ndim:
+            return False
+        return all((is_integer(k) for k in key))
+
+    def _validate_integer(self, key: int | np.integer, axis: AxisInt) -> None:
+        len_axis = len(self.obj._get_axis(axis))
+        if key >= len_axis or key < -len_axis:
+            raise IndexError('single positional indexer is out-of-bounds')
+
+    def _getitem_tuple(self, tup: tuple):
+        tup = self._validate_tuple_indexer(tup)
+        with suppress(IndexingError):
+            return self._getitem_lowerdim(tup)
+        return self._getitem_tuple_same_dim(tup)
+
+    def _get_list_axis(self, key, axis: AxisInt):
+        try:
+            return self.obj.take(key, axis=axis)
+        except IndexError as err:
+            raise IndexError('positional indexers are out-of-bounds') from err
+
+    def _getitem_axis(self, key, axis: AxisInt):
+        if key is Ellipsis:
+            key = slice(None)
+        elif isinstance(key, ABCDataFrame):
+            raise IndexError('DataFrame indexer is not allowed for .iloc\nConsider using .loc for automatic alignment.')
+        if isinstance(key, slice):
+            return self._get_slice_axis(key, axis=axis)
+        if is_iterator(key):
+            key = list(key)
+        if isinstance(key, list):
+            key = np.asarray(key)
+        if com.is_bool_indexer(key):
+            self._validate_key(key, axis)
+            return self._getbool_axis(key, axis=axis)
+        elif is_list_like_indexer(key):
+            return self._get_list_axis(key, axis=axis)
+        else:
+            key = item_from_zerodim(key)
+            if not is_integer(key):
+                raise TypeError('Cannot index by location index with a non-integer key')
+            self._validate_integer(key, axis)
+            return self.obj._ixs(key, axis=axis)
+
+    def _get_slice_axis(self, slice_obj: slice, axis: AxisInt):
+        obj = self.obj
+        if not need_slice(slice_obj):
+            return obj.copy(deep=False)
+        labels = obj._get_axis(axis)
+        labels._validate_positional_slice(slice_obj)
+        return self.obj._slice(slice_obj, axis=axis)
+
+    def _convert_to_indexer(self, key: T, axis: AxisInt) -> T:
+        return key
+
+    def _get_setitem_indexer(self, key):
+        if is_iterator(key):
+            key = list(key)
+        if self.axis is not None:
+            key = _tupleize_axis_indexer(self.ndim, self.axis, key)
+        return key
+
+    def _setitem_with_indexer(self, indexer, value, name: str='iloc') -> None:
+        info_axis = self.obj._info_axis_number
+        take_split_path = not self.obj._mgr.is_single_block
+        if not take_split_path and isinstance(value, ABCDataFrame):
+            take_split_path = not value._mgr.is_single_block
+        if not take_split_path and len(self.obj._mgr.blocks) and (self.ndim > 1):
+            val = list(value.values()) if isinstance(value, dict) else value
+            arr = self.obj._mgr.blocks[0].values
+            take_split_path = not can_hold_element(arr, extract_array(val, extract_numpy=True))
+        if isinstance(indexer, tuple) and len(indexer) == len(self.obj.axes):
+            for (i, ax) in zip(indexer, self.obj.axes):
+                if isinstance(ax, MultiIndex) and (not (is_integer(i) or com.is_null_slice(i))):
+                    take_split_path = True
+                    break
+        if isinstance(indexer, tuple):
+            nindexer = []
+            for (i, idx) in enumerate(indexer):
+                if isinstance(idx, dict):
+                    (key, _) = convert_missing_indexer(idx)
+                    if self.ndim > 1 and i == info_axis:
+                        if not len(self.obj):
+                            if not is_list_like_indexer(value):
+                                raise ValueError('cannot set a frame with no defined index and a scalar')
+                            self.obj[key] = value
+                            return
+                        if com.is_null_slice(indexer[0]):
+                            self.obj[key] = value
+                            return
+                        elif is_array_like(value):
+                            arr = extract_array(value, extract_numpy=True)
+                            taker = -1 * np.ones(len(self.obj), dtype=np.intp)
+                            empty_value = algos.take_nd(arr, taker)
+                            if not isinstance(value, ABCSeries):
+                                if isinstance(arr, np.ndarray) and arr.ndim == 1 and (len(arr) == 1):
+                                    arr = arr[0, ...]
+                                empty_value[indexer[0]] = arr
+                                self.obj[key] = empty_value
+                                return
+                            self.obj[key] = empty_value
+                        elif not is_list_like(value):
+                            self.obj[key] = construct_1d_array_from_inferred_fill_value(value, len(self.obj))
+                        else:
+                            self.obj[key] = infer_fill_value(value)
+                        new_indexer = convert_from_missing_indexer_tuple(indexer, self.obj.axes)
+                        self._setitem_with_indexer(new_indexer, value, name)
+                        return
+                    index = self.obj._get_axis(i)
+                    labels = index.insert(len(index), key)
+                    taker = np.arange(len(index) + 1, dtype=np.intp)
+                    taker[-1] = -1
+                    reindexers = {i: (labels, taker)}
+                    new_obj = self.obj._reindex_with_indexers(reindexers, allow_dups=True)
+                    self.obj._mgr = new_obj._mgr
+                    nindexer.append(labels.get_loc(key))
+                else:
+                    nindexer.append(idx)
+            indexer = tuple(nindexer)
+        else:
+            (indexer, missing) = convert_missing_indexer(indexer)
+            if missing:
+                self._setitem_with_indexer_missing(indexer, value)
+                return
+        if name == 'loc':
+            (indexer, value) = self._maybe_mask_setitem_value(indexer, value)
+        if take_split_path:
+            self._setitem_with_indexer_split_path(indexer, value, name)
+        else:
+            self._setitem_single_block(indexer, value, name)
+
+    def _setitem_with_indexer_split_path(self, indexer, value, name: str):
+        assert self.ndim == 2
+        if not isinstance(indexer, tuple):
+            indexer = _tuplify(self.ndim, indexer)
+        if len(indexer) > self.ndim:
+            raise IndexError('too many indices for array')
+        if isinstance(indexer[0], np.ndarray) and indexer[0].ndim > 2:
+            raise ValueError('Cannot set values with ndim > 2')
+        if isinstance(value, ABCSeries) and name != 'iloc' or isinstance(value, dict):
+            from pandas import Series
+            value = self._align_series(indexer, Series(value))
+        info_axis = indexer[1]
+        ilocs = self._ensure_iterable_column_indexer(info_axis)
+        pi = indexer[0]
+        lplane_indexer = length_of_indexer(pi, self.obj.index)
+        if is_list_like_indexer(value) and getattr(value, 'ndim', 1) > 0:
+            if isinstance(value, ABCDataFrame):
+                self._setitem_with_indexer_frame_value(indexer, value, name)
+            elif np.ndim(value) == 2:
+                self._setitem_with_indexer_2d_value(indexer, value)
+            elif len(ilocs) == 1 and lplane_indexer == len(value) and (not is_scalar(pi)):
+                self._setitem_single_column(ilocs[0], value, pi)
+            elif len(ilocs) == 1 and 0 != lplane_indexer != len(value):
+                if len(value) == 1 and (not is_integer(info_axis)):
+                    return self._setitem_with_indexer((pi, info_axis[0]), value[0])
+                raise ValueError('Must have equal len keys and value when setting with an iterable')
+            elif lplane_indexer == 0 and len(value) == len(self.obj.index):
+                pass
+            elif self._is_scalar_access(indexer) and is_object_dtype(self.obj.dtypes._values[ilocs[0]]):
+                self._setitem_single_column(indexer[1], value, pi)
+            elif len(ilocs) == len(value):
+                for (loc, v) in zip(ilocs, value):
+                    self._setitem_single_column(loc, v, pi)
+            elif len(ilocs) == 1 and com.is_null_slice(pi) and (len(self.obj) == 0):
+                self._setitem_single_column(ilocs[0], value, pi)
+            else:
+                raise ValueError('Must have equal len keys and value when setting with an iterable')
+        else:
+            for loc in ilocs:
+                self._setitem_single_column(loc, value, pi)
+
+    def _setitem_with_indexer_2d_value(self, indexer, value) -> None:
+        pi = indexer[0]
+        ilocs = self._ensure_iterable_column_indexer(indexer[1])
+        if not is_array_like(value):
+            value = np.array(value, dtype=object)
+        if len(ilocs) != value.shape[1]:
+            raise ValueError('Must have equal len keys and value when setting with an ndarray')
+        for (i, loc) in enumerate(ilocs):
+            value_col = value[:, i]
+            if is_object_dtype(value_col.dtype):
+                value_col = value_col.tolist()
+            self._setitem_single_column(loc, value_col, pi)
+
+    def _setitem_with_indexer_frame_value(self, indexer, value: DataFrame, name: str) -> None:
+        ilocs = self._ensure_iterable_column_indexer(indexer[1])
+        sub_indexer = list(indexer)
+        pi = indexer[0]
+        multiindex_indexer = isinstance(self.obj.columns, MultiIndex)
+        unique_cols = value.columns.is_unique
+        if name == 'iloc':
+            for (i, loc) in enumerate(ilocs):
+                val = value.iloc[:, i]
+                self._setitem_single_column(loc, val, pi)
+        elif not unique_cols and value.columns.equals(self.obj.columns):
+            for loc in ilocs:
+                item = self.obj.columns[loc]
+                if item in value:
+                    sub_indexer[1] = item
+                    val = self._align_series(tuple(sub_indexer), value.iloc[:, loc], multiindex_indexer)
+                else:
+                    val = np.nan
+                self._setitem_single_column(loc, val, pi)
+        elif not unique_cols:
+            raise ValueError('Setting with non-unique columns is not allowed.')
+        else:
+            for loc in ilocs:
+                item = self.obj.columns[loc]
+                if item in value:
+                    sub_indexer[1] = item
+                    val = self._align_series(tuple(sub_indexer), value[item], multiindex_indexer, using_cow=True)
+                else:
+                    val = np.nan
+                self._setitem_single_column(loc, val, pi)
+
+    def _setitem_single_column(self, loc: int, value, plane_indexer) -> None:
+        pi = plane_indexer
+        is_full_setter = com.is_null_slice(pi) or com.is_full_slice(pi, len(self.obj))
+        is_null_setter = com.is_empty_slice(pi) or (is_array_like(pi) and len(pi) == 0)
+        if is_null_setter:
+            return
+        elif is_full_setter:
+            try:
+                self.obj._mgr.column_setitem(loc, plane_indexer, value, inplace_only=True)
+            except (ValueError, TypeError, LossySetitemError) as exc:
+                dtype = self.obj.dtypes.iloc[loc]
+                if dtype not in (np.void, object) and (not self.obj.empty):
+                    raise TypeError(f"Invalid value '{value}' for dtype '{dtype}'") from exc
+                self.obj.isetitem(loc, value)
+        else:
+            dtype = self.obj.dtypes.iloc[loc]
+            if dtype == np.void:
+                self.obj.iloc[:, loc] = construct_1d_array_from_inferred_fill_value(value, len(self.obj))
+            self.obj._mgr.column_setitem(loc, plane_indexer, value)
+
+    def _setitem_single_block(self, indexer, value, name: str) -> None:
+        from pandas import Series
+        if isinstance(value, ABCSeries) and name != 'iloc' or isinstance(value, dict):
+            value = self._align_series(indexer, Series(value))
+        info_axis = self.obj._info_axis_number
+        item_labels = self.obj._get_axis(info_axis)
+        if isinstance(indexer, tuple):
+            if self.ndim == len(indexer) == 2 and is_integer(indexer[1]) and com.is_null_slice(indexer[0]):
+                col = item_labels[indexer[info_axis]]
+                if len(item_labels.get_indexer_for([col])) == 1:
+                    loc = item_labels.get_loc(col)
+                    self._setitem_single_column(loc, value, indexer[0])
+                    return
+            indexer = maybe_convert_ix(*indexer)
+        if isinstance(value, ABCDataFrame) and name != 'iloc':
+            value = self._align_frame(indexer, value)._values
+        self.obj._mgr = self.obj._mgr.setitem(indexer=indexer, value=value)
+
+    def _setitem_with_indexer_missing(self, indexer, value):
+        from pandas import Series
+        if self.ndim == 1:
+            index = self.obj.index
+            new_index = index.insert(len(index), indexer)
+            if index.is_unique:
+                new_indexer = index.get_indexer(new_index[-1:])
+                if (new_indexer != -1).any():
+                    return self._setitem_with_indexer(new_indexer, value, 'loc')
+            if not is_scalar(value):
+                new_dtype = None
+            elif is_valid_na_for_dtype(value, self.obj.dtype):
+                if not is_object_dtype(self.obj.dtype):
+                    value = na_value_for_dtype(self.obj.dtype, compat=False)
+                new_dtype = maybe_promote(self.obj.dtype, value)[0]
+            elif isna(value):
+                new_dtype = None
+            elif not self.obj.empty and (not is_object_dtype(self.obj.dtype)):
+                curr_dtype = self.obj.dtype
+                curr_dtype = getattr(curr_dtype, 'numpy_dtype', curr_dtype)
+                new_dtype = maybe_promote(curr_dtype, value)[0]
+            else:
+                new_dtype = None
+            new_values = Series([value], dtype=new_dtype)._values
+            if len(self.obj._values):
+                new_values = concat_compat([self.obj._values, new_values])
+            self.obj._mgr = self.obj._constructor(new_values, index=new_index, name=self.obj.name)._mgr
+        elif self.ndim == 2:
+            if not len(self.obj.columns):
+                raise ValueError('cannot set a frame with no defined columns')
+            has_dtype = hasattr(value, 'dtype')
+            if isinstance(value, ABCSeries):
+                value = value.reindex(index=self.obj.columns)
+                value.name = indexer
+            elif isinstance(value, dict):
+                value = Series(value, index=self.obj.columns, name=indexer, dtype=object)
+            else:
+                if is_list_like_indexer(value):
+                    if len(value) != len(self.obj.columns):
+                        raise ValueError('cannot set a row with mismatched columns')
+                value = Series(value, index=self.obj.columns, name=indexer)
+            if not len(self.obj):
+                df = value.to_frame().T
+                idx = self.obj.index
+                if isinstance(idx, MultiIndex):
+                    name = idx.names
+                else:
+                    name = idx.name
+                df.index = Index([indexer], name=name)
+                if not has_dtype:
+                    df = df.infer_objects()
+                self.obj._mgr = df._mgr
+            else:
+                self.obj._mgr = self.obj._append(value)._mgr
+
+    def _ensure_iterable_column_indexer(self, column_indexer):
+        ilocs: Sequence[int | np.integer] | np.ndarray | range
+        if is_integer(column_indexer):
+            ilocs = [column_indexer]
+        elif isinstance(column_indexer, slice):
+            ilocs = range(len(self.obj.columns))[column_indexer]
+        elif isinstance(column_indexer, np.ndarray) and column_indexer.dtype.kind == 'b':
+            ilocs = np.arange(len(column_indexer))[column_indexer]
+        else:
+            ilocs = column_indexer
+        return ilocs
+
+    def _align_series(self, indexer, ser: Series, multiindex_indexer: bool=False, using_cow: bool=False):
+        if isinstance(indexer, (slice, np.ndarray, list, Index)):
+            indexer = (indexer,)
+        if isinstance(indexer, tuple):
+
+            def ravel(i):
+                return i.ravel() if isinstance(i, np.ndarray) else i
+            indexer = tuple(map(ravel, indexer))
+            aligners = [not com.is_null_slice(idx) for idx in indexer]
+            sum_aligners = sum(aligners)
+            single_aligner = sum_aligners == 1
+            is_frame = self.ndim == 2
+            obj = self.obj
+            if is_frame:
+                single_aligner = single_aligner and aligners[0]
+            if sum_aligners == self.ndim and all((is_sequence(_) for _ in indexer)):
+                ser_values = ser.reindex(obj.axes[0][indexer[0]])._values
+                if len(indexer) > 1 and (not multiindex_indexer):
+                    len_indexer = len(indexer[1])
+                    ser_values = np.tile(ser_values, len_indexer).reshape(len_indexer, -1).T
+                return ser_values
+            for (i, idx) in enumerate(indexer):
+                ax = obj.axes[i]
+                if is_sequence(idx) or isinstance(idx, slice):
+                    if single_aligner and com.is_null_slice(idx):
+                        continue
+                    new_ix = ax[idx]
+                    if not is_list_like_indexer(new_ix):
+                        new_ix = Index([new_ix])
+                    else:
+                        new_ix = Index(new_ix)
+                    if not len(new_ix) or ser.index.equals(new_ix):
+                        if using_cow:
+                            return ser
+                        return ser._values.copy()
+                    return ser.reindex(new_ix)._values
+                elif single_aligner:
+                    ax = self.obj.axes[1]
+                    if ser.index.equals(ax) or not len(ax):
+                        return ser._values.copy()
+                    return ser.reindex(ax)._values
+        elif is_integer(indexer) and self.ndim == 1:
+            if is_object_dtype(self.obj.dtype):
+                return ser
+            ax = self.obj._get_axis(0)
+            if ser.index.equals(ax):
+                return ser._values.copy()
+            return ser.reindex(ax)._values[indexer]
+        elif is_integer(indexer):
+            ax = self.obj._get_axis(1)
+            if ser.index.equals(ax):
+                return ser._values.copy()
+            return ser.reindex(ax)._values
+        raise ValueError('Incompatible indexer with Series')
+
+    def _align_frame(self, indexer, df: DataFrame) -> DataFrame:
+        is_frame = self.ndim == 2
+        if isinstance(indexer, tuple):
+            (idx, cols) = (None, None)
+            sindexers = []
+            for (i, ix) in enumerate(indexer):
+                ax = self.obj.axes[i]
+                if is_sequence(ix) or isinstance(ix, slice):
+                    if isinstance(ix, np.ndarray):
+                        ix = ix.reshape(-1)
+                    if idx is None:
+                        idx = ax[ix]
+                    elif cols is None:
+                        cols = ax[ix]
+                    else:
+                        break
+                else:
+                    sindexers.append(i)
+            if idx is not None and cols is not None:
+                if df.index.equals(idx) and df.columns.equals(cols):
+                    val = df.copy()
+                else:
+                    val = df.reindex(idx, columns=cols)
+                return val
+        elif (isinstance(indexer, slice) or is_list_like_indexer(indexer)) and is_frame:
+            ax = self.obj.index[indexer]
+            if df.index.equals(ax):
+                val = df.copy()
+            else:
+                if isinstance(ax, MultiIndex) and isinstance(df.index, MultiIndex) and (ax.nlevels != df.index.nlevels):
+                    raise TypeError('cannot align on a multi-index with out specifying the join levels')
+                val = df.reindex(index=ax)
+            return val
+        raise ValueError('Incompatible indexer with DataFrame')
+
+class _ScalarAccessIndexer(NDFrameIndexerBase):
+    _takeable: bool
+
+    def _convert_key(self, key):
+        raise AbstractMethodError(self)
+
+    def __getitem__(self, key):
+        if not isinstance(key, tuple):
+            if not is_list_like_indexer(key):
+                key = (key,)
+            else:
+                raise ValueError('Invalid call for scalar access (getting)!')
+        key = self._convert_key(key)
+        return self.obj._get_value(*key, takeable=self._takeable)
+
+    def __setitem__(self, key, value) -> None:
+        if isinstance(key, tuple):
+            key = tuple((com.apply_if_callable(x, self.obj) for x in key))
+        else:
+            key = com.apply_if_callable(key, self.obj)
+        if not isinstance(key, tuple):
+            key = _tuplify(self.ndim, key)
+        key = list(self._convert_key(key))
+        if len(key) != self.ndim:
+            raise ValueError('Not enough indexers for scalar access (setting)!')
+        self.obj._set_value(*key, value=value, takeable=self._takeable)
+
+@doc(IndexingMixin.at)
+class _AtIndexer(_ScalarAccessIndexer):
+    _takeable = False
+
+    def _convert_key(self, key):
+        if self.ndim == 1 and len(key) > 1:
+            key = (key,)
+        return key
+
+    @property
+    def _axes_are_unique(self) -> bool:
+        assert self.ndim == 2
+        return self.obj.index.is_unique and self.obj.columns.is_unique
+
+    def __getitem__(self, key):
+        if self.ndim == 2 and (not self._axes_are_unique):
+            if not isinstance(key, tuple) or not all((is_scalar(x) for x in key)):
+                raise ValueError('Invalid call for scalar access (getting)!')
+            return self.obj.loc[key]
+        return super().__getitem__(key)
+
+    def __setitem__(self, key, value) -> None:
+        if self.ndim == 2 and (not self._axes_are_unique):
+            if not isinstance(key, tuple) or not all((is_scalar(x) for x in key)):
+                raise ValueError('Invalid call for scalar access (setting)!')
+            self.obj.loc[key] = value
+            return
+        return super().__setitem__(key, value)
+
+@doc(IndexingMixin.iat)
+class _iAtIndexer(_ScalarAccessIndexer):
+    _takeable = True
+
+    def _convert_key(self, key):
+        for i in key:
+            if not is_integer(i):
+                raise ValueError('iAt based indexing can only have integer indexers')
+        return key
+
+def _tuplify(ndim: int, loc: Hashable) -> tuple[Hashable | slice, ...]:
+    _tup: list[Hashable | slice]
+    _tup = [slice(None, None) for _ in range(ndim)]
+    _tup[0] = loc
+    return tuple(_tup)
+
+def _tupleize_axis_indexer(ndim: int, axis: AxisInt, key) -> tuple:
+    new_key = [slice(None)] * ndim
+    new_key[axis] = key
+    return tuple(new_key)
+
+def check_bool_indexer(index: Index, key) -> np.ndarray:
+    result = key
+    if isinstance(key, ABCSeries) and (not key.index.equals(index)):
+        indexer = result.index.get_indexer_for(index)
+        if -1 in indexer:
+            raise IndexingError('Unalignable boolean Series provided as indexer (index of the boolean Series and of the indexed object do not match).')
+        result = result.take(indexer)
+        if not isinstance(result.dtype, ExtensionDtype):
+            return result.astype(bool)._values
+    if is_object_dtype(key):
+        result = np.asarray(result, dtype=bool)
+    elif not is_array_like(result):
+        result = pd_array(result, dtype=bool)
+    return check_array_indexer(index, result)
+
+def convert_missing_indexer(indexer):
+    if isinstance(indexer, dict):
+        indexer = indexer['key']
+        if isinstance(indexer, bool):
+            raise KeyError('cannot use a single bool to index into setitem')
+        return (indexer, True)
+    return (indexer, False)
+
+def convert_from_missing_indexer_tuple(indexer, axes):
+
+    def get_indexer(_i, _idx):
+        return axes[_i].get_loc(_idx['key']) if isinstance(_idx, dict) else _idx
+    return tuple((get_indexer(_i, _idx) for (_i, _idx) in enumerate(indexer)))
+
+def maybe_convert_ix(*args):
+    for arg in args:
+        if not isinstance(arg, (np.ndarray, list, ABCSeries, Index)):
+            return args
+    return np.ix_(*args)
+
+def is_nested_tuple(tup, labels) -> bool:
+    if not isinstance(tup, tuple):
+        return False
+    for k in tup:
+        if is_list_like(k) or isinstance(k, slice):
+            return isinstance(labels, MultiIndex)
+    return False
+
+def is_label_like(key) -> bool:
+    return not isinstance(key, slice) and (not is_list_like_indexer(key)) and (key is not Ellipsis)
+
+def need_slice(obj: slice) -> bool:
+    return obj.start is not None or obj.stop is not None or (obj.step is not None and obj.step != 1)
+
+def check_dict_or_set_indexers(key) -> None:
+    if isinstance(key, set) or (isinstance(key, tuple) and any((isinstance(x, set) for x in key))):
+        raise TypeError('Passing a set as an indexer is not supported. Use a list instead.')
+    if isinstance(key, dict) or (isinstance(key, tuple) and any((isinstance(x, dict) for x in key))):
+        raise TypeError('Passing a dict as an indexer is not supported. Use a list instead.')
+
+# File: pandas-main/pandas/core/interchange/buffer.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from pandas.core.interchange.dataframe_protocol import Buffer, DlpackDeviceType
+if TYPE_CHECKING:
+    import numpy as np
+    import pyarrow as pa
+
+class PandasBuffer(Buffer):
+
+    def __init__(self, x: np.ndarray, allow_copy: bool=True) -> None:
+        if x.strides[0] and (not x.strides == (x.dtype.itemsize,)):
+            if allow_copy:
+                x = x.copy()
+            else:
+                raise RuntimeError('Exports cannot be zero-copy in the case of a non-contiguous buffer')
+        self._x = x
+
+    @property
+    def bufsize(self) -> int:
+        return self._x.size * self._x.dtype.itemsize
+
+    @property
+    def ptr(self) -> int:
+        return self._x.__array_interface__['data'][0]
+
+    def __dlpack__(self) -> Any:
+        return self._x.__dlpack__()
+
+    def __dlpack_device__(self) -> tuple[DlpackDeviceType, int | None]:
+        return (DlpackDeviceType.CPU, None)
+
+    def __repr__(self) -> str:
+        return 'PandasBuffer(' + str({'bufsize': self.bufsize, 'ptr': self.ptr, 'device': self.__dlpack_device__()[0].name}) + ')'
+
+class PandasBufferPyarrow(Buffer):
+
+    def __init__(self, buffer: pa.Buffer, *, length: int) -> None:
+        self._buffer = buffer
+        self._length = length
+
+    @property
+    def bufsize(self) -> int:
+        return self._buffer.size
+
+    @property
+    def ptr(self) -> int:
+        return self._buffer.address
+
+    def __dlpack__(self) -> Any:
+        raise NotImplementedError
+
+    def __dlpack_device__(self) -> tuple[DlpackDeviceType, int | None]:
+        return (DlpackDeviceType.CPU, None)
+
+    def __repr__(self) -> str:
+        return 'PandasBuffer[pyarrow](' + str({'bufsize': self.bufsize, 'ptr': self.ptr, 'device': 'CPU'}) + ')'
+
+# File: pandas-main/pandas/core/interchange/column.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+import numpy as np
+from pandas._libs.lib import infer_dtype
+from pandas._libs.tslibs import iNaT
+from pandas.errors import NoBufferPresent
+from pandas.util._decorators import cache_readonly
+from pandas.core.dtypes.dtypes import BaseMaskedDtype
+import pandas as pd
+from pandas import ArrowDtype, DatetimeTZDtype
+from pandas.api.types import is_string_dtype
+from pandas.core.interchange.buffer import PandasBuffer, PandasBufferPyarrow
+from pandas.core.interchange.dataframe_protocol import Column, ColumnBuffers, ColumnNullType, DtypeKind
+from pandas.core.interchange.utils import ArrowCTypes, Endianness, dtype_to_arrow_c_fmt
+if TYPE_CHECKING:
+    from pandas.core.interchange.dataframe_protocol import Buffer
+_NP_KINDS = {'i': DtypeKind.INT, 'u': DtypeKind.UINT, 'f': DtypeKind.FLOAT, 'b': DtypeKind.BOOL, 'U': DtypeKind.STRING, 'M': DtypeKind.DATETIME, 'm': DtypeKind.DATETIME}
+_NULL_DESCRIPTION = {DtypeKind.FLOAT: (ColumnNullType.USE_NAN, None), DtypeKind.DATETIME: (ColumnNullType.USE_SENTINEL, iNaT), DtypeKind.INT: (ColumnNullType.NON_NULLABLE, None), DtypeKind.UINT: (ColumnNullType.NON_NULLABLE, None), DtypeKind.BOOL: (ColumnNullType.NON_NULLABLE, None), DtypeKind.CATEGORICAL: (ColumnNullType.USE_SENTINEL, -1), DtypeKind.STRING: (ColumnNullType.USE_BYTEMASK, 0)}
+_NO_VALIDITY_BUFFER = {ColumnNullType.NON_NULLABLE: 'This column is non-nullable', ColumnNullType.USE_NAN: 'This column uses NaN as null', ColumnNullType.USE_SENTINEL: 'This column uses a sentinel value'}
+
+class PandasColumn(Column):
+
+    def __init__(self, column: pd.Series, allow_copy: bool=True) -> None:
+        if isinstance(column, pd.DataFrame):
+            raise TypeError(f'Expected a Series, got a DataFrame. This likely happened because you called __dataframe__ on a DataFrame which, after converting column names to string, resulted in duplicated names: {column.columns}. Please rename these columns before using the interchange protocol.')
+        if not isinstance(column, pd.Series):
+            raise NotImplementedError(f'Columns of type {type(column)} not handled yet')
+        self._col = column
+        self._allow_copy = allow_copy
+
+    def size(self) -> int:
+        return self._col.size
+
+    @property
+    def offset(self) -> int:
+        return 0
+
+    @cache_readonly
+    def dtype(self) -> tuple[DtypeKind, int, str, str]:
+        dtype = self._col.dtype
+        if isinstance(dtype, pd.CategoricalDtype):
+            codes = self._col.values.codes
+            (_, bitwidth, c_arrow_dtype_f_str, _) = self._dtype_from_pandasdtype(codes.dtype)
+            return (DtypeKind.CATEGORICAL, bitwidth, c_arrow_dtype_f_str, Endianness.NATIVE)
+        elif is_string_dtype(dtype):
+            if infer_dtype(self._col) in ('string', 'empty'):
+                return (DtypeKind.STRING, 8, dtype_to_arrow_c_fmt(dtype), Endianness.NATIVE)
+            raise NotImplementedError('Non-string object dtypes are not supported yet')
+        else:
+            return self._dtype_from_pandasdtype(dtype)
+
+    def _dtype_from_pandasdtype(self, dtype) -> tuple[DtypeKind, int, str, str]:
+        kind = _NP_KINDS.get(dtype.kind, None)
+        if kind is None:
+            raise ValueError(f'Data type {dtype} not supported by interchange protocol')
+        if isinstance(dtype, ArrowDtype):
+            byteorder = dtype.numpy_dtype.byteorder
+        elif isinstance(dtype, DatetimeTZDtype):
+            byteorder = dtype.base.byteorder
+        elif isinstance(dtype, BaseMaskedDtype):
+            byteorder = dtype.numpy_dtype.byteorder
+        else:
+            byteorder = dtype.byteorder
+        if dtype == 'bool[pyarrow]':
+            return (kind, dtype.itemsize, ArrowCTypes.BOOL, byteorder)
+        return (kind, dtype.itemsize * 8, dtype_to_arrow_c_fmt(dtype), byteorder)
+
+    @property
+    def describe_categorical(self):
+        if not self.dtype[0] == DtypeKind.CATEGORICAL:
+            raise TypeError('describe_categorical only works on a column with categorical dtype!')
+        return {'is_ordered': self._col.cat.ordered, 'is_dictionary': True, 'categories': PandasColumn(pd.Series(self._col.cat.categories))}
+
+    @property
+    def describe_null(self):
+        if isinstance(self._col.dtype, BaseMaskedDtype):
+            column_null_dtype = ColumnNullType.USE_BYTEMASK
+            null_value = 1
+            return (column_null_dtype, null_value)
+        if isinstance(self._col.dtype, ArrowDtype):
+            if self._col.array._pa_array.chunks[0].buffers()[0] is None:
+                return (ColumnNullType.NON_NULLABLE, None)
+            return (ColumnNullType.USE_BITMASK, 0)
+        kind = self.dtype[0]
+        try:
+            (null, value) = _NULL_DESCRIPTION[kind]
+        except KeyError as err:
+            raise NotImplementedError(f'Data type {kind} not yet supported') from err
+        return (null, value)
+
+    @cache_readonly
+    def null_count(self) -> int:
+        return self._col.isna().sum().item()
+
+    @property
+    def metadata(self) -> dict[str, pd.Index]:
+        return {'pandas.index': self._col.index}
+
+    def num_chunks(self) -> int:
+        return 1
+
+    def get_chunks(self, n_chunks: int | None=None):
+        if n_chunks and n_chunks > 1:
+            size = len(self._col)
+            step = size // n_chunks
+            if size % n_chunks != 0:
+                step += 1
+            for start in range(0, step * n_chunks, step):
+                yield PandasColumn(self._col.iloc[start:start + step], self._allow_copy)
+        else:
+            yield self
+
+    def get_buffers(self) -> ColumnBuffers:
+        buffers: ColumnBuffers = {'data': self._get_data_buffer(), 'validity': None, 'offsets': None}
+        try:
+            buffers['validity'] = self._get_validity_buffer()
+        except NoBufferPresent:
+            pass
+        try:
+            buffers['offsets'] = self._get_offsets_buffer()
+        except NoBufferPresent:
+            pass
+        return buffers
+
+    def _get_data_buffer(self) -> tuple[Buffer, tuple[DtypeKind, int, str, str]]:
+        buffer: Buffer
+        if self.dtype[0] == DtypeKind.DATETIME:
+            if len(self.dtype[2]) > 4:
+                np_arr = self._col.dt.tz_convert(None).to_numpy()
+            else:
+                np_arr = self._col.to_numpy()
+            buffer = PandasBuffer(np_arr, allow_copy=self._allow_copy)
+            dtype = (DtypeKind.INT, 64, ArrowCTypes.INT64, Endianness.NATIVE)
+        elif self.dtype[0] in (DtypeKind.INT, DtypeKind.UINT, DtypeKind.FLOAT, DtypeKind.BOOL):
+            dtype = self.dtype
+            arr = self._col.array
+            if isinstance(self._col.dtype, ArrowDtype):
+                arr = arr._pa_array.chunks[0]
+                buffer = PandasBufferPyarrow(arr.buffers()[1], length=len(arr))
+                return (buffer, dtype)
+            if isinstance(self._col.dtype, BaseMaskedDtype):
+                np_arr = arr._data
+            else:
+                np_arr = arr._ndarray
+            buffer = PandasBuffer(np_arr, allow_copy=self._allow_copy)
+        elif self.dtype[0] == DtypeKind.CATEGORICAL:
+            codes = self._col.values._codes
+            buffer = PandasBuffer(codes, allow_copy=self._allow_copy)
+            dtype = self._dtype_from_pandasdtype(codes.dtype)
+        elif self.dtype[0] == DtypeKind.STRING:
+            buf = self._col.to_numpy()
+            b = bytearray()
+            for obj in buf:
+                if isinstance(obj, str):
+                    b.extend(obj.encode(encoding='utf-8'))
+            buffer = PandasBuffer(np.frombuffer(b, dtype='uint8'))
+            dtype = (DtypeKind.UINT, 8, ArrowCTypes.UINT8, Endianness.NATIVE)
+        else:
+            raise NotImplementedError(f'Data type {self._col.dtype} not handled yet')
+        return (buffer, dtype)
+
+    def _get_validity_buffer(self) -> tuple[Buffer, Any] | None:
+        (null, invalid) = self.describe_null
+        buffer: Buffer
+        if isinstance(self._col.dtype, ArrowDtype):
+            arr = self._col.array._pa_array.chunks[0]
+            dtype = (DtypeKind.BOOL, 1, ArrowCTypes.BOOL, Endianness.NATIVE)
+            if arr.buffers()[0] is None:
+                return None
+            buffer = PandasBufferPyarrow(arr.buffers()[0], length=len(arr))
+            return (buffer, dtype)
+        if isinstance(self._col.dtype, BaseMaskedDtype):
+            mask = self._col.array._mask
+            buffer = PandasBuffer(mask)
+            dtype = (DtypeKind.BOOL, 8, ArrowCTypes.BOOL, Endianness.NATIVE)
+            return (buffer, dtype)
+        if self.dtype[0] == DtypeKind.STRING:
+            buf = self._col.to_numpy()
+            valid = invalid == 0
+            invalid = not valid
+            mask = np.zeros(shape=(len(buf),), dtype=np.bool_)
+            for (i, obj) in enumerate(buf):
+                mask[i] = valid if isinstance(obj, str) else invalid
+            buffer = PandasBuffer(mask)
+            dtype = (DtypeKind.BOOL, 8, ArrowCTypes.BOOL, Endianness.NATIVE)
+            return (buffer, dtype)
+        try:
+            msg = f'{_NO_VALIDITY_BUFFER[null]} so does not have a separate mask'
+        except KeyError as err:
+            raise NotImplementedError('See self.describe_null') from err
+        raise NoBufferPresent(msg)
+
+    def _get_offsets_buffer(self) -> tuple[PandasBuffer, Any]:
+        if self.dtype[0] == DtypeKind.STRING:
+            values = self._col.to_numpy()
+            ptr = 0
+            offsets = np.zeros(shape=(len(values) + 1,), dtype=np.int64)
+            for (i, v) in enumerate(values):
+                if isinstance(v, str):
+                    b = v.encode(encoding='utf-8')
+                    ptr += len(b)
+                offsets[i + 1] = ptr
+            buffer = PandasBuffer(offsets)
+            dtype = (DtypeKind.INT, 64, ArrowCTypes.INT64, Endianness.NATIVE)
+        else:
+            raise NoBufferPresent('This column has a fixed-length dtype so it does not have an offsets buffer')
+        return (buffer, dtype)
+
+# File: pandas-main/pandas/core/interchange/dataframe.py
+from __future__ import annotations
+from collections import abc
+from typing import TYPE_CHECKING
+from pandas.core.interchange.column import PandasColumn
+from pandas.core.interchange.dataframe_protocol import DataFrame as DataFrameXchg
+from pandas.core.interchange.utils import maybe_rechunk
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+    from pandas import DataFrame, Index
+
+class PandasDataFrameXchg(DataFrameXchg):
+
+    def __init__(self, df: DataFrame, allow_copy: bool=True) -> None:
+        self._df = df.rename(columns=str)
+        self._allow_copy = allow_copy
+        for (i, _col) in enumerate(self._df.columns):
+            rechunked = maybe_rechunk(self._df.iloc[:, i], allow_copy=allow_copy)
+            if rechunked is not None:
+                self._df.isetitem(i, rechunked)
+
+    def __dataframe__(self, nan_as_null: bool=False, allow_copy: bool=True) -> PandasDataFrameXchg:
+        return PandasDataFrameXchg(self._df, allow_copy)
+
+    @property
+    def metadata(self) -> dict[str, Index]:
+        return {'pandas.index': self._df.index}
+
+    def num_columns(self) -> int:
+        return len(self._df.columns)
+
+    def num_rows(self) -> int:
+        return len(self._df)
+
+    def num_chunks(self) -> int:
+        return 1
+
+    def column_names(self) -> Index:
+        return self._df.columns
+
+    def get_column(self, i: int) -> PandasColumn:
+        return PandasColumn(self._df.iloc[:, i], allow_copy=self._allow_copy)
+
+    def get_column_by_name(self, name: str) -> PandasColumn:
+        return PandasColumn(self._df[name], allow_copy=self._allow_copy)
+
+    def get_columns(self) -> list[PandasColumn]:
+        return [PandasColumn(self._df[name], allow_copy=self._allow_copy) for name in self._df.columns]
+
+    def select_columns(self, indices: Sequence[int]) -> PandasDataFrameXchg:
+        if not isinstance(indices, abc.Sequence):
+            raise ValueError('`indices` is not a sequence')
+        if not isinstance(indices, list):
+            indices = list(indices)
+        return PandasDataFrameXchg(self._df.iloc[:, indices], allow_copy=self._allow_copy)
+
+    def select_columns_by_name(self, names: list[str]) -> PandasDataFrameXchg:
+        if not isinstance(names, abc.Sequence):
+            raise ValueError('`names` is not a sequence')
+        if not isinstance(names, list):
+            names = list(names)
+        return PandasDataFrameXchg(self._df.loc[:, names], allow_copy=self._allow_copy)
+
+    def get_chunks(self, n_chunks: int | None=None) -> Iterable[PandasDataFrameXchg]:
+        if n_chunks and n_chunks > 1:
+            size = len(self._df)
+            step = size // n_chunks
+            if size % n_chunks != 0:
+                step += 1
+            for start in range(0, step * n_chunks, step):
+                yield PandasDataFrameXchg(self._df.iloc[start:start + step, :], allow_copy=self._allow_copy)
+        else:
+            yield self
+
+# File: pandas-main/pandas/core/interchange/dataframe_protocol.py
+""""""
+from __future__ import annotations
+from abc import ABC, abstractmethod
+import enum
+from typing import TYPE_CHECKING, Any, TypedDict
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+
+class DlpackDeviceType(enum.IntEnum):
+    CPU = 1
+    CUDA = 2
+    CPU_PINNED = 3
+    OPENCL = 4
+    VULKAN = 7
+    METAL = 8
+    VPI = 9
+    ROCM = 10
+
+class DtypeKind(enum.IntEnum):
+    INT = 0
+    UINT = 1
+    FLOAT = 2
+    BOOL = 20
+    STRING = 21
+    DATETIME = 22
+    CATEGORICAL = 23
+
+class ColumnNullType(enum.IntEnum):
+    NON_NULLABLE = 0
+    USE_NAN = 1
+    USE_SENTINEL = 2
+    USE_BITMASK = 3
+    USE_BYTEMASK = 4
+
+class ColumnBuffers(TypedDict):
+    data: tuple[Buffer, Any]
+    validity: tuple[Buffer, Any] | None
+    offsets: tuple[Buffer, Any] | None
+
+class CategoricalDescription(TypedDict):
+    is_ordered: bool
+    is_dictionary: bool
+    categories: Column | None
+
+class Buffer(ABC):
+
+    @property
+    @abstractmethod
+    def bufsize(self) -> int:
+
+    @property
+    @abstractmethod
+    def ptr(self) -> int:
+
+    @abstractmethod
+    def __dlpack__(self):
+        raise NotImplementedError('__dlpack__')
+
+    @abstractmethod
+    def __dlpack_device__(self) -> tuple[DlpackDeviceType, int | None]:
+
+class Column(ABC):
+
+    @abstractmethod
+    def size(self) -> int:
+
+    @property
+    @abstractmethod
+    def offset(self) -> int:
+
+    @property
+    @abstractmethod
+    def dtype(self) -> tuple[DtypeKind, int, str, str]:
+
+    @property
+    @abstractmethod
+    def describe_categorical(self) -> CategoricalDescription:
+
+    @property
+    @abstractmethod
+    def describe_null(self) -> tuple[ColumnNullType, Any]:
+
+    @property
+    @abstractmethod
+    def null_count(self) -> int | None:
+
+    @property
+    @abstractmethod
+    def metadata(self) -> dict[str, Any]:
+
+    @abstractmethod
+    def num_chunks(self) -> int:
+
+    @abstractmethod
+    def get_chunks(self, n_chunks: int | None=None) -> Iterable[Column]:
+
+    @abstractmethod
+    def get_buffers(self) -> ColumnBuffers:
+
+class DataFrame(ABC):
+    version = 0
+
+    @abstractmethod
+    def __dataframe__(self, nan_as_null: bool=False, allow_copy: bool=True):
+
+    @property
+    @abstractmethod
+    def metadata(self) -> dict[str, Any]:
+
+    @abstractmethod
+    def num_columns(self) -> int:
+
+    @abstractmethod
+    def num_rows(self) -> int | None:
+
+    @abstractmethod
+    def num_chunks(self) -> int:
+
+    @abstractmethod
+    def column_names(self) -> Iterable[str]:
+
+    @abstractmethod
+    def get_column(self, i: int) -> Column:
+
+    @abstractmethod
+    def get_column_by_name(self, name: str) -> Column:
+
+    @abstractmethod
+    def get_columns(self) -> Iterable[Column]:
+
+    @abstractmethod
+    def select_columns(self, indices: Sequence[int]) -> DataFrame:
+
+    @abstractmethod
+    def select_columns_by_name(self, names: Sequence[str]) -> DataFrame:
+
+    @abstractmethod
+    def get_chunks(self, n_chunks: int | None=None) -> Iterable[DataFrame]:
+
+# File: pandas-main/pandas/core/interchange/from_dataframe.py
+from __future__ import annotations
+import ctypes
+import re
+from typing import Any, overload
+import numpy as np
+from pandas.compat._optional import import_optional_dependency
+import pandas as pd
+from pandas.core.interchange.dataframe_protocol import Buffer, Column, ColumnNullType, DataFrame as DataFrameXchg, DtypeKind
+from pandas.core.interchange.utils import ArrowCTypes, Endianness
+_NP_DTYPES: dict[DtypeKind, dict[int, Any]] = {DtypeKind.INT: {8: np.int8, 16: np.int16, 32: np.int32, 64: np.int64}, DtypeKind.UINT: {8: np.uint8, 16: np.uint16, 32: np.uint32, 64: np.uint64}, DtypeKind.FLOAT: {32: np.float32, 64: np.float64}, DtypeKind.BOOL: {1: bool, 8: bool}}
+
+def from_dataframe(df, allow_copy: bool=True) -> pd.DataFrame:
+    if isinstance(df, pd.DataFrame):
+        return df
+    if not hasattr(df, '__dataframe__'):
+        raise ValueError('`df` does not support __dataframe__')
+    return _from_dataframe(df.__dataframe__(allow_copy=allow_copy), allow_copy=allow_copy)
+
+def _from_dataframe(df: DataFrameXchg, allow_copy: bool=True) -> pd.DataFrame:
+    pandas_dfs = []
+    for chunk in df.get_chunks():
+        pandas_df = protocol_df_chunk_to_pandas(chunk)
+        pandas_dfs.append(pandas_df)
+    if not allow_copy and len(pandas_dfs) > 1:
+        raise RuntimeError('To join chunks a copy is required which is forbidden by allow_copy=False')
+    if not pandas_dfs:
+        pandas_df = protocol_df_chunk_to_pandas(df)
+    elif len(pandas_dfs) == 1:
+        pandas_df = pandas_dfs[0]
+    else:
+        pandas_df = pd.concat(pandas_dfs, axis=0, ignore_index=True, copy=False)
+    index_obj = df.metadata.get('pandas.index', None)
+    if index_obj is not None:
+        pandas_df.index = index_obj
+    return pandas_df
+
+def protocol_df_chunk_to_pandas(df: DataFrameXchg) -> pd.DataFrame:
+    columns: dict[str, Any] = {}
+    buffers = []
+    for name in df.column_names():
+        if not isinstance(name, str):
+            raise ValueError(f'Column {name} is not a string')
+        if name in columns:
+            raise ValueError(f'Column {name} is not unique')
+        col = df.get_column_by_name(name)
+        dtype = col.dtype[0]
+        if dtype in (DtypeKind.INT, DtypeKind.UINT, DtypeKind.FLOAT, DtypeKind.BOOL):
+            (columns[name], buf) = primitive_column_to_ndarray(col)
+        elif dtype == DtypeKind.CATEGORICAL:
+            (columns[name], buf) = categorical_column_to_series(col)
+        elif dtype == DtypeKind.STRING:
+            (columns[name], buf) = string_column_to_ndarray(col)
+        elif dtype == DtypeKind.DATETIME:
+            (columns[name], buf) = datetime_column_to_ndarray(col)
+        else:
+            raise NotImplementedError(f'Data type {dtype} not handled yet')
+        buffers.append(buf)
+    pandas_df = pd.DataFrame(columns)
+    pandas_df.attrs['_INTERCHANGE_PROTOCOL_BUFFERS'] = buffers
+    return pandas_df
+
+def primitive_column_to_ndarray(col: Column) -> tuple[np.ndarray, Any]:
+    buffers = col.get_buffers()
+    (data_buff, data_dtype) = buffers['data']
+    data = buffer_to_ndarray(data_buff, data_dtype, offset=col.offset, length=col.size())
+    data = set_nulls(data, col, buffers['validity'])
+    return (data, buffers)
+
+def categorical_column_to_series(col: Column) -> tuple[pd.Series, Any]:
+    categorical = col.describe_categorical
+    if not categorical['is_dictionary']:
+        raise NotImplementedError('Non-dictionary categoricals not supported yet')
+    cat_column = categorical['categories']
+    if hasattr(cat_column, '_col'):
+        categories = np.array(cat_column._col)
+    else:
+        raise NotImplementedError("Interchanging categorical columns isn't supported yet, and our fallback of using the `col._col` attribute (a ndarray) failed.")
+    buffers = col.get_buffers()
+    (codes_buff, codes_dtype) = buffers['data']
+    codes = buffer_to_ndarray(codes_buff, codes_dtype, offset=col.offset, length=col.size())
+    if len(categories) > 0:
+        values = categories[codes % len(categories)]
+    else:
+        values = codes
+    cat = pd.Categorical(values, categories=categories, ordered=categorical['is_ordered'])
+    data = pd.Series(cat)
+    data = set_nulls(data, col, buffers['validity'])
+    return (data, buffers)
+
+def string_column_to_ndarray(col: Column) -> tuple[np.ndarray, Any]:
+    (null_kind, sentinel_val) = col.describe_null
+    if null_kind not in (ColumnNullType.NON_NULLABLE, ColumnNullType.USE_BITMASK, ColumnNullType.USE_BYTEMASK):
+        raise NotImplementedError(f'{null_kind} null kind is not yet supported for string columns.')
+    buffers = col.get_buffers()
+    assert buffers['offsets'], 'String buffers must contain offsets'
+    (data_buff, _) = buffers['data']
+    assert col.dtype[2] in (ArrowCTypes.STRING, ArrowCTypes.LARGE_STRING)
+    data_dtype = (DtypeKind.UINT, 8, ArrowCTypes.UINT8, Endianness.NATIVE)
+    data = buffer_to_ndarray(data_buff, data_dtype, offset=0, length=data_buff.bufsize)
+    (offset_buff, offset_dtype) = buffers['offsets']
+    offsets = buffer_to_ndarray(offset_buff, offset_dtype, offset=col.offset, length=col.size() + 1)
+    null_pos = None
+    if null_kind in (ColumnNullType.USE_BITMASK, ColumnNullType.USE_BYTEMASK):
+        validity = buffers['validity']
+        if validity is not None:
+            (valid_buff, valid_dtype) = validity
+            null_pos = buffer_to_ndarray(valid_buff, valid_dtype, offset=col.offset, length=col.size())
+            if sentinel_val == 0:
+                null_pos = ~null_pos
+    str_list: list[None | float | str] = [None] * col.size()
+    for i in range(col.size()):
+        if null_pos is not None and null_pos[i]:
+            str_list[i] = np.nan
+            continue
+        units = data[offsets[i]:offsets[i + 1]]
+        str_bytes = bytes(units)
+        string = str_bytes.decode(encoding='utf-8')
+        str_list[i] = string
+    return (np.asarray(str_list, dtype='object'), buffers)
+
+def parse_datetime_format_str(format_str, data) -> pd.Series | np.ndarray:
+    timestamp_meta = re.match('ts([smun]):(.*)', format_str)
+    if timestamp_meta:
+        (unit, tz) = (timestamp_meta.group(1), timestamp_meta.group(2))
+        if unit != 's':
+            unit += 's'
+        data = data.astype(f'datetime64[{unit}]')
+        if tz != '':
+            data = pd.Series(data).dt.tz_localize('UTC').dt.tz_convert(tz)
+        return data
+    date_meta = re.match('td([Dm])', format_str)
+    if date_meta:
+        unit = date_meta.group(1)
+        if unit == 'D':
+            data = (data.astype(np.uint64) * (24 * 60 * 60)).astype('datetime64[s]')
+        elif unit == 'm':
+            data = data.astype('datetime64[ms]')
+        else:
+            raise NotImplementedError(f'Date unit is not supported: {unit}')
+        return data
+    raise NotImplementedError(f'DateTime kind is not supported: {format_str}')
+
+def datetime_column_to_ndarray(col: Column) -> tuple[np.ndarray | pd.Series, Any]:
+    buffers = col.get_buffers()
+    (_, col_bit_width, format_str, _) = col.dtype
+    (dbuf, _) = buffers['data']
+    data = buffer_to_ndarray(dbuf, (DtypeKind.INT, col_bit_width, getattr(ArrowCTypes, f'INT{col_bit_width}'), Endianness.NATIVE), offset=col.offset, length=col.size())
+    data = parse_datetime_format_str(format_str, data)
+    data = set_nulls(data, col, buffers['validity'])
+    return (data, buffers)
+
+def buffer_to_ndarray(buffer: Buffer, dtype: tuple[DtypeKind, int, str, str], *, length: int, offset: int=0) -> np.ndarray:
+    (kind, bit_width, _, _) = dtype
+    column_dtype = _NP_DTYPES.get(kind, {}).get(bit_width, None)
+    if column_dtype is None:
+        raise NotImplementedError(f'Conversion for {dtype} is not yet supported.')
+    ctypes_type = np.ctypeslib.as_ctypes_type(column_dtype)
+    if bit_width == 1:
+        assert length is not None, '`length` must be specified for a bit-mask buffer.'
+        pa = import_optional_dependency('pyarrow')
+        arr = pa.BooleanArray.from_buffers(pa.bool_(), length, [None, pa.foreign_buffer(buffer.ptr, length)], offset=offset)
+        return np.asarray(arr)
+    else:
+        data_pointer = ctypes.cast(buffer.ptr + offset * bit_width // 8, ctypes.POINTER(ctypes_type))
+        if length > 0:
+            return np.ctypeslib.as_array(data_pointer, shape=(length,))
+        return np.array([], dtype=ctypes_type)
+
+@overload
+def set_nulls(data: np.ndarray, col: Column, validity: tuple[Buffer, tuple[DtypeKind, int, str, str]] | None, allow_modify_inplace: bool=...) -> np.ndarray:
+    ...
+
+@overload
+def set_nulls(data: pd.Series, col: Column, validity: tuple[Buffer, tuple[DtypeKind, int, str, str]] | None, allow_modify_inplace: bool=...) -> pd.Series:
+    ...
+
+@overload
+def set_nulls(data: np.ndarray | pd.Series, col: Column, validity: tuple[Buffer, tuple[DtypeKind, int, str, str]] | None, allow_modify_inplace: bool=...) -> np.ndarray | pd.Series:
+    ...
+
+def set_nulls(data: np.ndarray | pd.Series, col: Column, validity: tuple[Buffer, tuple[DtypeKind, int, str, str]] | None, allow_modify_inplace: bool=True) -> np.ndarray | pd.Series:
+    if validity is None:
+        return data
+    (null_kind, sentinel_val) = col.describe_null
+    null_pos = None
+    if null_kind == ColumnNullType.USE_SENTINEL:
+        null_pos = pd.Series(data) == sentinel_val
+    elif null_kind in (ColumnNullType.USE_BITMASK, ColumnNullType.USE_BYTEMASK):
+        assert validity, 'Expected to have a validity buffer for the mask'
+        (valid_buff, valid_dtype) = validity
+        null_pos = buffer_to_ndarray(valid_buff, valid_dtype, offset=col.offset, length=col.size())
+        if sentinel_val == 0:
+            null_pos = ~null_pos
+    elif null_kind in (ColumnNullType.NON_NULLABLE, ColumnNullType.USE_NAN):
+        pass
+    else:
+        raise NotImplementedError(f'Null kind {null_kind} is not yet supported.')
+    if null_pos is not None and np.any(null_pos):
+        if not allow_modify_inplace:
+            data = data.copy()
+        try:
+            data[null_pos] = None
+        except TypeError:
+            data = data.astype(float)
+            data[null_pos] = None
+    return data
+
+# File: pandas-main/pandas/core/interchange/utils.py
+""""""
+from __future__ import annotations
+import typing
+import numpy as np
+from pandas._libs import lib
+from pandas.core.dtypes.dtypes import ArrowDtype, CategoricalDtype, DatetimeTZDtype
+import pandas as pd
+if typing.TYPE_CHECKING:
+    from pandas._typing import DtypeObj
+PYARROW_CTYPES = {'null': 'n', 'bool': 'b', 'uint8': 'C', 'uint16': 'S', 'uint32': 'I', 'uint64': 'L', 'int8': 'c', 'int16': 'S', 'int32': 'i', 'int64': 'l', 'halffloat': 'e', 'float': 'f', 'double': 'g', 'string': 'u', 'large_string': 'U', 'binary': 'z', 'time32[s]': 'tts', 'time32[ms]': 'ttm', 'time64[us]': 'ttu', 'time64[ns]': 'ttn', 'date32[day]': 'tdD', 'date64[ms]': 'tdm', 'timestamp[s]': 'tss:', 'timestamp[ms]': 'tsm:', 'timestamp[us]': 'tsu:', 'timestamp[ns]': 'tsn:', 'duration[s]': 'tDs', 'duration[ms]': 'tDm', 'duration[us]': 'tDu', 'duration[ns]': 'tDn'}
+
+class ArrowCTypes:
+    NULL = 'n'
+    BOOL = 'b'
+    INT8 = 'c'
+    UINT8 = 'C'
+    INT16 = 's'
+    UINT16 = 'S'
+    INT32 = 'i'
+    UINT32 = 'I'
+    INT64 = 'l'
+    UINT64 = 'L'
+    FLOAT16 = 'e'
+    FLOAT32 = 'f'
+    FLOAT64 = 'g'
+    STRING = 'u'
+    LARGE_STRING = 'U'
+    DATE32 = 'tdD'
+    DATE64 = 'tdm'
+    TIMESTAMP = 'ts{resolution}:{tz}'
+    TIME = 'tt{resolution}'
+
+class Endianness:
+    LITTLE = '<'
+    BIG = '>'
+    NATIVE = '='
+    NA = '|'
+
+def dtype_to_arrow_c_fmt(dtype: DtypeObj) -> str:
+    if isinstance(dtype, CategoricalDtype):
+        return ArrowCTypes.INT64
+    elif dtype == np.dtype('O'):
+        return ArrowCTypes.STRING
+    elif isinstance(dtype, ArrowDtype):
+        import pyarrow as pa
+        pa_type = dtype.pyarrow_dtype
+        if pa.types.is_decimal(pa_type):
+            return f'd:{pa_type.precision},{pa_type.scale}'
+        elif pa.types.is_timestamp(pa_type) and pa_type.tz is not None:
+            return f'ts{pa_type.unit[0]}:{pa_type.tz}'
+        format_str = PYARROW_CTYPES.get(str(pa_type), None)
+        if format_str is not None:
+            return format_str
+    format_str = getattr(ArrowCTypes, dtype.name.upper(), None)
+    if format_str is not None:
+        return format_str
+    if isinstance(dtype, pd.StringDtype):
+        return ArrowCTypes.STRING
+    elif lib.is_np_dtype(dtype, 'M'):
+        resolution = np.datetime_data(dtype)[0][0]
+        return ArrowCTypes.TIMESTAMP.format(resolution=resolution, tz='')
+    elif isinstance(dtype, DatetimeTZDtype):
+        return ArrowCTypes.TIMESTAMP.format(resolution=dtype.unit[0], tz=dtype.tz)
+    elif isinstance(dtype, pd.BooleanDtype):
+        return ArrowCTypes.BOOL
+    raise NotImplementedError(f'Conversion of {dtype} to Arrow C format string is not implemented.')
+
+def maybe_rechunk(series: pd.Series, *, allow_copy: bool) -> pd.Series | None:
+    if not isinstance(series.dtype, pd.ArrowDtype):
+        return None
+    chunked_array = series.array._pa_array
+    if len(chunked_array.chunks) == 1:
+        return None
+    if not allow_copy:
+        raise RuntimeError('Found multi-chunk pyarrow array, but `allow_copy` is False. Please rechunk the array before calling this function, or set `allow_copy=True`.')
+    arr = chunked_array.combine_chunks()
+    return pd.Series(arr, dtype=series.dtype, name=series.name, index=series.index)
+
+# File: pandas-main/pandas/core/internals/__init__.py
+from pandas.core.internals.api import make_block
+from pandas.core.internals.concat import concatenate_managers
+from pandas.core.internals.managers import BlockManager, SingleBlockManager
+__all__ = ['make_block', 'BlockManager', 'SingleBlockManager', 'concatenate_managers']
+
+# File: pandas-main/pandas/core/internals/api.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import warnings
+import numpy as np
+from pandas._libs.internals import BlockPlacement
+from pandas.core.dtypes.common import pandas_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype, ExtensionDtype, PeriodDtype
+from pandas.core.arrays import DatetimeArray, TimedeltaArray
+from pandas.core.construction import extract_array
+from pandas.core.internals.blocks import check_ndim, ensure_block_shape, extract_pandas_array, get_block_type, maybe_coerce_values
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike, Dtype
+    from pandas.core.internals.blocks import Block
+
+def _make_block(values: ArrayLike, placement: np.ndarray) -> Block:
+    dtype = values.dtype
+    klass = get_block_type(dtype)
+    placement_obj = BlockPlacement(placement)
+    if isinstance(dtype, ExtensionDtype) and dtype._supports_2d or isinstance(values, (DatetimeArray, TimedeltaArray)):
+        values = ensure_block_shape(values, ndim=2)
+    values = maybe_coerce_values(values)
+    return klass(values, ndim=2, placement=placement_obj)
+
+def make_block(values, placement, klass=None, ndim=None, dtype: Dtype | None=None) -> Block:
+    warnings.warn('make_block is deprecated and will be removed in a future version. Use pd.api.internals.create_dataframe_from_blocks or (recommended) higher-level public APIs instead.', DeprecationWarning, stacklevel=2)
+    if dtype is not None:
+        dtype = pandas_dtype(dtype)
+    (values, dtype) = extract_pandas_array(values, dtype, ndim)
+    from pandas.core.internals.blocks import ExtensionBlock
+    if klass is ExtensionBlock and isinstance(values.dtype, PeriodDtype):
+        klass = None
+    if klass is None:
+        dtype = dtype or values.dtype
+        klass = get_block_type(dtype)
+    if not isinstance(placement, BlockPlacement):
+        placement = BlockPlacement(placement)
+    ndim = maybe_infer_ndim(values, placement, ndim)
+    if isinstance(values.dtype, (PeriodDtype, DatetimeTZDtype)):
+        values = extract_array(values, extract_numpy=True)
+        values = ensure_block_shape(values, ndim)
+    check_ndim(values, placement, ndim)
+    values = maybe_coerce_values(values)
+    return klass(values, ndim=ndim, placement=placement)
+
+def maybe_infer_ndim(values, placement: BlockPlacement, ndim: int | None) -> int:
+    if ndim is None:
+        if not isinstance(values.dtype, np.dtype):
+            if len(placement) != 1:
+                ndim = 1
+            else:
+                ndim = 2
+        else:
+            ndim = values.ndim
+    return ndim
+
+# File: pandas-main/pandas/core/internals/blocks.py
+from __future__ import annotations
+import inspect
+import re
+from typing import TYPE_CHECKING, Any, Literal, cast, final
+import warnings
+import weakref
+import numpy as np
+from pandas._libs import NaT, internals as libinternals, lib
+from pandas._libs.internals import BlockPlacement, BlockValuesRefs
+from pandas._libs.missing import NA
+from pandas._typing import ArrayLike, AxisInt, DtypeBackend, DtypeObj, FillnaOptions, IgnoreRaise, InterpolateOptions, QuantileInterpolation, Self, Shape, npt
+from pandas.errors import AbstractMethodError, OutOfBoundsDatetime
+from pandas.util._decorators import cache_readonly
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import validate_bool_kwarg
+from pandas.core.dtypes.astype import astype_array_safe, astype_is_view
+from pandas.core.dtypes.cast import LossySetitemError, can_hold_element, convert_dtypes, find_result_type, np_can_hold_element
+from pandas.core.dtypes.common import is_1d_only_ea_dtype, is_float_dtype, is_integer_dtype, is_list_like, is_scalar, is_string_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype, ExtensionDtype, IntervalDtype, NumpyEADtype, PeriodDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCIndex, ABCNumpyExtensionArray, ABCSeries
+from pandas.core.dtypes.missing import is_valid_na_for_dtype, isna, na_value_for_dtype
+from pandas.core import missing
+import pandas.core.algorithms as algos
+from pandas.core.array_algos.putmask import extract_bool_array, putmask_inplace, putmask_without_repeat, setitem_datetimelike_compat, validate_putmask
+from pandas.core.array_algos.quantile import quantile_compat
+from pandas.core.array_algos.replace import compare_or_regex_search, replace_regex, should_use_regex
+from pandas.core.array_algos.transforms import shift
+from pandas.core.arrays import DatetimeArray, ExtensionArray, IntervalArray, NumpyExtensionArray, PeriodArray, TimedeltaArray
+from pandas.core.base import PandasObject
+import pandas.core.common as com
+from pandas.core.computation import expressions
+from pandas.core.construction import ensure_wrapped_if_datetimelike, extract_array
+from pandas.core.indexers import check_setitem_lengths
+from pandas.core.indexes.base import get_values_for_csv
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator, Iterable, Sequence
+    from pandas.core.api import Index
+    from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
+_dtype_obj = np.dtype('object')
+
+class Block(PandasObject, libinternals.Block):
+    values: np.ndarray | ExtensionArray
+    ndim: int
+    refs: BlockValuesRefs
+    __init__: Callable
+    __slots__ = ()
+    is_numeric = False
+
+    @final
+    @cache_readonly
+    def _validate_ndim(self) -> bool:
+        dtype = self.dtype
+        return not isinstance(dtype, ExtensionDtype) or isinstance(dtype, DatetimeTZDtype)
+
+    @final
+    @cache_readonly
+    def is_object(self) -> bool:
+        return self.values.dtype == _dtype_obj
+
+    @final
+    @cache_readonly
+    def is_extension(self) -> bool:
+        return not lib.is_np_dtype(self.values.dtype)
+
+    @final
+    @cache_readonly
+    def _can_consolidate(self) -> bool:
+        return not self.is_extension
+
+    @final
+    @cache_readonly
+    def _consolidate_key(self):
+        return (self._can_consolidate, self.dtype.name)
+
+    @final
+    @cache_readonly
+    def _can_hold_na(self) -> bool:
+        dtype = self.dtype
+        if isinstance(dtype, np.dtype):
+            return dtype.kind not in 'iub'
+        return dtype._can_hold_na
+
+    @final
+    @property
+    def is_bool(self) -> bool:
+        return self.values.dtype == np.dtype(bool)
+
+    @final
+    def external_values(self):
+        return external_values(self.values)
+
+    @final
+    @cache_readonly
+    def fill_value(self):
+        return na_value_for_dtype(self.dtype, compat=False)
+
+    @final
+    def _standardize_fill_value(self, value):
+        if self.dtype != _dtype_obj and is_valid_na_for_dtype(value, self.dtype):
+            value = self.fill_value
+        return value
+
+    @property
+    def mgr_locs(self) -> BlockPlacement:
+        return self._mgr_locs
+
+    @mgr_locs.setter
+    def mgr_locs(self, new_mgr_locs: BlockPlacement) -> None:
+        self._mgr_locs = new_mgr_locs
+
+    @final
+    def make_block(self, values, placement: BlockPlacement | None=None, refs: BlockValuesRefs | None=None) -> Block:
+        if placement is None:
+            placement = self._mgr_locs
+        if self.is_extension:
+            values = ensure_block_shape(values, ndim=self.ndim)
+        return new_block(values, placement=placement, ndim=self.ndim, refs=refs)
+
+    @final
+    def make_block_same_class(self, values, placement: BlockPlacement | None=None, refs: BlockValuesRefs | None=None) -> Self:
+        if placement is None:
+            placement = self._mgr_locs
+        return type(self)(values, placement=placement, ndim=self.ndim, refs=refs)
+
+    @final
+    def __repr__(self) -> str:
+        name = type(self).__name__
+        if self.ndim == 1:
+            result = f'{name}: {len(self)} dtype: {self.dtype}'
+        else:
+            shape = ' x '.join([str(s) for s in self.shape])
+            result = f'{name}: {self.mgr_locs.indexer}, {shape}, dtype: {self.dtype}'
+        return result
+
+    @final
+    def __len__(self) -> int:
+        return len(self.values)
+
+    @final
+    def slice_block_columns(self, slc: slice) -> Self:
+        new_mgr_locs = self._mgr_locs[slc]
+        new_values = self._slice(slc)
+        refs = self.refs
+        return type(self)(new_values, new_mgr_locs, self.ndim, refs=refs)
+
+    @final
+    def take_block_columns(self, indices: npt.NDArray[np.intp]) -> Self:
+        new_mgr_locs = self._mgr_locs[indices]
+        new_values = self._slice(indices)
+        return type(self)(new_values, new_mgr_locs, self.ndim, refs=None)
+
+    @final
+    def getitem_block_columns(self, slicer: slice, new_mgr_locs: BlockPlacement, ref_inplace_op: bool=False) -> Self:
+        new_values = self._slice(slicer)
+        refs = self.refs if not ref_inplace_op or self.refs.has_reference() else None
+        return type(self)(new_values, new_mgr_locs, self.ndim, refs=refs)
+
+    @final
+    def _can_hold_element(self, element: Any) -> bool:
+        element = extract_array(element, extract_numpy=True)
+        return can_hold_element(self.values, element)
+
+    @final
+    def should_store(self, value: ArrayLike) -> bool:
+        return value.dtype == self.dtype
+
+    @final
+    def apply(self, func, **kwargs) -> list[Block]:
+        result = func(self.values, **kwargs)
+        result = maybe_coerce_values(result)
+        return self._split_op_result(result)
+
+    @final
+    def reduce(self, func) -> list[Block]:
+        assert self.ndim == 2
+        result = func(self.values)
+        if self.values.ndim == 1:
+            res_values = result
+        else:
+            res_values = result.reshape(-1, 1)
+        nb = self.make_block(res_values)
+        return [nb]
+
+    @final
+    def _split_op_result(self, result: ArrayLike) -> list[Block]:
+        if result.ndim > 1 and isinstance(result.dtype, ExtensionDtype):
+            nbs = []
+            for (i, loc) in enumerate(self._mgr_locs):
+                if not is_1d_only_ea_dtype(result.dtype):
+                    vals = result[i:i + 1]
+                else:
+                    vals = result[i]
+                bp = BlockPlacement(loc)
+                block = self.make_block(values=vals, placement=bp)
+                nbs.append(block)
+            return nbs
+        nb = self.make_block(result)
+        return [nb]
+
+    @final
+    def _split(self) -> Generator[Block, None, None]:
+        assert self.ndim == 2
+        for (i, ref_loc) in enumerate(self._mgr_locs):
+            vals = self.values[slice(i, i + 1)]
+            bp = BlockPlacement(ref_loc)
+            nb = type(self)(vals, placement=bp, ndim=2, refs=self.refs)
+            yield nb
+
+    @final
+    def split_and_operate(self, func, *args, **kwargs) -> list[Block]:
+        assert self.ndim == 2 and self.shape[0] != 1
+        res_blocks = []
+        for nb in self._split():
+            rbs = func(nb, *args, **kwargs)
+            res_blocks.extend(rbs)
+        return res_blocks
+
+    @final
+    def coerce_to_target_dtype(self, other, raise_on_upcast: bool) -> Block:
+        new_dtype = find_result_type(self.values.dtype, other)
+        if new_dtype == self.dtype:
+            raise AssertionError('Something has gone wrong, please report a bug at https://github.com/pandas-dev/pandas/issues')
+        if is_scalar(other) and is_integer_dtype(self.values.dtype) and isna(other) and (other is not NaT) and (not (isinstance(other, (np.datetime64, np.timedelta64)) and np.isnat(other))):
+            raise_on_upcast = False
+        elif isinstance(other, np.ndarray) and other.ndim == 1 and is_integer_dtype(self.values.dtype) and is_float_dtype(other.dtype) and lib.has_only_ints_or_nan(other):
+            raise_on_upcast = False
+        if raise_on_upcast:
+            raise TypeError(f"Invalid value '{other}' for dtype '{self.values.dtype}'")
+        if self.values.dtype == new_dtype:
+            raise AssertionError(f'Did not expect new dtype {new_dtype} to equal self.dtype {self.values.dtype}. Please report a bug at https://github.com/pandas-dev/pandas/issues.')
+        try:
+            return self.astype(new_dtype)
+        except OutOfBoundsDatetime as err:
+            raise OutOfBoundsDatetime(f"Incompatible (high-resolution) value for dtype='{self.dtype}'. Explicitly cast before operating.") from err
+
+    @final
+    def convert(self) -> list[Block]:
+        if not self.is_object:
+            return [self.copy(deep=False)]
+        if self.ndim != 1 and self.shape[0] != 1:
+            blocks = self.split_and_operate(Block.convert)
+            if all((blk.dtype.kind == 'O' for blk in blocks)):
+                return [self.copy(deep=False)]
+            return blocks
+        values = self.values
+        if values.ndim == 2:
+            values = values[0]
+        res_values = lib.maybe_convert_objects(values, convert_non_numeric=True)
+        refs = None
+        if res_values is values or (isinstance(res_values, NumpyExtensionArray) and res_values._ndarray is values):
+            refs = self.refs
+        res_values = ensure_block_shape(res_values, self.ndim)
+        res_values = maybe_coerce_values(res_values)
+        return [self.make_block(res_values, refs=refs)]
+
+    def convert_dtypes(self, infer_objects: bool=True, convert_string: bool=True, convert_integer: bool=True, convert_boolean: bool=True, convert_floating: bool=True, dtype_backend: DtypeBackend='numpy_nullable') -> list[Block]:
+        if infer_objects and self.is_object:
+            blks = self.convert()
+        else:
+            blks = [self]
+        if not any([convert_floating, convert_integer, convert_boolean, convert_string]):
+            return [b.copy(deep=False) for b in blks]
+        rbs = []
+        for blk in blks:
+            sub_blks = [blk] if blk.ndim == 1 or self.shape[0] == 1 else list(blk._split())
+            dtypes = [convert_dtypes(b.values, convert_string, convert_integer, convert_boolean, convert_floating, infer_objects, dtype_backend) for b in sub_blks]
+            if all((dtype == self.dtype for dtype in dtypes)):
+                rbs.append(blk.copy(deep=False))
+                continue
+            for (dtype, b) in zip(dtypes, sub_blks):
+                rbs.append(b.astype(dtype=dtype, squeeze=b.ndim != 1))
+        return rbs
+
+    @final
+    @cache_readonly
+    def dtype(self) -> DtypeObj:
+        return self.values.dtype
+
+    @final
+    def astype(self, dtype: DtypeObj, errors: IgnoreRaise='raise', squeeze: bool=False) -> Block:
+        values = self.values
+        if squeeze and values.ndim == 2 and is_1d_only_ea_dtype(dtype):
+            if values.shape[0] != 1:
+                raise ValueError('Can not squeeze with more than one column.')
+            values = values[0, :]
+        new_values = astype_array_safe(values, dtype, errors=errors)
+        new_values = maybe_coerce_values(new_values)
+        refs = None
+        if astype_is_view(values.dtype, new_values.dtype):
+            refs = self.refs
+        newb = self.make_block(new_values, refs=refs)
+        if newb.shape != self.shape:
+            raise TypeError(f'cannot set astype for dtype ({self.dtype.name} [{self.shape}]) to different shape ({newb.dtype.name} [{newb.shape}])')
+        return newb
+
+    @final
+    def get_values_for_csv(self, *, float_format, date_format, decimal, na_rep: str='nan', quoting=None) -> Block:
+        result = get_values_for_csv(self.values, na_rep=na_rep, quoting=quoting, float_format=float_format, date_format=date_format, decimal=decimal)
+        return self.make_block(result)
+
+    @final
+    def copy(self, deep: bool=True) -> Self:
+        values = self.values
+        refs: BlockValuesRefs | None
+        if deep:
+            values = values.copy()
+            refs = None
+        else:
+            refs = self.refs
+        return type(self)(values, placement=self._mgr_locs, ndim=self.ndim, refs=refs)
+
+    def _maybe_copy(self, inplace: bool) -> Self:
+        if inplace:
+            deep = self.refs.has_reference()
+            return self.copy(deep=deep)
+        return self.copy()
+
+    @final
+    def _get_refs_and_copy(self, inplace: bool):
+        refs = None
+        copy = not inplace
+        if inplace:
+            if self.refs.has_reference():
+                copy = True
+            else:
+                refs = self.refs
+        return (copy, refs)
+
+    @final
+    def replace(self, to_replace, value, inplace: bool=False, mask: npt.NDArray[np.bool_] | None=None) -> list[Block]:
+        values = self.values
+        if not self._can_hold_element(to_replace):
+            return [self.copy(deep=False)]
+        if mask is None:
+            mask = missing.mask_missing(values, to_replace)
+        if not mask.any():
+            return [self.copy(deep=False)]
+        elif self._can_hold_element(value):
+            blk = self._maybe_copy(inplace)
+            putmask_inplace(blk.values, mask, value)
+            return [blk]
+        elif self.ndim == 1 or self.shape[0] == 1:
+            if value is None or value is NA:
+                blk = self.astype(np.dtype(object))
+            else:
+                blk = self.coerce_to_target_dtype(value, raise_on_upcast=False)
+            return blk.replace(to_replace=to_replace, value=value, inplace=True, mask=mask)
+        else:
+            blocks = []
+            for (i, nb) in enumerate(self._split()):
+                blocks.extend(type(self).replace(nb, to_replace=to_replace, value=value, inplace=True, mask=mask[i:i + 1]))
+            return blocks
+
+    @final
+    def _replace_regex(self, to_replace, value, inplace: bool=False, mask=None) -> list[Block]:
+        if not self._can_hold_element(to_replace):
+            return [self.copy(deep=False)]
+        rx = re.compile(to_replace)
+        block = self._maybe_copy(inplace)
+        replace_regex(block.values, rx, value, mask)
+        return [block]
+
+    @final
+    def replace_list(self, src_list: Iterable[Any], dest_list: Sequence[Any], inplace: bool=False, regex: bool=False) -> list[Block]:
+        values = self.values
+        pairs = [(x, y) for (x, y) in zip(src_list, dest_list) if self._can_hold_element(x)]
+        if not len(pairs):
+            return [self.copy(deep=False)]
+        src_len = len(pairs) - 1
+        if is_string_dtype(values.dtype):
+            na_mask = ~isna(values)
+            masks: Iterable[npt.NDArray[np.bool_]] = (extract_bool_array(cast(ArrayLike, compare_or_regex_search(values, s[0], regex=regex, mask=na_mask))) for s in pairs)
+        else:
+            masks = (missing.mask_missing(values, s[0]) for s in pairs)
+        if inplace:
+            masks = list(masks)
+        rb = [self]
+        for (i, ((src, dest), mask)) in enumerate(zip(pairs, masks)):
+            new_rb: list[Block] = []
+            for (blk_num, blk) in enumerate(rb):
+                if len(rb) == 1:
+                    m = mask
+                else:
+                    mib = mask
+                    assert not isinstance(mib, bool)
+                    m = mib[blk_num:blk_num + 1]
+                result = blk._replace_coerce(to_replace=src, value=dest, mask=m, inplace=inplace, regex=regex)
+                if i != src_len:
+                    for b in result:
+                        ref = weakref.ref(b)
+                        b.refs.referenced_blocks.pop(b.refs.referenced_blocks.index(ref))
+                new_rb.extend(result)
+            rb = new_rb
+        return rb
+
+    @final
+    def _replace_coerce(self, to_replace, value, mask: npt.NDArray[np.bool_], inplace: bool=True, regex: bool=False) -> list[Block]:
+        if should_use_regex(regex, to_replace):
+            return self._replace_regex(to_replace, value, inplace=inplace, mask=mask)
+        else:
+            if value is None:
+                if mask.any():
+                    has_ref = self.refs.has_reference()
+                    nb = self.astype(np.dtype(object))
+                    if not inplace:
+                        nb = nb.copy()
+                    elif inplace and has_ref and nb.refs.has_reference():
+                        nb = nb.copy()
+                    putmask_inplace(nb.values, mask, value)
+                    return [nb]
+                return [self.copy(deep=False)]
+            return self.replace(to_replace=to_replace, value=value, inplace=inplace, mask=mask)
+
+    def _maybe_squeeze_arg(self, arg: np.ndarray) -> np.ndarray:
+        return arg
+
+    def _unwrap_setitem_indexer(self, indexer):
+        return indexer
+
+    @property
+    def shape(self) -> Shape:
+        return self.values.shape
+
+    def iget(self, i: int | tuple[int, int] | tuple[slice, int]) -> np.ndarray:
+        return self.values[i]
+
+    def _slice(self, slicer: slice | npt.NDArray[np.bool_] | npt.NDArray[np.intp]) -> ArrayLike:
+        return self.values[slicer]
+
+    def set_inplace(self, locs, values: ArrayLike, copy: bool=False) -> None:
+        if copy:
+            self.values = self.values.copy()
+        self.values[locs] = values
+
+    @final
+    def take_nd(self, indexer: npt.NDArray[np.intp], axis: AxisInt, new_mgr_locs: BlockPlacement | None=None, fill_value=lib.no_default) -> Block:
+        values = self.values
+        if fill_value is lib.no_default:
+            fill_value = self.fill_value
+            allow_fill = False
+        else:
+            allow_fill = True
+        new_values = algos.take_nd(values, indexer, axis=axis, allow_fill=allow_fill, fill_value=fill_value)
+        if isinstance(self, ExtensionBlock):
+            assert not (self.ndim == 1 and new_mgr_locs is None)
+        assert not (axis == 0 and new_mgr_locs is None)
+        if new_mgr_locs is None:
+            new_mgr_locs = self._mgr_locs
+        if new_values.dtype != self.dtype:
+            return self.make_block(new_values, new_mgr_locs)
+        else:
+            return self.make_block_same_class(new_values, new_mgr_locs)
+
+    def _unstack(self, unstacker, fill_value, new_placement: npt.NDArray[np.intp], needs_masking: npt.NDArray[np.bool_]):
+        (new_values, mask) = unstacker.get_new_values(self.values.T, fill_value=fill_value)
+        mask = mask.any(0)
+        new_values = new_values.T[mask]
+        new_placement = new_placement[mask]
+        bp = BlockPlacement(new_placement)
+        blocks = [new_block_2d(new_values, placement=bp)]
+        return (blocks, mask)
+
+    def setitem(self, indexer, value) -> Block:
+        value = self._standardize_fill_value(value)
+        values = cast(np.ndarray, self.values)
+        if self.ndim == 2:
+            values = values.T
+        check_setitem_lengths(indexer, value, values)
+        if self.dtype != _dtype_obj:
+            value = extract_array(value, extract_numpy=True)
+        try:
+            casted = np_can_hold_element(values.dtype, value)
+        except LossySetitemError:
+            nb = self.coerce_to_target_dtype(value, raise_on_upcast=True)
+            return nb.setitem(indexer, value)
+        else:
+            if self.dtype == _dtype_obj:
+                vi = values[indexer]
+                if lib.is_list_like(vi):
+                    casted = setitem_datetimelike_compat(values, len(vi), casted)
+            self = self._maybe_copy(inplace=True)
+            values = cast(np.ndarray, self.values.T)
+            if isinstance(casted, np.ndarray) and casted.ndim == 1 and (len(casted) == 1):
+                casted = casted[0, ...]
+            try:
+                values[indexer] = casted
+            except (TypeError, ValueError) as err:
+                if is_list_like(casted):
+                    raise ValueError('setting an array element with a sequence.') from err
+                raise
+        return self
+
+    def putmask(self, mask, new) -> list[Block]:
+        orig_mask = mask
+        values = cast(np.ndarray, self.values)
+        (mask, noop) = validate_putmask(values.T, mask)
+        assert not isinstance(new, (ABCIndex, ABCSeries, ABCDataFrame))
+        if new is lib.no_default:
+            new = self.fill_value
+        new = self._standardize_fill_value(new)
+        new = extract_array(new, extract_numpy=True)
+        if noop:
+            return [self.copy(deep=False)]
+        try:
+            casted = np_can_hold_element(values.dtype, new)
+            self = self._maybe_copy(inplace=True)
+            values = cast(np.ndarray, self.values)
+            putmask_without_repeat(values.T, mask, casted)
+            return [self]
+        except LossySetitemError:
+            if self.ndim == 1 or self.shape[0] == 1:
+                if not is_list_like(new):
+                    return self.coerce_to_target_dtype(new, raise_on_upcast=True).putmask(mask, new)
+                else:
+                    indexer = mask.nonzero()[0]
+                    nb = self.setitem(indexer, new[indexer])
+                    return [nb]
+            else:
+                is_array = isinstance(new, np.ndarray)
+                res_blocks = []
+                for (i, nb) in enumerate(self._split()):
+                    n = new
+                    if is_array:
+                        n = new[:, i:i + 1]
+                    submask = orig_mask[:, i:i + 1]
+                    rbs = nb.putmask(submask, n)
+                    res_blocks.extend(rbs)
+                return res_blocks
+
+    def where(self, other, cond) -> list[Block]:
+        assert cond.ndim == self.ndim
+        assert not isinstance(other, (ABCIndex, ABCSeries, ABCDataFrame))
+        transpose = self.ndim == 2
+        cond = extract_bool_array(cond)
+        values = cast(np.ndarray, self.values)
+        orig_other = other
+        if transpose:
+            values = values.T
+        (icond, noop) = validate_putmask(values, ~cond)
+        if noop:
+            return [self.copy(deep=False)]
+        if other is lib.no_default:
+            other = self.fill_value
+        other = self._standardize_fill_value(other)
+        try:
+            casted = np_can_hold_element(values.dtype, other)
+        except (ValueError, TypeError, LossySetitemError):
+            if self.ndim == 1 or self.shape[0] == 1:
+                block = self.coerce_to_target_dtype(other, raise_on_upcast=False)
+                return block.where(orig_other, cond)
+            else:
+                is_array = isinstance(other, (np.ndarray, ExtensionArray))
+                res_blocks = []
+                for (i, nb) in enumerate(self._split()):
+                    oth = other
+                    if is_array:
+                        oth = other[:, i:i + 1]
+                    submask = cond[:, i:i + 1]
+                    rbs = nb.where(oth, submask)
+                    res_blocks.extend(rbs)
+                return res_blocks
+        else:
+            other = casted
+            alt = setitem_datetimelike_compat(values, icond.sum(), other)
+            if alt is not other:
+                if is_list_like(other) and len(other) < len(values):
+                    np.where(~icond, values, other)
+                    raise NotImplementedError('This should not be reached; call to np.where above is expected to raise ValueError. Please report a bug at github.com/pandas-dev/pandas')
+                result = values.copy()
+                np.putmask(result, icond, alt)
+            else:
+                if is_list_like(other) and (not isinstance(other, np.ndarray)) and (len(other) == self.shape[-1]):
+                    other = np.array(other).reshape(values.shape)
+                result = expressions.where(~icond, values, other)
+        if transpose:
+            result = result.T
+        return [self.make_block(result)]
+
+    def fillna(self, value, limit: int | None=None, inplace: bool=False) -> list[Block]:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if not self._can_hold_na:
+            noop = True
+        else:
+            mask = isna(self.values)
+            (mask, noop) = validate_putmask(self.values, mask)
+        if noop:
+            return [self.copy(deep=False)]
+        if limit is not None:
+            mask[mask.cumsum(self.ndim - 1) > limit] = False
+        if inplace:
+            nbs = self.putmask(mask.T, value)
+        else:
+            nbs = self.where(value, ~mask.T)
+        return extend_blocks(nbs)
+
+    def pad_or_backfill(self, *, method: FillnaOptions, inplace: bool=False, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None) -> list[Block]:
+        if not self._can_hold_na:
+            return [self.copy(deep=False)]
+        (copy, refs) = self._get_refs_and_copy(inplace)
+        vals = cast(NumpyExtensionArray, self.array_values)
+        new_values = vals.T._pad_or_backfill(method=method, limit=limit, limit_area=limit_area, copy=copy).T
+        data = extract_array(new_values, extract_numpy=True)
+        return [self.make_block_same_class(data, refs=refs)]
+
+    @final
+    def interpolate(self, *, method: InterpolateOptions, index: Index, inplace: bool=False, limit: int | None=None, limit_direction: Literal['forward', 'backward', 'both']='forward', limit_area: Literal['inside', 'outside'] | None=None, **kwargs) -> list[Block]:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if method == 'asfreq':
+            missing.clean_fill_method(method)
+        if not self._can_hold_na:
+            return [self.copy(deep=False)]
+        if self.dtype == _dtype_obj:
+            name = {1: 'Series', 2: 'DataFrame'}[self.ndim]
+            raise TypeError(f'{name} cannot interpolate with object dtype.')
+        (copy, refs) = self._get_refs_and_copy(inplace)
+        new_values = self.array_values.interpolate(method=method, axis=self.ndim - 1, index=index, limit=limit, limit_direction=limit_direction, limit_area=limit_area, copy=copy, **kwargs)
+        data = extract_array(new_values, extract_numpy=True)
+        return [self.make_block_same_class(data, refs=refs)]
+
+    @final
+    def diff(self, n: int) -> list[Block]:
+        new_values = algos.diff(self.values.T, n, axis=0).T
+        return [self.make_block(values=new_values)]
+
+    def shift(self, periods: int, fill_value: Any=None) -> list[Block]:
+        axis = self.ndim - 1
+        if not lib.is_scalar(fill_value) and self.dtype != _dtype_obj:
+            raise ValueError('fill_value must be a scalar')
+        fill_value = self._standardize_fill_value(fill_value)
+        try:
+            casted = np_can_hold_element(self.dtype, fill_value)
+        except LossySetitemError:
+            nb = self.coerce_to_target_dtype(fill_value, raise_on_upcast=False)
+            return nb.shift(periods, fill_value=fill_value)
+        else:
+            values = cast(np.ndarray, self.values)
+            new_values = shift(values, periods, axis, casted)
+            return [self.make_block_same_class(new_values)]
+
+    @final
+    def quantile(self, qs: Index, interpolation: QuantileInterpolation='linear') -> Block:
+        assert self.ndim == 2
+        assert is_list_like(qs)
+        result = quantile_compat(self.values, np.asarray(qs._values), interpolation)
+        result = ensure_block_shape(result, ndim=2)
+        return new_block_2d(result, placement=self._mgr_locs)
+
+    @final
+    def round(self, decimals: int) -> Self:
+        if not self.is_numeric or self.is_bool:
+            return self.copy(deep=False)
+        values = self.values.round(decimals)
+        refs = None
+        if values is self.values:
+            refs = self.refs
+        return self.make_block_same_class(values, refs=refs)
+
+    def delete(self, loc) -> list[Block]:
+        if not is_list_like(loc):
+            loc = [loc]
+        if self.ndim == 1:
+            values = cast(np.ndarray, self.values)
+            values = np.delete(values, loc)
+            mgr_locs = self._mgr_locs.delete(loc)
+            return [type(self)(values, placement=mgr_locs, ndim=self.ndim)]
+        if np.max(loc) >= self.values.shape[0]:
+            raise IndexError
+        loc = np.concatenate([loc, [self.values.shape[0]]])
+        mgr_locs_arr = self._mgr_locs.as_array
+        new_blocks: list[Block] = []
+        previous_loc = -1
+        refs = self.refs if self.refs.has_reference() else None
+        for idx in loc:
+            if idx == previous_loc + 1:
+                pass
+            else:
+                values = self.values[previous_loc + 1:idx, :]
+                locs = mgr_locs_arr[previous_loc + 1:idx]
+                nb = type(self)(values, placement=BlockPlacement(locs), ndim=self.ndim, refs=refs)
+                new_blocks.append(nb)
+            previous_loc = idx
+        return new_blocks
+
+    @property
+    def is_view(self) -> bool:
+        raise AbstractMethodError(self)
+
+    @property
+    def array_values(self) -> ExtensionArray:
+        raise AbstractMethodError(self)
+
+    def get_values(self, dtype: DtypeObj | None=None) -> np.ndarray:
+        raise AbstractMethodError(self)
+
+class EABackedBlock(Block):
+    values: ExtensionArray
+
+    @final
+    def shift(self, periods: int, fill_value: Any=None) -> list[Block]:
+        new_values = self.values.T.shift(periods=periods, fill_value=fill_value).T
+        return [self.make_block_same_class(new_values)]
+
+    @final
+    def setitem(self, indexer, value):
+        orig_indexer = indexer
+        orig_value = value
+        indexer = self._unwrap_setitem_indexer(indexer)
+        value = self._maybe_squeeze_arg(value)
+        values = self.values
+        if values.ndim == 2:
+            values = values.T
+        check_setitem_lengths(indexer, value, values)
+        try:
+            values[indexer] = value
+        except (ValueError, TypeError):
+            if isinstance(self.dtype, IntervalDtype):
+                nb = self.coerce_to_target_dtype(orig_value, raise_on_upcast=True)
+                return nb.setitem(orig_indexer, orig_value)
+            elif isinstance(self, NDArrayBackedExtensionBlock):
+                nb = self.coerce_to_target_dtype(orig_value, raise_on_upcast=True)
+                return nb.setitem(orig_indexer, orig_value)
+            else:
+                raise
+        else:
+            return self
+
+    @final
+    def where(self, other, cond) -> list[Block]:
+        arr = self.values.T
+        cond = extract_bool_array(cond)
+        orig_other = other
+        orig_cond = cond
+        other = self._maybe_squeeze_arg(other)
+        cond = self._maybe_squeeze_arg(cond)
+        if other is lib.no_default:
+            other = self.fill_value
+        (icond, noop) = validate_putmask(arr, ~cond)
+        if noop:
+            return [self.copy(deep=False)]
+        try:
+            res_values = arr._where(cond, other).T
+        except (ValueError, TypeError):
+            if self.ndim == 1 or self.shape[0] == 1:
+                if isinstance(self.dtype, IntervalDtype):
+                    blk = self.coerce_to_target_dtype(orig_other, raise_on_upcast=False)
+                    return blk.where(orig_other, orig_cond)
+                elif isinstance(self, NDArrayBackedExtensionBlock):
+                    blk = self.coerce_to_target_dtype(orig_other, raise_on_upcast=False)
+                    return blk.where(orig_other, orig_cond)
+                else:
+                    raise
+            else:
+                is_array = isinstance(orig_other, (np.ndarray, ExtensionArray))
+                res_blocks = []
+                for (i, nb) in enumerate(self._split()):
+                    n = orig_other
+                    if is_array:
+                        n = orig_other[:, i:i + 1]
+                    submask = orig_cond[:, i:i + 1]
+                    rbs = nb.where(n, submask)
+                    res_blocks.extend(rbs)
+                return res_blocks
+        nb = self.make_block_same_class(res_values)
+        return [nb]
+
+    @final
+    def putmask(self, mask, new) -> list[Block]:
+        mask = extract_bool_array(mask)
+        if new is lib.no_default:
+            new = self.fill_value
+        orig_new = new
+        orig_mask = mask
+        new = self._maybe_squeeze_arg(new)
+        mask = self._maybe_squeeze_arg(mask)
+        if not mask.any():
+            return [self.copy(deep=False)]
+        self = self._maybe_copy(inplace=True)
+        values = self.values
+        if values.ndim == 2:
+            values = values.T
+        try:
+            values._putmask(mask, new)
+        except (TypeError, ValueError):
+            if self.ndim == 1 or self.shape[0] == 1:
+                if isinstance(self.dtype, IntervalDtype):
+                    blk = self.coerce_to_target_dtype(orig_new, raise_on_upcast=True)
+                    return blk.putmask(orig_mask, orig_new)
+                elif isinstance(self, NDArrayBackedExtensionBlock):
+                    blk = self.coerce_to_target_dtype(orig_new, raise_on_upcast=True)
+                    return blk.putmask(orig_mask, orig_new)
+                else:
+                    raise
+            else:
+                is_array = isinstance(orig_new, (np.ndarray, ExtensionArray))
+                res_blocks = []
+                for (i, nb) in enumerate(self._split()):
+                    n = orig_new
+                    if is_array:
+                        n = orig_new[:, i:i + 1]
+                    submask = orig_mask[:, i:i + 1]
+                    rbs = nb.putmask(submask, n)
+                    res_blocks.extend(rbs)
+                return res_blocks
+        return [self]
+
+    @final
+    def delete(self, loc) -> list[Block]:
+        if self.ndim == 1:
+            values = self.values.delete(loc)
+            mgr_locs = self._mgr_locs.delete(loc)
+            return [type(self)(values, placement=mgr_locs, ndim=self.ndim)]
+        elif self.values.ndim == 1:
+            return []
+        return super().delete(loc)
+
+    @final
+    @cache_readonly
+    def array_values(self) -> ExtensionArray:
+        return self.values
+
+    @final
+    def get_values(self, dtype: DtypeObj | None=None) -> np.ndarray:
+        values: ArrayLike = self.values
+        if dtype == _dtype_obj:
+            values = values.astype(object)
+        return np.asarray(values).reshape(self.shape)
+
+    @final
+    def pad_or_backfill(self, *, method: FillnaOptions, inplace: bool=False, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None) -> list[Block]:
+        values = self.values
+        kwargs: dict[str, Any] = {'method': method, 'limit': limit}
+        if 'limit_area' in inspect.signature(values._pad_or_backfill).parameters:
+            kwargs['limit_area'] = limit_area
+        elif limit_area is not None:
+            raise NotImplementedError(f'{type(values).__name__} does not implement limit_area (added in pandas 2.2). 3rd-party ExtensionArray authors need to add this argument to _pad_or_backfill.')
+        if values.ndim == 2:
+            new_values = values.T._pad_or_backfill(**kwargs).T
+        else:
+            new_values = values._pad_or_backfill(**kwargs)
+        return [self.make_block_same_class(new_values)]
+
+class ExtensionBlock(EABackedBlock):
+    values: ExtensionArray
+
+    def fillna(self, value, limit: int | None=None, inplace: bool=False) -> list[Block]:
+        if isinstance(self.dtype, IntervalDtype):
+            if limit is not None:
+                raise ValueError('limit must be None')
+            return super().fillna(value=value, limit=limit, inplace=inplace)
+        if self._can_hold_na and (not self.values._hasna):
+            refs = self.refs
+            new_values = self.values
+        else:
+            (copy, refs) = self._get_refs_and_copy(inplace)
+            try:
+                new_values = self.values.fillna(value=value, limit=limit, copy=copy)
+            except TypeError:
+                refs = None
+                new_values = self.values.fillna(value=value, limit=limit)
+                warnings.warn(f"ExtensionArray.fillna added a 'copy' keyword in pandas 2.1.0. In a future version, ExtensionArray subclasses will need to implement this keyword or an exception will be raised. In the interim, the keyword is ignored by {type(self.values).__name__}.", DeprecationWarning, stacklevel=find_stack_level())
+        return [self.make_block_same_class(new_values, refs=refs)]
+
+    @cache_readonly
+    def shape(self) -> Shape:
+        if self.ndim == 1:
+            return (len(self.values),)
+        return (len(self._mgr_locs), len(self.values))
+
+    def iget(self, i: int | tuple[int, int] | tuple[slice, int]):
+        if isinstance(i, tuple):
+            (col, loc) = i
+            if not com.is_null_slice(col) and col != 0:
+                raise IndexError(f'{self} only contains one item')
+            if isinstance(col, slice):
+                if loc < 0:
+                    loc += len(self.values)
+                return self.values[loc:loc + 1]
+            return self.values[loc]
+        else:
+            if i != 0:
+                raise IndexError(f'{self} only contains one item')
+            return self.values
+
+    def set_inplace(self, locs, values: ArrayLike, copy: bool=False) -> None:
+        if copy:
+            self.values = self.values.copy()
+        self.values[:] = values
+
+    def _maybe_squeeze_arg(self, arg):
+        if isinstance(arg, (np.ndarray, ExtensionArray)) and arg.ndim == self.values.ndim + 1:
+            assert arg.shape[1] == 1
+            arg = arg[:, 0]
+        elif isinstance(arg, ABCDataFrame):
+            assert arg.shape[1] == 1
+            arg = arg._ixs(0, axis=1)._values
+        return arg
+
+    def _unwrap_setitem_indexer(self, indexer):
+        if isinstance(indexer, tuple) and len(indexer) == 2:
+            if all((isinstance(x, np.ndarray) and x.ndim == 2 for x in indexer)):
+                (first, second) = indexer
+                if not (second.size == 1 and (second == 0).all() and (first.shape[1] == 1)):
+                    raise NotImplementedError('This should not be reached. Please report a bug at github.com/pandas-dev/pandas/')
+                indexer = first[:, 0]
+            elif lib.is_integer(indexer[1]) and indexer[1] == 0:
+                indexer = indexer[0]
+            elif com.is_null_slice(indexer[1]):
+                indexer = indexer[0]
+            elif is_list_like(indexer[1]) and indexer[1][0] == 0:
+                indexer = indexer[0]
+            else:
+                raise NotImplementedError('This should not be reached. Please report a bug at github.com/pandas-dev/pandas/')
+        return indexer
+
+    @property
+    def is_view(self) -> bool:
+        return False
+
+    @cache_readonly
+    def is_numeric(self) -> bool:
+        return self.values.dtype._is_numeric
+
+    def _slice(self, slicer: slice | npt.NDArray[np.bool_] | npt.NDArray[np.intp]) -> ExtensionArray:
+        if self.ndim == 2:
+            if not isinstance(slicer, slice):
+                raise AssertionError('invalid slicing for a 1-ndim ExtensionArray', slicer)
+            new_locs = range(1)[slicer]
+            if not len(new_locs):
+                raise AssertionError('invalid slicing for a 1-ndim ExtensionArray', slicer)
+            slicer = slice(None)
+        return self.values[slicer]
+
+    @final
+    def slice_block_rows(self, slicer: slice) -> Self:
+        new_values = self.values[slicer]
+        return type(self)(new_values, self._mgr_locs, ndim=self.ndim, refs=self.refs)
+
+    def _unstack(self, unstacker, fill_value, new_placement: npt.NDArray[np.intp], needs_masking: npt.NDArray[np.bool_]):
+        (new_values, mask) = unstacker.arange_result
+        new_values = new_values.T[mask]
+        new_placement = new_placement[mask]
+        blocks = [type(self)(self.values.take(indices, allow_fill=needs_masking[i], fill_value=fill_value), BlockPlacement(place), ndim=2) for (i, (indices, place)) in enumerate(zip(new_values, new_placement))]
+        return (blocks, mask)
+
+class NumpyBlock(Block):
+    values: np.ndarray
+    __slots__ = ()
+
+    @property
+    def is_view(self) -> bool:
+        return self.values.base is not None
+
+    @property
+    def array_values(self) -> ExtensionArray:
+        return NumpyExtensionArray(self.values)
+
+    def get_values(self, dtype: DtypeObj | None=None) -> np.ndarray:
+        if dtype == _dtype_obj:
+            return self.values.astype(_dtype_obj)
+        return self.values
+
+    @cache_readonly
+    def is_numeric(self) -> bool:
+        dtype = self.values.dtype
+        kind = dtype.kind
+        return kind in 'fciub'
+
+class NDArrayBackedExtensionBlock(EABackedBlock):
+    values: NDArrayBackedExtensionArray
+
+    @property
+    def is_view(self) -> bool:
+        return self.values._ndarray.base is not None
+
+class DatetimeLikeBlock(NDArrayBackedExtensionBlock):
+    __slots__ = ()
+    is_numeric = False
+    values: DatetimeArray | TimedeltaArray
+
+def maybe_coerce_values(values: ArrayLike) -> ArrayLike:
+    if isinstance(values, np.ndarray):
+        values = ensure_wrapped_if_datetimelike(values)
+        if issubclass(values.dtype.type, str):
+            values = np.array(values, dtype=object)
+    if isinstance(values, (DatetimeArray, TimedeltaArray)) and values.freq is not None:
+        values = values._with_freq(None)
+    return values
+
+def get_block_type(dtype: DtypeObj) -> type[Block]:
+    if isinstance(dtype, DatetimeTZDtype):
+        return DatetimeLikeBlock
+    elif isinstance(dtype, PeriodDtype):
+        return NDArrayBackedExtensionBlock
+    elif isinstance(dtype, ExtensionDtype):
+        return ExtensionBlock
+    kind = dtype.kind
+    if kind in 'Mm':
+        return DatetimeLikeBlock
+    return NumpyBlock
+
+def new_block_2d(values: ArrayLike, placement: BlockPlacement, refs: BlockValuesRefs | None=None) -> Block:
+    klass = get_block_type(values.dtype)
+    values = maybe_coerce_values(values)
+    return klass(values, ndim=2, placement=placement, refs=refs)
+
+def new_block(values, placement: BlockPlacement, *, ndim: int, refs: BlockValuesRefs | None=None) -> Block:
+    klass = get_block_type(values.dtype)
+    return klass(values, ndim=ndim, placement=placement, refs=refs)
+
+def check_ndim(values, placement: BlockPlacement, ndim: int) -> None:
+    if values.ndim > ndim:
+        raise ValueError(f'Wrong number of dimensions. values.ndim > ndim [{values.ndim} > {ndim}]')
+    if not is_1d_only_ea_dtype(values.dtype):
+        if values.ndim != ndim:
+            raise ValueError(f'Wrong number of dimensions. values.ndim != ndim [{values.ndim} != {ndim}]')
+        if len(placement) != len(values):
+            raise ValueError(f'Wrong number of items passed {len(values)}, placement implies {len(placement)}')
+    elif ndim == 2 and len(placement) != 1:
+        raise ValueError('need to split')
+
+def extract_pandas_array(values: ArrayLike, dtype: DtypeObj | None, ndim: int) -> tuple[ArrayLike, DtypeObj | None]:
+    if isinstance(values, ABCNumpyExtensionArray):
+        values = values.to_numpy()
+        if ndim and ndim > 1:
+            values = np.atleast_2d(values)
+    if isinstance(dtype, NumpyEADtype):
+        dtype = dtype.numpy_dtype
+    return (values, dtype)
+
+def extend_blocks(result, blocks=None) -> list[Block]:
+    if blocks is None:
+        blocks = []
+    if isinstance(result, list):
+        for r in result:
+            if isinstance(r, list):
+                blocks.extend(r)
+            else:
+                blocks.append(r)
+    else:
+        assert isinstance(result, Block), type(result)
+        blocks.append(result)
+    return blocks
+
+def ensure_block_shape(values: ArrayLike, ndim: int=1) -> ArrayLike:
+    if values.ndim < ndim:
+        if not is_1d_only_ea_dtype(values.dtype):
+            values = cast('np.ndarray | DatetimeArray | TimedeltaArray', values)
+            values = values.reshape(1, -1)
+    return values
+
+def external_values(values: ArrayLike) -> ArrayLike:
+    if isinstance(values, (PeriodArray, IntervalArray)):
+        return values.astype(object)
+    elif isinstance(values, (DatetimeArray, TimedeltaArray)):
+        values = values._ndarray
+    if isinstance(values, np.ndarray):
+        values = values.view()
+        values.flags.writeable = False
+    return values
+
+# File: pandas-main/pandas/core/internals/concat.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, cast
+import numpy as np
+from pandas._libs import NaT, algos as libalgos, internals as libinternals, lib
+from pandas._libs.missing import NA
+from pandas.util._decorators import cache_readonly
+from pandas.core.dtypes.cast import ensure_dtype_can_hold_na, find_common_type
+from pandas.core.dtypes.common import is_1d_only_ea_dtype, needs_i8_conversion
+from pandas.core.dtypes.concat import concat_compat
+from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.missing import is_valid_na_for_dtype
+from pandas.core.construction import ensure_wrapped_if_datetimelike
+from pandas.core.internals.blocks import ensure_block_shape, new_block_2d
+from pandas.core.internals.managers import BlockManager, make_na_array
+if TYPE_CHECKING:
+    from collections.abc import Generator, Sequence
+    from pandas._typing import ArrayLike, AxisInt, DtypeObj, Shape
+    from pandas import Index
+    from pandas.core.internals.blocks import Block, BlockPlacement
+
+def concatenate_managers(mgrs_indexers, axes: list[Index], concat_axis: AxisInt, copy: bool) -> BlockManager:
+    needs_copy = copy and concat_axis == 0
+    if concat_axis == 0:
+        mgrs = _maybe_reindex_columns_na_proxy(axes, mgrs_indexers, needs_copy)
+        return mgrs[0].concat_horizontal(mgrs, axes)
+    if len(mgrs_indexers) > 0 and mgrs_indexers[0][0].nblocks > 0:
+        first_dtype = mgrs_indexers[0][0].blocks[0].dtype
+        if first_dtype in [np.float64, np.float32]:
+            if all((_is_homogeneous_mgr(mgr, first_dtype) for (mgr, _) in mgrs_indexers)) and len(mgrs_indexers) > 1:
+                shape = tuple((len(x) for x in axes))
+                nb = _concat_homogeneous_fastpath(mgrs_indexers, shape, first_dtype)
+                return BlockManager((nb,), axes)
+    mgrs = _maybe_reindex_columns_na_proxy(axes, mgrs_indexers, needs_copy)
+    if len(mgrs) == 1:
+        mgr = mgrs[0]
+        out = mgr.copy(deep=False)
+        out.axes = axes
+        return out
+    blocks = []
+    values: ArrayLike
+    for (placement, join_units) in _get_combined_plan(mgrs):
+        unit = join_units[0]
+        blk = unit.block
+        if _is_uniform_join_units(join_units):
+            vals = [ju.block.values for ju in join_units]
+            if not blk.is_extension:
+                values = np.concatenate(vals, axis=1)
+            elif is_1d_only_ea_dtype(blk.dtype):
+                values = concat_compat(vals, axis=0, ea_compat_axis=True)
+                values = ensure_block_shape(values, ndim=2)
+            else:
+                values = concat_compat(vals, axis=1)
+            values = ensure_wrapped_if_datetimelike(values)
+            fastpath = blk.values.dtype == values.dtype
+        else:
+            values = _concatenate_join_units(join_units, copy=copy)
+            fastpath = False
+        if fastpath:
+            b = blk.make_block_same_class(values, placement=placement)
+        else:
+            b = new_block_2d(values, placement=placement)
+        blocks.append(b)
+    return BlockManager(tuple(blocks), axes)
+
+def _maybe_reindex_columns_na_proxy(axes: list[Index], mgrs_indexers: list[tuple[BlockManager, dict[int, np.ndarray]]], needs_copy: bool) -> list[BlockManager]:
+    new_mgrs = []
+    for (mgr, indexers) in mgrs_indexers:
+        for (i, indexer) in indexers.items():
+            mgr = mgr.reindex_indexer(axes[i], indexers[i], axis=i, only_slice=True, allow_dups=True, use_na_proxy=True)
+        if needs_copy and (not indexers):
+            mgr = mgr.copy()
+        new_mgrs.append(mgr)
+    return new_mgrs
+
+def _is_homogeneous_mgr(mgr: BlockManager, first_dtype: DtypeObj) -> bool:
+    if mgr.nblocks != 1:
+        return False
+    blk = mgr.blocks[0]
+    if not (blk.mgr_locs.is_slice_like and blk.mgr_locs.as_slice.step == 1):
+        return False
+    return blk.dtype == first_dtype
+
+def _concat_homogeneous_fastpath(mgrs_indexers, shape: Shape, first_dtype: np.dtype) -> Block:
+    if all((not indexers for (_, indexers) in mgrs_indexers)):
+        arrs = [mgr.blocks[0].values.T for (mgr, _) in mgrs_indexers]
+        arr = np.concatenate(arrs).T
+        bp = libinternals.BlockPlacement(slice(shape[0]))
+        nb = new_block_2d(arr, bp)
+        return nb
+    arr = np.empty(shape, dtype=first_dtype)
+    if first_dtype == np.float64:
+        take_func = libalgos.take_2d_axis0_float64_float64
+    else:
+        take_func = libalgos.take_2d_axis0_float32_float32
+    start = 0
+    for (mgr, indexers) in mgrs_indexers:
+        mgr_len = mgr.shape[1]
+        end = start + mgr_len
+        if 0 in indexers:
+            take_func(mgr.blocks[0].values, indexers[0], arr[:, start:end])
+        else:
+            arr[:, start:end] = mgr.blocks[0].values
+        start += mgr_len
+    bp = libinternals.BlockPlacement(slice(shape[0]))
+    nb = new_block_2d(arr, bp)
+    return nb
+
+def _get_combined_plan(mgrs: list[BlockManager]) -> Generator[tuple[BlockPlacement, list[JoinUnit]], None, None]:
+    max_len = mgrs[0].shape[0]
+    blknos_list = [mgr.blknos for mgr in mgrs]
+    pairs = libinternals.get_concat_blkno_indexers(blknos_list)
+    for (blknos, bp) in pairs:
+        units_for_bp = []
+        for (k, mgr) in enumerate(mgrs):
+            blkno = blknos[k]
+            nb = _get_block_for_concat_plan(mgr, bp, blkno, max_len=max_len)
+            unit = JoinUnit(nb)
+            units_for_bp.append(unit)
+        yield (bp, units_for_bp)
+
+def _get_block_for_concat_plan(mgr: BlockManager, bp: BlockPlacement, blkno: int, *, max_len: int) -> Block:
+    blk = mgr.blocks[blkno]
+    if len(bp) == len(blk.mgr_locs) and (blk.mgr_locs.is_slice_like and blk.mgr_locs.as_slice.step == 1):
+        nb = blk
+    else:
+        ax0_blk_indexer = mgr.blklocs[bp.indexer]
+        slc = lib.maybe_indices_to_slice(ax0_blk_indexer, max_len)
+        if isinstance(slc, slice):
+            nb = blk.slice_block_columns(slc)
+        else:
+            nb = blk.take_block_columns(slc)
+    return nb
+
+class JoinUnit:
+
+    def __init__(self, block: Block) -> None:
+        self.block = block
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}({self.block!r})'
+
+    def _is_valid_na_for(self, dtype: DtypeObj) -> bool:
+        if not self.is_na:
+            return False
+        blk = self.block
+        if blk.dtype.kind == 'V':
+            return True
+        if blk.dtype == object:
+            values = blk.values
+            return all((is_valid_na_for_dtype(x, dtype) for x in values.ravel(order='K')))
+        na_value = blk.fill_value
+        if na_value is NaT and blk.dtype != dtype:
+            return False
+        if na_value is NA and needs_i8_conversion(dtype):
+            return False
+        return is_valid_na_for_dtype(na_value, dtype)
+
+    @cache_readonly
+    def is_na(self) -> bool:
+        blk = self.block
+        if blk.dtype.kind == 'V':
+            return True
+        return False
+
+    def get_reindexed_values(self, empty_dtype: DtypeObj, upcasted_na) -> ArrayLike:
+        values: ArrayLike
+        if upcasted_na is None and self.block.dtype.kind != 'V':
+            return self.block.values
+        else:
+            fill_value = upcasted_na
+            if self._is_valid_na_for(empty_dtype):
+                blk_dtype = self.block.dtype
+                if blk_dtype == np.dtype('object'):
+                    values = cast(np.ndarray, self.block.values)
+                    if values.size and values[0, 0] is None:
+                        fill_value = None
+                return make_na_array(empty_dtype, self.block.shape, fill_value)
+            return self.block.values
+
+def _concatenate_join_units(join_units: list[JoinUnit], copy: bool) -> ArrayLike:
+    empty_dtype = _get_empty_dtype(join_units)
+    has_none_blocks = any((unit.block.dtype.kind == 'V' for unit in join_units))
+    upcasted_na = _dtype_to_na_value(empty_dtype, has_none_blocks)
+    to_concat = [ju.get_reindexed_values(empty_dtype=empty_dtype, upcasted_na=upcasted_na) for ju in join_units]
+    if any((is_1d_only_ea_dtype(t.dtype) for t in to_concat)):
+        to_concat = [t if is_1d_only_ea_dtype(t.dtype) else t[0, :] for t in to_concat]
+        concat_values = concat_compat(to_concat, axis=0, ea_compat_axis=True)
+        concat_values = ensure_block_shape(concat_values, 2)
+    else:
+        concat_values = concat_compat(to_concat, axis=1)
+    return concat_values
+
+def _dtype_to_na_value(dtype: DtypeObj, has_none_blocks: bool):
+    if isinstance(dtype, ExtensionDtype):
+        return dtype.na_value
+    elif dtype.kind in 'mM':
+        return dtype.type('NaT')
+    elif dtype.kind in 'fc':
+        return dtype.type('NaN')
+    elif dtype.kind == 'b':
+        return None
+    elif dtype.kind in 'iu':
+        if not has_none_blocks:
+            return None
+        return np.nan
+    elif dtype.kind == 'O':
+        return np.nan
+    raise NotImplementedError
+
+def _get_empty_dtype(join_units: Sequence[JoinUnit]) -> DtypeObj:
+    if lib.dtypes_all_equal([ju.block.dtype for ju in join_units]):
+        empty_dtype = join_units[0].block.dtype
+        return empty_dtype
+    has_none_blocks = any((unit.block.dtype.kind == 'V' for unit in join_units))
+    dtypes = [unit.block.dtype for unit in join_units if not unit.is_na]
+    dtype = find_common_type(dtypes)
+    if has_none_blocks:
+        dtype = ensure_dtype_can_hold_na(dtype)
+    return dtype
+
+def _is_uniform_join_units(join_units: list[JoinUnit]) -> bool:
+    first = join_units[0].block
+    if first.dtype.kind == 'V':
+        return False
+    return all((type(ju.block) is type(first) for ju in join_units)) and all((ju.block.dtype == first.dtype or ju.block.dtype.kind in 'iub' for ju in join_units)) and all((not ju.is_na or ju.block.is_extension for ju in join_units))
+
+# File: pandas-main/pandas/core/internals/construction.py
+""""""
+from __future__ import annotations
+from collections import abc
+from typing import TYPE_CHECKING, Any
+import numpy as np
+from numpy import ma
+from pandas._config import using_string_dtype
+from pandas._libs import lib
+from pandas.core.dtypes.astype import astype_is_view
+from pandas.core.dtypes.cast import construct_1d_arraylike_from_scalar, dict_compat, maybe_cast_to_datetime, maybe_convert_platform, maybe_infer_to_datetimelike
+from pandas.core.dtypes.common import is_1d_only_ea_dtype, is_integer_dtype, is_list_like, is_named_tuple, is_object_dtype, is_scalar
+from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.dtypes.missing import isna
+from pandas.core import algorithms, common as com
+from pandas.core.arrays import ExtensionArray
+from pandas.core.arrays.string_ import StringDtype
+from pandas.core.construction import array as pd_array, extract_array, range_to_ndarray, sanitize_array
+from pandas.core.indexes.api import DatetimeIndex, Index, TimedeltaIndex, default_index, ensure_index, get_objs_combined_axis, maybe_sequence_to_range, union_indexes
+from pandas.core.internals.blocks import BlockPlacement, ensure_block_shape, new_block, new_block_2d
+from pandas.core.internals.managers import create_block_manager_from_blocks, create_block_manager_from_column_arrays
+if TYPE_CHECKING:
+    from collections.abc import Hashable, Sequence
+    from pandas._typing import ArrayLike, DtypeObj, Manager, npt
+
+def arrays_to_mgr(arrays, columns: Index, index, *, dtype: DtypeObj | None=None, verify_integrity: bool=True, consolidate: bool=True) -> Manager:
+    if verify_integrity:
+        if index is None:
+            index = _extract_index(arrays)
+        else:
+            index = ensure_index(index)
+        (arrays, refs) = _homogenize(arrays, index, dtype)
+    else:
+        index = ensure_index(index)
+        arrays = [extract_array(x, extract_numpy=True) for x in arrays]
+        refs = [None] * len(arrays)
+        for arr in arrays:
+            if not isinstance(arr, (np.ndarray, ExtensionArray)) or arr.ndim != 1 or len(arr) != len(index):
+                raise ValueError('Arrays must be 1-dimensional np.ndarray or ExtensionArray with length matching len(index)')
+    columns = ensure_index(columns)
+    if len(columns) != len(arrays):
+        raise ValueError('len(arrays) must match len(columns)')
+    axes = [columns, index]
+    return create_block_manager_from_column_arrays(arrays, axes, consolidate=consolidate, refs=refs)
+
+def rec_array_to_mgr(data: np.rec.recarray | np.ndarray, index, columns, dtype: DtypeObj | None, copy: bool) -> Manager:
+    fdata = ma.getdata(data)
+    if index is None:
+        index = default_index(len(fdata))
+    else:
+        index = ensure_index(index)
+    if columns is not None:
+        columns = ensure_index(columns)
+    (arrays, arr_columns) = to_arrays(fdata, columns)
+    (arrays, arr_columns) = reorder_arrays(arrays, arr_columns, columns, len(index))
+    if columns is None:
+        columns = arr_columns
+    mgr = arrays_to_mgr(arrays, columns, index, dtype=dtype)
+    if copy:
+        mgr = mgr.copy()
+    return mgr
+
+def ndarray_to_mgr(values, index, columns, dtype: DtypeObj | None, copy: bool) -> Manager:
+    infer_object = not isinstance(values, (ABCSeries, Index, ExtensionArray))
+    if isinstance(values, ABCSeries):
+        if columns is None:
+            if values.name is not None:
+                columns = Index([values.name])
+        if index is None:
+            index = values.index
+        else:
+            values = values.reindex(index)
+        if not len(values) and columns is not None and len(columns):
+            values = np.empty((0, 1), dtype=object)
+    vdtype = getattr(values, 'dtype', None)
+    refs = None
+    if is_1d_only_ea_dtype(vdtype) or is_1d_only_ea_dtype(dtype):
+        if isinstance(values, (np.ndarray, ExtensionArray)) and values.ndim > 1:
+            values = [values[:, n] for n in range(values.shape[1])]
+        else:
+            values = [values]
+        if columns is None:
+            columns = Index(range(len(values)))
+        else:
+            columns = ensure_index(columns)
+        return arrays_to_mgr(values, columns, index, dtype=dtype)
+    elif isinstance(vdtype, ExtensionDtype):
+        values = extract_array(values, extract_numpy=True)
+        if copy:
+            values = values.copy()
+        if values.ndim == 1:
+            values = values.reshape(-1, 1)
+    elif isinstance(values, (ABCSeries, Index)):
+        if not copy and (dtype is None or astype_is_view(values.dtype, dtype)):
+            refs = values._references
+        if copy:
+            values = values._values.copy()
+        else:
+            values = values._values
+        values = _ensure_2d(values)
+    elif isinstance(values, (np.ndarray, ExtensionArray)):
+        if copy and (dtype is None or astype_is_view(values.dtype, dtype)):
+            values = np.array(values, copy=True, order='F')
+        else:
+            values = np.array(values, copy=False)
+        values = _ensure_2d(values)
+    else:
+        values = _prep_ndarraylike(values, copy=copy)
+    if dtype is not None and values.dtype != dtype:
+        values = sanitize_array(values, None, dtype=dtype, copy=copy, allow_2d=True)
+    (index, columns) = _get_axes(values.shape[0], values.shape[1], index=index, columns=columns)
+    _check_values_indices_shape_match(values, index, columns)
+    values = values.T
+    if dtype is None and infer_object and is_object_dtype(values.dtype):
+        obj_columns = list(values)
+        maybe_datetime = [maybe_infer_to_datetimelike(x) for x in obj_columns]
+        if any((x is not y for (x, y) in zip(obj_columns, maybe_datetime))):
+            block_values = [new_block_2d(ensure_block_shape(dval, 2), placement=BlockPlacement(n)) for (n, dval) in enumerate(maybe_datetime)]
+        else:
+            bp = BlockPlacement(slice(len(columns)))
+            nb = new_block_2d(values, placement=bp, refs=refs)
+            block_values = [nb]
+    elif dtype is None and values.dtype.kind == 'U' and using_string_dtype():
+        dtype = StringDtype(na_value=np.nan)
+        obj_columns = list(values)
+        block_values = [new_block(dtype.construct_array_type()._from_sequence(data, dtype=dtype), BlockPlacement(slice(i, i + 1)), ndim=2) for (i, data) in enumerate(obj_columns)]
+    else:
+        bp = BlockPlacement(slice(len(columns)))
+        nb = new_block_2d(values, placement=bp, refs=refs)
+        block_values = [nb]
+    if len(columns) == 0:
+        block_values = []
+    return create_block_manager_from_blocks(block_values, [columns, index], verify_integrity=False)
+
+def _check_values_indices_shape_match(values: np.ndarray, index: Index, columns: Index) -> None:
+    if values.shape[1] != len(columns) or values.shape[0] != len(index):
+        if values.shape[0] == 0 < len(index):
+            raise ValueError('Empty data passed with indices specified.')
+        passed = values.shape
+        implied = (len(index), len(columns))
+        raise ValueError(f'Shape of passed values is {passed}, indices imply {implied}')
+
+def dict_to_mgr(data: dict, index, columns, *, dtype: DtypeObj | None=None, copy: bool=True) -> Manager:
+    arrays: Sequence[Any]
+    if columns is not None:
+        columns = ensure_index(columns)
+        arrays = [np.nan] * len(columns)
+        midxs = set()
+        data_keys = ensure_index(data.keys())
+        data_values = list(data.values())
+        for (i, column) in enumerate(columns):
+            try:
+                idx = data_keys.get_loc(column)
+            except KeyError:
+                midxs.add(i)
+                continue
+            array = data_values[idx]
+            arrays[i] = array
+            if is_scalar(array) and isna(array):
+                midxs.add(i)
+        if index is None:
+            if midxs:
+                index = _extract_index([array for (i, array) in enumerate(arrays) if i not in midxs])
+            else:
+                index = _extract_index(arrays)
+        else:
+            index = ensure_index(index)
+        if midxs and (not is_integer_dtype(dtype)):
+            for i in midxs:
+                arr = construct_1d_arraylike_from_scalar(arrays[i], len(index), dtype if dtype is not None else np.dtype('object'))
+                arrays[i] = arr
+    else:
+        keys = maybe_sequence_to_range(list(data.keys()))
+        columns = Index(keys) if keys else default_index(0)
+        arrays = [com.maybe_iterable_to_list(data[k]) for k in keys]
+    if copy:
+        arrays = [x.copy() if isinstance(x, ExtensionArray) else x.copy(deep=True) if isinstance(x, Index) or (isinstance(x, ABCSeries) and is_1d_only_ea_dtype(x.dtype)) else x for x in arrays]
+    return arrays_to_mgr(arrays, columns, index, dtype=dtype, consolidate=copy)
+
+def nested_data_to_arrays(data: Sequence, columns: Index | None, index: Index | None, dtype: DtypeObj | None) -> tuple[list[ArrayLike], Index, Index]:
+    if is_named_tuple(data[0]) and columns is None:
+        columns = ensure_index(data[0]._fields)
+    (arrays, columns) = to_arrays(data, columns, dtype=dtype)
+    columns = ensure_index(columns)
+    if index is None:
+        if isinstance(data[0], ABCSeries):
+            index = _get_names_from_index(data)
+        else:
+            index = default_index(len(data))
+    return (arrays, columns, index)
+
+def treat_as_nested(data) -> bool:
+    return len(data) > 0 and is_list_like(data[0]) and (getattr(data[0], 'ndim', 1) == 1) and (not (isinstance(data, ExtensionArray) and data.ndim == 2))
+
+def _prep_ndarraylike(values, copy: bool=True) -> np.ndarray:
+    if len(values) == 0:
+        return np.empty((0, 0), dtype=object)
+    elif isinstance(values, range):
+        arr = range_to_ndarray(values)
+        return arr[..., np.newaxis]
+
+    def convert(v):
+        if not is_list_like(v) or isinstance(v, ABCDataFrame):
+            return v
+        v = extract_array(v, extract_numpy=True)
+        res = maybe_convert_platform(v)
+        return res
+    if is_list_like(values[0]):
+        values = np.array([convert(v) for v in values])
+    elif isinstance(values[0], np.ndarray) and values[0].ndim == 0:
+        values = np.array([convert(v) for v in values])
+    else:
+        values = convert(values)
+    return _ensure_2d(values)
+
+def _ensure_2d(values: np.ndarray) -> np.ndarray:
+    if values.ndim == 1:
+        values = values.reshape((values.shape[0], 1))
+    elif values.ndim != 2:
+        raise ValueError(f'Must pass 2-d input. shape={values.shape}')
+    return values
+
+def _homogenize(data, index: Index, dtype: DtypeObj | None) -> tuple[list[ArrayLike], list[Any]]:
+    oindex = None
+    homogenized = []
+    refs: list[Any] = []
+    for val in data:
+        if isinstance(val, (ABCSeries, Index)):
+            if dtype is not None:
+                val = val.astype(dtype)
+            if isinstance(val, ABCSeries) and val.index is not index:
+                val = val.reindex(index)
+            refs.append(val._references)
+            val = val._values
+        else:
+            if isinstance(val, dict):
+                if oindex is None:
+                    oindex = index.astype('O')
+                if isinstance(index, (DatetimeIndex, TimedeltaIndex)):
+                    val = dict_compat(val)
+                else:
+                    val = dict(val)
+                val = lib.fast_multiget(val, oindex._values, default=np.nan)
+            val = sanitize_array(val, index, dtype=dtype, copy=False)
+            com.require_length_match(val, index)
+            refs.append(None)
+        homogenized.append(val)
+    return (homogenized, refs)
+
+def _extract_index(data) -> Index:
+    index: Index
+    if len(data) == 0:
+        return default_index(0)
+    raw_lengths = set()
+    indexes: list[list[Hashable] | Index] = []
+    have_raw_arrays = False
+    have_series = False
+    have_dicts = False
+    for val in data:
+        if isinstance(val, ABCSeries):
+            have_series = True
+            indexes.append(val.index)
+        elif isinstance(val, dict):
+            have_dicts = True
+            indexes.append(list(val.keys()))
+        elif is_list_like(val) and getattr(val, 'ndim', 1) == 1:
+            have_raw_arrays = True
+            raw_lengths.add(len(val))
+        elif isinstance(val, np.ndarray) and val.ndim > 1:
+            raise ValueError('Per-column arrays must each be 1-dimensional')
+    if not indexes and (not raw_lengths):
+        raise ValueError('If using all scalar values, you must pass an index')
+    if have_series:
+        index = union_indexes(indexes)
+    elif have_dicts:
+        index = union_indexes(indexes, sort=False)
+    if have_raw_arrays:
+        if len(raw_lengths) > 1:
+            raise ValueError('All arrays must be of the same length')
+        if have_dicts:
+            raise ValueError('Mixing dicts with non-Series may lead to ambiguous ordering.')
+        raw_length = raw_lengths.pop()
+        if have_series:
+            if raw_length != len(index):
+                msg = f'array length {raw_length} does not match index length {len(index)}'
+                raise ValueError(msg)
+        else:
+            index = default_index(raw_length)
+    return ensure_index(index)
+
+def reorder_arrays(arrays: list[ArrayLike], arr_columns: Index, columns: Index | None, length: int) -> tuple[list[ArrayLike], Index]:
+    if columns is not None:
+        if not columns.equals(arr_columns):
+            new_arrays: list[ArrayLike] = []
+            indexer = arr_columns.get_indexer(columns)
+            for (i, k) in enumerate(indexer):
+                if k == -1:
+                    arr = np.empty(length, dtype=object)
+                    arr.fill(np.nan)
+                else:
+                    arr = arrays[k]
+                new_arrays.append(arr)
+            arrays = new_arrays
+            arr_columns = columns
+    return (arrays, arr_columns)
+
+def _get_names_from_index(data) -> Index:
+    has_some_name = any((getattr(s, 'name', None) is not None for s in data))
+    if not has_some_name:
+        return default_index(len(data))
+    index: list[Hashable] = list(range(len(data)))
+    count = 0
+    for (i, s) in enumerate(data):
+        n = getattr(s, 'name', None)
+        if n is not None:
+            index[i] = n
+        else:
+            index[i] = f'Unnamed {count}'
+            count += 1
+    return Index(index)
+
+def _get_axes(N: int, K: int, index: Index | None, columns: Index | None) -> tuple[Index, Index]:
+    if index is None:
+        index = default_index(N)
+    else:
+        index = ensure_index(index)
+    if columns is None:
+        columns = default_index(K)
+    else:
+        columns = ensure_index(columns)
+    return (index, columns)
+
+def dataclasses_to_dicts(data):
+    from dataclasses import asdict
+    return list(map(asdict, data))
+
+def to_arrays(data, columns: Index | None, dtype: DtypeObj | None=None) -> tuple[list[ArrayLike], Index]:
+    if not len(data):
+        if isinstance(data, np.ndarray):
+            if data.dtype.names is not None:
+                columns = ensure_index(data.dtype.names)
+                arrays = [data[name] for name in columns]
+                if len(data) == 0:
+                    for (i, arr) in enumerate(arrays):
+                        if arr.ndim == 2:
+                            arrays[i] = arr[:, 0]
+                return (arrays, columns)
+        return ([], ensure_index([]))
+    elif isinstance(data, np.ndarray) and data.dtype.names is not None:
+        columns = Index(list(data.dtype.names))
+        arrays = [data[k] for k in columns]
+        return (arrays, columns)
+    if isinstance(data[0], (list, tuple)):
+        arr = _list_to_arrays(data)
+    elif isinstance(data[0], abc.Mapping):
+        (arr, columns) = _list_of_dict_to_arrays(data, columns)
+    elif isinstance(data[0], ABCSeries):
+        (arr, columns) = _list_of_series_to_arrays(data, columns)
+    else:
+        data = [tuple(x) for x in data]
+        arr = _list_to_arrays(data)
+    (content, columns) = _finalize_columns_and_data(arr, columns, dtype)
+    return (content, columns)
+
+def _list_to_arrays(data: list[tuple | list]) -> np.ndarray:
+    if isinstance(data[0], tuple):
+        content = lib.to_object_array_tuples(data)
+    else:
+        content = lib.to_object_array(data)
+    return content
+
+def _list_of_series_to_arrays(data: list, columns: Index | None) -> tuple[np.ndarray, Index]:
+    if columns is None:
+        pass_data = [x for x in data if isinstance(x, (ABCSeries, ABCDataFrame))]
+        columns = get_objs_combined_axis(pass_data, sort=False)
+    indexer_cache: dict[int, np.ndarray] = {}
+    aligned_values = []
+    for s in data:
+        index = getattr(s, 'index', None)
+        if index is None:
+            index = default_index(len(s))
+        if id(index) in indexer_cache:
+            indexer = indexer_cache[id(index)]
+        else:
+            indexer = indexer_cache[id(index)] = index.get_indexer(columns)
+        values = extract_array(s, extract_numpy=True)
+        aligned_values.append(algorithms.take_nd(values, indexer))
+    content = np.vstack(aligned_values)
+    return (content, columns)
+
+def _list_of_dict_to_arrays(data: list[dict], columns: Index | None) -> tuple[np.ndarray, Index]:
+    if columns is None:
+        gen = (list(x.keys()) for x in data)
+        sort = not any((isinstance(d, dict) for d in data))
+        pre_cols = lib.fast_unique_multiple_list_gen(gen, sort=sort)
+        columns = ensure_index(pre_cols)
+    data = [d if type(d) is dict else dict(d) for d in data]
+    content = lib.dicts_to_array(data, list(columns))
+    return (content, columns)
+
+def _finalize_columns_and_data(content: np.ndarray, columns: Index | None, dtype: DtypeObj | None) -> tuple[list[ArrayLike], Index]:
+    contents = list(content.T)
+    try:
+        columns = _validate_or_indexify_columns(contents, columns)
+    except AssertionError as err:
+        raise ValueError(err) from err
+    if len(contents) and contents[0].dtype == np.object_:
+        contents = convert_object_array(contents, dtype=dtype)
+    return (contents, columns)
+
+def _validate_or_indexify_columns(content: list[np.ndarray], columns: Index | None) -> Index:
+    if columns is None:
+        columns = default_index(len(content))
+    else:
+        is_mi_list = isinstance(columns, list) and all((isinstance(col, list) for col in columns))
+        if not is_mi_list and len(columns) != len(content):
+            raise AssertionError(f'{len(columns)} columns passed, passed data had {len(content)} columns')
+        if is_mi_list:
+            if len({len(col) for col in columns}) > 1:
+                raise ValueError('Length of columns passed for MultiIndex columns is different')
+            if columns and len(columns[0]) != len(content):
+                raise ValueError(f'{len(columns[0])} columns passed, passed data had {len(content)} columns')
+    return columns
+
+def convert_object_array(content: list[npt.NDArray[np.object_]], dtype: DtypeObj | None, dtype_backend: str='numpy', coerce_float: bool=False) -> list[ArrayLike]:
+
+    def convert(arr):
+        if dtype != np.dtype('O'):
+            arr = lib.maybe_convert_objects(arr, try_float=coerce_float, convert_to_nullable_dtype=dtype_backend != 'numpy')
+            if dtype is None:
+                if arr.dtype == np.dtype('O'):
+                    arr = maybe_infer_to_datetimelike(arr)
+                    if dtype_backend != 'numpy' and arr.dtype == np.dtype('O'):
+                        new_dtype = StringDtype()
+                        arr_cls = new_dtype.construct_array_type()
+                        arr = arr_cls._from_sequence(arr, dtype=new_dtype)
+                elif dtype_backend != 'numpy' and isinstance(arr, np.ndarray):
+                    if arr.dtype.kind in 'iufb':
+                        arr = pd_array(arr, copy=False)
+            elif isinstance(dtype, ExtensionDtype):
+                cls = dtype.construct_array_type()
+                arr = cls._from_sequence(arr, dtype=dtype, copy=False)
+            elif dtype.kind in 'mM':
+                arr = maybe_cast_to_datetime(arr, dtype)
+        return arr
+    arrays = [convert(arr) for arr in content]
+    return arrays
+
+# File: pandas-main/pandas/core/internals/managers.py
+from __future__ import annotations
+from collections.abc import Callable, Hashable, Sequence
+import itertools
+from typing import TYPE_CHECKING, Any, Literal, NoReturn, cast, final
+import warnings
+import numpy as np
+from pandas._config.config import get_option
+from pandas._libs import algos as libalgos, internals as libinternals, lib
+from pandas._libs.internals import BlockPlacement, BlockValuesRefs
+from pandas._libs.tslibs import Timestamp
+from pandas.errors import AbstractMethodError, PerformanceWarning
+from pandas.util._decorators import cache_readonly
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import validate_bool_kwarg
+from pandas.core.dtypes.cast import find_common_type, infer_dtype_from_scalar, np_can_hold_element
+from pandas.core.dtypes.common import ensure_platform_int, is_1d_only_ea_dtype, is_list_like
+from pandas.core.dtypes.dtypes import DatetimeTZDtype, ExtensionDtype, SparseDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.dtypes.missing import array_equals, isna
+import pandas.core.algorithms as algos
+from pandas.core.arrays import DatetimeArray
+from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
+from pandas.core.base import PandasObject
+from pandas.core.construction import ensure_wrapped_if_datetimelike, extract_array
+from pandas.core.indexers import maybe_convert_indices
+from pandas.core.indexes.api import Index, default_index, ensure_index
+from pandas.core.internals.blocks import Block, NumpyBlock, ensure_block_shape, extend_blocks, get_block_type, maybe_coerce_values, new_block, new_block_2d
+from pandas.core.internals.ops import blockwise_all, operate_blockwise
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from pandas._typing import ArrayLike, AxisInt, DtypeObj, QuantileInterpolation, Self, Shape, npt
+    from pandas.api.extensions import ExtensionArray
+
+def interleaved_dtype(dtypes: list[DtypeObj]) -> DtypeObj | None:
+    if not len(dtypes):
+        return None
+    return find_common_type(dtypes)
+
+def ensure_np_dtype(dtype: DtypeObj) -> np.dtype:
+    if isinstance(dtype, SparseDtype):
+        dtype = dtype.subtype
+        dtype = cast(np.dtype, dtype)
+    elif isinstance(dtype, ExtensionDtype):
+        dtype = np.dtype('object')
+    elif dtype == np.dtype(str):
+        dtype = np.dtype('object')
+    return dtype
+
+class BaseBlockManager(PandasObject):
+    __slots__ = ()
+    _blknos: npt.NDArray[np.intp]
+    _blklocs: npt.NDArray[np.intp]
+    blocks: tuple[Block, ...]
+    axes: list[Index]
+
+    @property
+    def ndim(self) -> int:
+        raise NotImplementedError
+    _known_consolidated: bool
+    _is_consolidated: bool
+
+    def __init__(self, blocks, axes, verify_integrity: bool=True) -> None:
+        raise NotImplementedError
+
+    @final
+    def __len__(self) -> int:
+        return len(self.items)
+
+    @property
+    def shape(self) -> Shape:
+        return tuple((len(ax) for ax in self.axes))
+
+    @classmethod
+    def from_blocks(cls, blocks: list[Block], axes: list[Index]) -> Self:
+        raise NotImplementedError
+
+    @property
+    def blknos(self) -> npt.NDArray[np.intp]:
+        if self._blknos is None:
+            self._rebuild_blknos_and_blklocs()
+        return self._blknos
+
+    @property
+    def blklocs(self) -> npt.NDArray[np.intp]:
+        if self._blklocs is None:
+            self._rebuild_blknos_and_blklocs()
+        return self._blklocs
+
+    def make_empty(self, axes=None) -> Self:
+        if axes is None:
+            axes = [default_index(0)] + self.axes[1:]
+        if self.ndim == 1:
+            assert isinstance(self, SingleBlockManager)
+            blk = self.blocks[0]
+            arr = blk.values[:0]
+            bp = BlockPlacement(slice(0, 0))
+            nb = blk.make_block_same_class(arr, placement=bp)
+            blocks = [nb]
+        else:
+            blocks = []
+        return type(self).from_blocks(blocks, axes)
+
+    def __bool__(self) -> bool:
+        return True
+
+    def set_axis(self, axis: AxisInt, new_labels: Index) -> None:
+        self._validate_set_axis(axis, new_labels)
+        self.axes[axis] = new_labels
+
+    @final
+    def _validate_set_axis(self, axis: AxisInt, new_labels: Index) -> None:
+        old_len = len(self.axes[axis])
+        new_len = len(new_labels)
+        if axis == 1 and len(self.items) == 0:
+            pass
+        elif new_len != old_len:
+            raise ValueError(f'Length mismatch: Expected axis has {old_len} elements, new values have {new_len} elements')
+
+    @property
+    def is_single_block(self) -> bool:
+        return len(self.blocks) == 1
+
+    @property
+    def items(self) -> Index:
+        return self.axes[0]
+
+    def _has_no_reference(self, i: int) -> bool:
+        blkno = self.blknos[i]
+        return self._has_no_reference_block(blkno)
+
+    def _has_no_reference_block(self, blkno: int) -> bool:
+        return not self.blocks[blkno].refs.has_reference()
+
+    def add_references(self, mgr: BaseBlockManager) -> None:
+        if len(self.blocks) != len(mgr.blocks):
+            return
+        for (i, blk) in enumerate(self.blocks):
+            blk.refs = mgr.blocks[i].refs
+            blk.refs.add_reference(blk)
+
+    def references_same_values(self, mgr: BaseBlockManager, blkno: int) -> bool:
+        blk = self.blocks[blkno]
+        return any((blk is ref() for ref in mgr.blocks[blkno].refs.referenced_blocks))
+
+    def get_dtypes(self) -> npt.NDArray[np.object_]:
+        dtypes = np.array([blk.dtype for blk in self.blocks], dtype=object)
+        return dtypes.take(self.blknos)
+
+    @property
+    def arrays(self) -> list[ArrayLike]:
+        return [blk.values for blk in self.blocks]
+
+    def __repr__(self) -> str:
+        output = type(self).__name__
+        for (i, ax) in enumerate(self.axes):
+            if i == 0:
+                output += f'\nItems: {ax}'
+            else:
+                output += f'\nAxis {i}: {ax}'
+        for block in self.blocks:
+            output += f'\n{block}'
+        return output
+
+    def _equal_values(self, other: Self) -> bool:
+        raise AbstractMethodError(self)
+
+    @final
+    def equals(self, other: object) -> bool:
+        if not isinstance(other, type(self)):
+            return False
+        (self_axes, other_axes) = (self.axes, other.axes)
+        if len(self_axes) != len(other_axes):
+            return False
+        if not all((ax1.equals(ax2) for (ax1, ax2) in zip(self_axes, other_axes))):
+            return False
+        return self._equal_values(other)
+
+    def apply(self, f, align_keys: list[str] | None=None, **kwargs) -> Self:
+        assert 'filter' not in kwargs
+        align_keys = align_keys or []
+        result_blocks: list[Block] = []
+        aligned_args = {k: kwargs[k] for k in align_keys}
+        for b in self.blocks:
+            if aligned_args:
+                for (k, obj) in aligned_args.items():
+                    if isinstance(obj, (ABCSeries, ABCDataFrame)):
+                        if obj.ndim == 1:
+                            kwargs[k] = obj.iloc[b.mgr_locs.indexer]._values
+                        else:
+                            kwargs[k] = obj.iloc[:, b.mgr_locs.indexer]._values
+                    else:
+                        kwargs[k] = obj[b.mgr_locs.indexer]
+            if callable(f):
+                applied = b.apply(f, **kwargs)
+            else:
+                applied = getattr(b, f)(**kwargs)
+            result_blocks = extend_blocks(applied, result_blocks)
+        out = type(self).from_blocks(result_blocks, self.axes)
+        return out
+
+    @final
+    def isna(self, func) -> Self:
+        return self.apply('apply', func=func)
+
+    @final
+    def fillna(self, value, limit: int | None, inplace: bool) -> Self:
+        if limit is not None:
+            limit = libalgos.validate_limit(None, limit=limit)
+        return self.apply('fillna', value=value, limit=limit, inplace=inplace)
+
+    @final
+    def where(self, other, cond, align: bool) -> Self:
+        if align:
+            align_keys = ['other', 'cond']
+        else:
+            align_keys = ['cond']
+            other = extract_array(other, extract_numpy=True)
+        return self.apply('where', align_keys=align_keys, other=other, cond=cond)
+
+    @final
+    def putmask(self, mask, new, align: bool=True) -> Self:
+        if align:
+            align_keys = ['new', 'mask']
+        else:
+            align_keys = ['mask']
+            new = extract_array(new, extract_numpy=True)
+        return self.apply('putmask', align_keys=align_keys, mask=mask, new=new)
+
+    @final
+    def round(self, decimals: int) -> Self:
+        return self.apply('round', decimals=decimals)
+
+    @final
+    def replace(self, to_replace, value, inplace: bool) -> Self:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        assert not lib.is_list_like(to_replace)
+        assert not lib.is_list_like(value)
+        return self.apply('replace', to_replace=to_replace, value=value, inplace=inplace)
+
+    @final
+    def replace_regex(self, **kwargs) -> Self:
+        return self.apply('_replace_regex', **kwargs)
+
+    @final
+    def replace_list(self, src_list: list[Any], dest_list: list[Any], inplace: bool=False, regex: bool=False) -> Self:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        bm = self.apply('replace_list', src_list=src_list, dest_list=dest_list, inplace=inplace, regex=regex)
+        bm._consolidate_inplace()
+        return bm
+
+    def interpolate(self, inplace: bool, **kwargs) -> Self:
+        return self.apply('interpolate', inplace=inplace, **kwargs)
+
+    def pad_or_backfill(self, inplace: bool, **kwargs) -> Self:
+        return self.apply('pad_or_backfill', inplace=inplace, **kwargs)
+
+    def shift(self, periods: int, fill_value) -> Self:
+        if fill_value is lib.no_default:
+            fill_value = None
+        return self.apply('shift', periods=periods, fill_value=fill_value)
+
+    def setitem(self, indexer, value) -> Self:
+        if isinstance(indexer, np.ndarray) and indexer.ndim > self.ndim:
+            raise ValueError(f'Cannot set values with ndim > {self.ndim}')
+        if not self._has_no_reference(0):
+            if self.ndim == 2 and isinstance(indexer, tuple):
+                blk_loc = self.blklocs[indexer[1]]
+                if is_list_like(blk_loc) and blk_loc.ndim == 2:
+                    blk_loc = np.squeeze(blk_loc, axis=0)
+                elif not is_list_like(blk_loc):
+                    blk_loc = [blk_loc]
+                if len(blk_loc) == 0:
+                    return self.copy(deep=False)
+                values = self.blocks[0].values
+                if values.ndim == 2:
+                    values = values[blk_loc]
+                    self._iset_split_block(0, blk_loc, values)
+                    self.blocks[0].setitem((indexer[0], np.arange(len(blk_loc))), value)
+                    return self
+            self = self.copy()
+        return self.apply('setitem', indexer=indexer, value=value)
+
+    def diff(self, n: int) -> Self:
+        return self.apply('diff', n=n)
+
+    def astype(self, dtype, errors: str='raise') -> Self:
+        return self.apply('astype', dtype=dtype, errors=errors)
+
+    def convert(self) -> Self:
+        return self.apply('convert')
+
+    def convert_dtypes(self, **kwargs):
+        return self.apply('convert_dtypes', **kwargs)
+
+    def get_values_for_csv(self, *, float_format, date_format, decimal, na_rep: str='nan', quoting=None) -> Self:
+        return self.apply('get_values_for_csv', na_rep=na_rep, quoting=quoting, float_format=float_format, date_format=date_format, decimal=decimal)
+
+    @property
+    def any_extension_types(self) -> bool:
+        return any((block.is_extension for block in self.blocks))
+
+    @property
+    def is_view(self) -> bool:
+        if len(self.blocks) == 1:
+            return self.blocks[0].is_view
+        return False
+
+    def _get_data_subset(self, predicate: Callable) -> Self:
+        blocks = [blk for blk in self.blocks if predicate(blk.values)]
+        return self._combine(blocks)
+
+    def get_bool_data(self) -> Self:
+        new_blocks = []
+        for blk in self.blocks:
+            if blk.dtype == bool:
+                new_blocks.append(blk)
+            elif blk.is_object:
+                new_blocks.extend((nb for nb in blk._split() if nb.is_bool))
+        return self._combine(new_blocks)
+
+    def get_numeric_data(self) -> Self:
+        numeric_blocks = [blk for blk in self.blocks if blk.is_numeric]
+        if len(numeric_blocks) == len(self.blocks):
+            return self
+        return self._combine(numeric_blocks)
+
+    def _combine(self, blocks: list[Block], index: Index | None=None) -> Self:
+        if len(blocks) == 0:
+            if self.ndim == 2:
+                if index is not None:
+                    axes = [self.items[:0], index]
+                else:
+                    axes = [self.items[:0]] + self.axes[1:]
+                return self.make_empty(axes)
+            return self.make_empty()
+        indexer = np.sort(np.concatenate([b.mgr_locs.as_array for b in blocks]))
+        inv_indexer = lib.get_reverse_indexer(indexer, self.shape[0])
+        new_blocks: list[Block] = []
+        for b in blocks:
+            nb = b.copy(deep=False)
+            nb.mgr_locs = BlockPlacement(inv_indexer[nb.mgr_locs.indexer])
+            new_blocks.append(nb)
+        axes = list(self.axes)
+        if index is not None:
+            axes[-1] = index
+        axes[0] = self.items.take(indexer)
+        return type(self).from_blocks(new_blocks, axes)
+
+    @property
+    def nblocks(self) -> int:
+        return len(self.blocks)
+
+    def copy(self, deep: bool | Literal['all']=True) -> Self:
+        if deep:
+
+            def copy_func(ax):
+                return ax.copy(deep=True) if deep == 'all' else ax.view()
+            new_axes = [copy_func(ax) for ax in self.axes]
+        else:
+            new_axes = [ax.view() for ax in self.axes]
+        res = self.apply('copy', deep=deep)
+        res.axes = new_axes
+        if self.ndim > 1:
+            blknos = self._blknos
+            if blknos is not None:
+                res._blknos = blknos.copy()
+                res._blklocs = self._blklocs.copy()
+        if deep:
+            res._consolidate_inplace()
+        return res
+
+    def is_consolidated(self) -> bool:
+        return True
+
+    def consolidate(self) -> Self:
+        if self.is_consolidated():
+            return self
+        bm = type(self)(self.blocks, self.axes, verify_integrity=False)
+        bm._is_consolidated = False
+        bm._consolidate_inplace()
+        return bm
+
+    def _consolidate_inplace(self) -> None:
+        return
+
+    @final
+    def reindex_axis(self, new_index: Index, axis: AxisInt, fill_value=None, only_slice: bool=False) -> Self:
+        (new_index, indexer) = self.axes[axis].reindex(new_index)
+        return self.reindex_indexer(new_index, indexer, axis=axis, fill_value=fill_value, only_slice=only_slice)
+
+    def reindex_indexer(self, new_axis: Index, indexer: npt.NDArray[np.intp] | None, axis: AxisInt, fill_value=None, allow_dups: bool=False, only_slice: bool=False, *, use_na_proxy: bool=False) -> Self:
+        if indexer is None:
+            if new_axis is self.axes[axis]:
+                return self
+            result = self.copy(deep=False)
+            result.axes = list(self.axes)
+            result.axes[axis] = new_axis
+            return result
+        assert isinstance(indexer, np.ndarray)
+        if not allow_dups:
+            self.axes[axis]._validate_can_reindex(indexer)
+        if axis >= self.ndim:
+            raise IndexError('Requested axis not found in manager')
+        if axis == 0:
+            new_blocks = list(self._slice_take_blocks_ax0(indexer, fill_value=fill_value, only_slice=only_slice, use_na_proxy=use_na_proxy))
+        else:
+            new_blocks = [blk.take_nd(indexer, axis=1, fill_value=fill_value if fill_value is not None else blk.fill_value) for blk in self.blocks]
+        new_axes = list(self.axes)
+        new_axes[axis] = new_axis
+        new_mgr = type(self).from_blocks(new_blocks, new_axes)
+        if axis == 1:
+            new_mgr._blknos = self.blknos.copy()
+            new_mgr._blklocs = self.blklocs.copy()
+        return new_mgr
+
+    def _slice_take_blocks_ax0(self, slice_or_indexer: slice | np.ndarray, fill_value=lib.no_default, only_slice: bool=False, *, use_na_proxy: bool=False, ref_inplace_op: bool=False) -> Generator[Block, None, None]:
+        allow_fill = fill_value is not lib.no_default
+        (sl_type, slobj, sllen) = _preprocess_slice_or_indexer(slice_or_indexer, self.shape[0], allow_fill=allow_fill)
+        if self.is_single_block:
+            blk = self.blocks[0]
+            if sl_type == 'slice':
+                if sllen == 0:
+                    return
+                bp = BlockPlacement(slice(0, sllen))
+                yield blk.getitem_block_columns(slobj, new_mgr_locs=bp)
+                return
+            elif not allow_fill or self.ndim == 1:
+                if allow_fill and fill_value is None:
+                    fill_value = blk.fill_value
+                if not allow_fill and only_slice:
+                    for (i, ml) in enumerate(slobj):
+                        yield blk.getitem_block_columns(slice(ml, ml + 1), new_mgr_locs=BlockPlacement(i), ref_inplace_op=ref_inplace_op)
+                else:
+                    bp = BlockPlacement(slice(0, sllen))
+                    yield blk.take_nd(slobj, axis=0, new_mgr_locs=bp, fill_value=fill_value)
+                return
+        if sl_type == 'slice':
+            blknos = self.blknos[slobj]
+            blklocs = self.blklocs[slobj]
+        else:
+            blknos = algos.take_nd(self.blknos, slobj, fill_value=-1, allow_fill=allow_fill)
+            blklocs = algos.take_nd(self.blklocs, slobj, fill_value=-1, allow_fill=allow_fill)
+        group = not only_slice
+        for (blkno, mgr_locs) in libinternals.get_blkno_placements(blknos, group=group):
+            if blkno == -1:
+                yield self._make_na_block(placement=mgr_locs, fill_value=fill_value, use_na_proxy=use_na_proxy)
+            else:
+                blk = self.blocks[blkno]
+                if not blk._can_consolidate and (not blk._validate_ndim):
+                    deep = False
+                    for mgr_loc in mgr_locs:
+                        newblk = blk.copy(deep=deep)
+                        newblk.mgr_locs = BlockPlacement(slice(mgr_loc, mgr_loc + 1))
+                        yield newblk
+                else:
+                    taker = blklocs[mgr_locs.indexer]
+                    max_len = max(len(mgr_locs), taker.max() + 1)
+                    taker = lib.maybe_indices_to_slice(taker, max_len)
+                    if isinstance(taker, slice):
+                        nb = blk.getitem_block_columns(taker, new_mgr_locs=mgr_locs)
+                        yield nb
+                    elif only_slice:
+                        for (i, ml) in zip(taker, mgr_locs):
+                            slc = slice(i, i + 1)
+                            bp = BlockPlacement(ml)
+                            nb = blk.getitem_block_columns(slc, new_mgr_locs=bp)
+                            yield nb
+                    else:
+                        nb = blk.take_nd(taker, axis=0, new_mgr_locs=mgr_locs)
+                        yield nb
+
+    def _make_na_block(self, placement: BlockPlacement, fill_value=None, use_na_proxy: bool=False) -> Block:
+        if use_na_proxy:
+            assert fill_value is None
+            shape = (len(placement), self.shape[1])
+            vals = np.empty(shape, dtype=np.void)
+            nb = NumpyBlock(vals, placement, ndim=2)
+            return nb
+        if fill_value is None or fill_value is np.nan:
+            fill_value = np.nan
+            dtype = interleaved_dtype([blk.dtype for blk in self.blocks])
+            if dtype is not None and np.issubdtype(dtype.type, np.floating):
+                fill_value = dtype.type(fill_value)
+        shape = (len(placement), self.shape[1])
+        (dtype, fill_value) = infer_dtype_from_scalar(fill_value)
+        block_values = make_na_array(dtype, shape, fill_value)
+        return new_block_2d(block_values, placement=placement)
+
+    def take(self, indexer: npt.NDArray[np.intp], axis: AxisInt=1, verify: bool=True) -> Self:
+        n = self.shape[axis]
+        indexer = maybe_convert_indices(indexer, n, verify=verify)
+        new_labels = self.axes[axis].take(indexer)
+        return self.reindex_indexer(new_axis=new_labels, indexer=indexer, axis=axis, allow_dups=True)
+
+class BlockManager(libinternals.BlockManager, BaseBlockManager):
+    ndim = 2
+
+    def __init__(self, blocks: Sequence[Block], axes: Sequence[Index], verify_integrity: bool=True) -> None:
+        if verify_integrity:
+            for block in blocks:
+                if self.ndim != block.ndim:
+                    raise AssertionError(f'Number of Block dimensions ({block.ndim}) must equal number of axes ({self.ndim})')
+            self._verify_integrity()
+
+    def _verify_integrity(self) -> None:
+        mgr_shape = self.shape
+        tot_items = sum((len(x.mgr_locs) for x in self.blocks))
+        for block in self.blocks:
+            if block.shape[1:] != mgr_shape[1:]:
+                raise_construction_error(tot_items, block.shape[1:], self.axes)
+        if len(self.items) != tot_items:
+            raise AssertionError(f'Number of manager items must equal union of block items\n# manager items: {len(self.items)}, # tot_items: {tot_items}')
+
+    @classmethod
+    def from_blocks(cls, blocks: list[Block], axes: list[Index]) -> Self:
+        return cls(blocks, axes, verify_integrity=False)
+
+    def fast_xs(self, loc: int) -> SingleBlockManager:
+        if len(self.blocks) == 1:
+            result: np.ndarray | ExtensionArray = self.blocks[0].iget((slice(None), loc))
+            bp = BlockPlacement(slice(0, len(result)))
+            block = new_block(result, placement=bp, ndim=1, refs=self.blocks[0].refs)
+            return SingleBlockManager(block, self.axes[0])
+        dtype = interleaved_dtype([blk.dtype for blk in self.blocks])
+        n = len(self)
+        if isinstance(dtype, ExtensionDtype):
+            result = np.empty(n, dtype=object)
+        else:
+            result = np.empty(n, dtype=dtype)
+            result = ensure_wrapped_if_datetimelike(result)
+        for blk in self.blocks:
+            for (i, rl) in enumerate(blk.mgr_locs):
+                result[rl] = blk.iget((i, loc))
+        if isinstance(dtype, ExtensionDtype):
+            cls = dtype.construct_array_type()
+            result = cls._from_sequence(result, dtype=dtype)
+        bp = BlockPlacement(slice(0, len(result)))
+        block = new_block(result, placement=bp, ndim=1)
+        return SingleBlockManager(block, self.axes[0])
+
+    def iget(self, i: int, track_ref: bool=True) -> SingleBlockManager:
+        block = self.blocks[self.blknos[i]]
+        values = block.iget(self.blklocs[i])
+        bp = BlockPlacement(slice(0, len(values)))
+        nb = type(block)(values, placement=bp, ndim=1, refs=block.refs if track_ref else None)
+        return SingleBlockManager(nb, self.axes[1])
+
+    def iget_values(self, i: int) -> ArrayLike:
+        block = self.blocks[self.blknos[i]]
+        values = block.iget(self.blklocs[i])
+        return values
+
+    @property
+    def column_arrays(self) -> list[np.ndarray]:
+        result: list[np.ndarray | None] = [None] * len(self.items)
+        for blk in self.blocks:
+            mgr_locs = blk._mgr_locs
+            values = blk.array_values._values_for_json()
+            if values.ndim == 1:
+                result[mgr_locs[0]] = values
+            else:
+                for (i, loc) in enumerate(mgr_locs):
+                    result[loc] = values[i]
+        return result
+
+    def iset(self, loc: int | slice | np.ndarray, value: ArrayLike, inplace: bool=False, refs: BlockValuesRefs | None=None) -> None:
+        if self._blklocs is None and self.ndim > 1:
+            self._rebuild_blknos_and_blklocs()
+        value_is_extension_type = is_1d_only_ea_dtype(value.dtype)
+        if not value_is_extension_type:
+            if value.ndim == 2:
+                value = value.T
+            else:
+                value = ensure_block_shape(value, ndim=2)
+            if value.shape[1:] != self.shape[1:]:
+                raise AssertionError('Shape of new values must be compatible with manager shape')
+        if lib.is_integer(loc):
+            loc = cast(int, loc)
+            blkno = self.blknos[loc]
+            blk = self.blocks[blkno]
+            if len(blk._mgr_locs) == 1:
+                return self._iset_single(loc, value, inplace=inplace, blkno=blkno, blk=blk, refs=refs)
+            loc = [loc]
+        if value_is_extension_type:
+
+            def value_getitem(placement):
+                return value
+        else:
+
+            def value_getitem(placement):
+                return value[placement.indexer]
+        blknos = self.blknos[loc]
+        blklocs = self.blklocs[loc].copy()
+        unfit_mgr_locs = []
+        unfit_val_locs = []
+        removed_blknos = []
+        for (blkno_l, val_locs) in libinternals.get_blkno_placements(blknos, group=True):
+            blk = self.blocks[blkno_l]
+            blk_locs = blklocs[val_locs.indexer]
+            if inplace and blk.should_store(value):
+                if not self._has_no_reference_block(blkno_l):
+                    self._iset_split_block(blkno_l, blk_locs, value_getitem(val_locs), refs=refs)
+                else:
+                    blk.set_inplace(blk_locs, value_getitem(val_locs))
+                    continue
+            else:
+                unfit_mgr_locs.append(blk.mgr_locs.as_array[blk_locs])
+                unfit_val_locs.append(val_locs)
+                if len(val_locs) == len(blk.mgr_locs):
+                    removed_blknos.append(blkno_l)
+                    continue
+                else:
+                    self._iset_split_block(blkno_l, blk_locs, refs=refs)
+        if len(removed_blknos):
+            is_deleted = np.zeros(self.nblocks, dtype=np.bool_)
+            is_deleted[removed_blknos] = True
+            new_blknos = np.empty(self.nblocks, dtype=np.intp)
+            new_blknos.fill(-1)
+            new_blknos[~is_deleted] = np.arange(self.nblocks - len(removed_blknos))
+            self._blknos = new_blknos[self._blknos]
+            self.blocks = tuple((blk for (i, blk) in enumerate(self.blocks) if i not in set(removed_blknos)))
+        if unfit_val_locs:
+            unfit_idxr = np.concatenate(unfit_mgr_locs)
+            unfit_count = len(unfit_idxr)
+            new_blocks: list[Block] = []
+            if value_is_extension_type:
+                new_blocks.extend((new_block_2d(values=value, placement=BlockPlacement(slice(mgr_loc, mgr_loc + 1)), refs=refs) for mgr_loc in unfit_idxr))
+                self._blknos[unfit_idxr] = np.arange(unfit_count) + len(self.blocks)
+                self._blklocs[unfit_idxr] = 0
+            else:
+                unfit_val_items = unfit_val_locs[0].append(unfit_val_locs[1:])
+                new_blocks.append(new_block_2d(values=value_getitem(unfit_val_items), placement=BlockPlacement(unfit_idxr), refs=refs))
+                self._blknos[unfit_idxr] = len(self.blocks)
+                self._blklocs[unfit_idxr] = np.arange(unfit_count)
+            self.blocks += tuple(new_blocks)
+            self._known_consolidated = False
+
+    def _iset_split_block(self, blkno_l: int, blk_locs: np.ndarray | list[int], value: ArrayLike | None=None, refs: BlockValuesRefs | None=None) -> None:
+        blk = self.blocks[blkno_l]
+        if self._blklocs is None:
+            self._rebuild_blknos_and_blklocs()
+        nbs_tup = tuple(blk.delete(blk_locs))
+        if value is not None:
+            locs = blk.mgr_locs.as_array[blk_locs]
+            first_nb = new_block_2d(value, BlockPlacement(locs), refs=refs)
+        else:
+            first_nb = nbs_tup[0]
+            nbs_tup = tuple(nbs_tup[1:])
+        nr_blocks = len(self.blocks)
+        blocks_tup = self.blocks[:blkno_l] + (first_nb,) + self.blocks[blkno_l + 1:] + nbs_tup
+        self.blocks = blocks_tup
+        if not nbs_tup and value is not None:
+            return
+        self._blklocs[first_nb.mgr_locs.indexer] = np.arange(len(first_nb))
+        for (i, nb) in enumerate(nbs_tup):
+            self._blklocs[nb.mgr_locs.indexer] = np.arange(len(nb))
+            self._blknos[nb.mgr_locs.indexer] = i + nr_blocks
+
+    def _iset_single(self, loc: int, value: ArrayLike, inplace: bool, blkno: int, blk: Block, refs: BlockValuesRefs | None=None) -> None:
+        if inplace and blk.should_store(value):
+            copy = not self._has_no_reference_block(blkno)
+            iloc = self.blklocs[loc]
+            blk.set_inplace(slice(iloc, iloc + 1), value, copy=copy)
+            return
+        nb = new_block_2d(value, placement=blk._mgr_locs, refs=refs)
+        old_blocks = self.blocks
+        new_blocks = old_blocks[:blkno] + (nb,) + old_blocks[blkno + 1:]
+        self.blocks = new_blocks
+        return
+
+    def column_setitem(self, loc: int, idx: int | slice | np.ndarray, value, inplace_only: bool=False) -> None:
+        if not self._has_no_reference(loc):
+            blkno = self.blknos[loc]
+            blk_loc = self.blklocs[loc]
+            values = self.blocks[blkno].values
+            if values.ndim == 1:
+                values = values.copy()
+            else:
+                values = values[[blk_loc]]
+            self._iset_split_block(blkno, [blk_loc], values)
+        col_mgr = self.iget(loc, track_ref=False)
+        if inplace_only:
+            col_mgr.setitem_inplace(idx, value)
+        else:
+            new_mgr = col_mgr.setitem((idx,), value)
+            self.iset(loc, new_mgr._block.values, inplace=True)
+
+    def insert(self, loc: int, item: Hashable, value: ArrayLike, refs=None) -> None:
+        new_axis = self.items.insert(loc, item)
+        if value.ndim == 2:
+            value = value.T
+            if len(value) > 1:
+                raise ValueError(f'Expected a 1D array, got an array with shape {value.T.shape}')
+        else:
+            value = ensure_block_shape(value, ndim=self.ndim)
+        bp = BlockPlacement(slice(loc, loc + 1))
+        block = new_block_2d(values=value, placement=bp, refs=refs)
+        if not len(self.blocks):
+            self._blklocs = np.array([0], dtype=np.intp)
+            self._blknos = np.array([0], dtype=np.intp)
+        else:
+            self._insert_update_mgr_locs(loc)
+            self._insert_update_blklocs_and_blknos(loc)
+        self.axes[0] = new_axis
+        self.blocks += (block,)
+        self._known_consolidated = False
+        if get_option('performance_warnings') and sum((not block.is_extension for block in self.blocks)) > 100:
+            warnings.warn('DataFrame is highly fragmented.  This is usually the result of calling `frame.insert` many times, which has poor performance.  Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()`', PerformanceWarning, stacklevel=find_stack_level())
+
+    def _insert_update_mgr_locs(self, loc) -> None:
+        blknos = np.bincount(self.blknos[loc:]).nonzero()[0]
+        for blkno in blknos:
+            blk = self.blocks[blkno]
+            blk._mgr_locs = blk._mgr_locs.increment_above(loc)
+
+    def _insert_update_blklocs_and_blknos(self, loc) -> None:
+        if loc == self.blklocs.shape[0]:
+            self._blklocs = np.append(self._blklocs, 0)
+            self._blknos = np.append(self._blknos, len(self.blocks))
+        elif loc == 0:
+            self._blklocs = np.concatenate([[0], self._blklocs])
+            self._blknos = np.concatenate([[len(self.blocks)], self._blknos])
+        else:
+            (new_blklocs, new_blknos) = libinternals.update_blklocs_and_blknos(self.blklocs, self.blknos, loc, len(self.blocks))
+            self._blklocs = new_blklocs
+            self._blknos = new_blknos
+
+    def idelete(self, indexer) -> BlockManager:
+        is_deleted = np.zeros(self.shape[0], dtype=np.bool_)
+        is_deleted[indexer] = True
+        taker = (~is_deleted).nonzero()[0]
+        nbs = self._slice_take_blocks_ax0(taker, only_slice=True, ref_inplace_op=True)
+        new_columns = self.items[~is_deleted]
+        axes = [new_columns, self.axes[1]]
+        return type(self)(tuple(nbs), axes, verify_integrity=False)
+
+    def grouped_reduce(self, func: Callable) -> Self:
+        result_blocks: list[Block] = []
+        for blk in self.blocks:
+            if blk.is_object:
+                for sb in blk._split():
+                    applied = sb.apply(func)
+                    result_blocks = extend_blocks(applied, result_blocks)
+            else:
+                applied = blk.apply(func)
+                result_blocks = extend_blocks(applied, result_blocks)
+        if len(result_blocks) == 0:
+            nrows = 0
+        else:
+            nrows = result_blocks[0].values.shape[-1]
+        index = default_index(nrows)
+        return type(self).from_blocks(result_blocks, [self.axes[0], index])
+
+    def reduce(self, func: Callable) -> Self:
+        assert self.ndim == 2
+        res_blocks: list[Block] = []
+        for blk in self.blocks:
+            nbs = blk.reduce(func)
+            res_blocks.extend(nbs)
+        index = Index([None])
+        new_mgr = type(self).from_blocks(res_blocks, [self.items, index])
+        return new_mgr
+
+    def operate_blockwise(self, other: BlockManager, array_op) -> BlockManager:
+        return operate_blockwise(self, other, array_op)
+
+    def _equal_values(self: BlockManager, other: BlockManager) -> bool:
+        return blockwise_all(self, other, array_equals)
+
+    def quantile(self, *, qs: Index, interpolation: QuantileInterpolation='linear') -> Self:
+        assert self.ndim >= 2
+        assert is_list_like(qs)
+        new_axes = list(self.axes)
+        new_axes[1] = Index(qs, dtype=np.float64)
+        blocks = [blk.quantile(qs=qs, interpolation=interpolation) for blk in self.blocks]
+        return type(self)(blocks, new_axes)
+
+    def unstack(self, unstacker, fill_value) -> BlockManager:
+        new_columns = unstacker.get_new_columns(self.items)
+        new_index = unstacker.new_index
+        allow_fill = not unstacker.mask_all
+        if allow_fill:
+            new_mask2D = (~unstacker.mask).reshape(*unstacker.full_shape)
+            needs_masking = new_mask2D.any(axis=0)
+        else:
+            needs_masking = np.zeros(unstacker.full_shape[1], dtype=bool)
+        new_blocks: list[Block] = []
+        columns_mask: list[np.ndarray] = []
+        if len(self.items) == 0:
+            factor = 1
+        else:
+            fac = len(new_columns) / len(self.items)
+            assert fac == int(fac)
+            factor = int(fac)
+        for blk in self.blocks:
+            mgr_locs = blk.mgr_locs
+            new_placement = mgr_locs.tile_for_unstack(factor)
+            (blocks, mask) = blk._unstack(unstacker, fill_value, new_placement=new_placement, needs_masking=needs_masking)
+            new_blocks.extend(blocks)
+            columns_mask.extend(mask)
+            assert mask.sum() == sum((len(nb._mgr_locs) for nb in blocks))
+        new_columns = new_columns[columns_mask]
+        bm = BlockManager(new_blocks, [new_columns, new_index], verify_integrity=False)
+        return bm
+
+    def to_iter_dict(self) -> Generator[tuple[str, Self], None, None]:
+        key = lambda block: str(block.dtype)
+        for (dtype, blocks) in itertools.groupby(sorted(self.blocks, key=key), key=key):
+            yield (dtype, self._combine(list(blocks)))
+
+    def as_array(self, dtype: np.dtype | None=None, copy: bool=False, na_value: object=lib.no_default) -> np.ndarray:
+        passed_nan = lib.is_float(na_value) and isna(na_value)
+        if len(self.blocks) == 0:
+            arr = np.empty(self.shape, dtype=float)
+            return arr.transpose()
+        if self.is_single_block:
+            blk = self.blocks[0]
+            if na_value is not lib.no_default:
+                if lib.is_np_dtype(blk.dtype, 'f') and passed_nan:
+                    pass
+                else:
+                    copy = True
+            if blk.is_extension:
+                arr = blk.values.to_numpy(dtype=dtype, na_value=na_value, copy=copy).reshape(blk.shape)
+            elif not copy:
+                arr = np.asarray(blk.values, dtype=dtype)
+            else:
+                arr = np.array(blk.values, dtype=dtype, copy=copy)
+            if not copy:
+                arr = arr.view()
+                arr.flags.writeable = False
+        else:
+            arr = self._interleave(dtype=dtype, na_value=na_value)
+        if na_value is lib.no_default:
+            pass
+        elif arr.dtype.kind == 'f' and passed_nan:
+            pass
+        else:
+            arr[isna(arr)] = na_value
+        return arr.transpose()
+
+    def _interleave(self, dtype: np.dtype | None=None, na_value: object=lib.no_default) -> np.ndarray:
+        if not dtype:
+            dtype = interleaved_dtype([blk.dtype for blk in self.blocks])
+        dtype = ensure_np_dtype(dtype)
+        result = np.empty(self.shape, dtype=dtype)
+        itemmask = np.zeros(self.shape[0])
+        if dtype == np.dtype('object') and na_value is lib.no_default:
+            for blk in self.blocks:
+                rl = blk.mgr_locs
+                arr = blk.get_values(dtype)
+                result[rl.indexer] = arr
+                itemmask[rl.indexer] = 1
+            return result
+        for blk in self.blocks:
+            rl = blk.mgr_locs
+            if blk.is_extension:
+                arr = blk.values.to_numpy(dtype=dtype, na_value=na_value)
+            else:
+                arr = blk.get_values(dtype)
+            result[rl.indexer] = arr
+            itemmask[rl.indexer] = 1
+        if not itemmask.all():
+            raise AssertionError('Some items were not contained in blocks')
+        return result
+
+    def is_consolidated(self) -> bool:
+        if not self._known_consolidated:
+            self._consolidate_check()
+        return self._is_consolidated
+
+    def _consolidate_check(self) -> None:
+        if len(self.blocks) == 1:
+            self._is_consolidated = True
+            self._known_consolidated = True
+            return
+        dtypes = [blk.dtype for blk in self.blocks if blk._can_consolidate]
+        self._is_consolidated = len(dtypes) == len(set(dtypes))
+        self._known_consolidated = True
+
+    def _consolidate_inplace(self) -> None:
+        if not self.is_consolidated():
+            self.blocks = _consolidate(self.blocks)
+            self._is_consolidated = True
+            self._known_consolidated = True
+            self._rebuild_blknos_and_blklocs()
+
+    @classmethod
+    def concat_horizontal(cls, mgrs: list[Self], axes: list[Index]) -> Self:
+        offset = 0
+        blocks: list[Block] = []
+        for mgr in mgrs:
+            for blk in mgr.blocks:
+                nb = blk.slice_block_columns(slice(None))
+                nb._mgr_locs = nb._mgr_locs.add(offset)
+                blocks.append(nb)
+            offset += len(mgr.items)
+        new_mgr = cls(tuple(blocks), axes)
+        return new_mgr
+
+    @classmethod
+    def concat_vertical(cls, mgrs: list[Self], axes: list[Index]) -> Self:
+        raise NotImplementedError('This logic lives (for now) in internals.concat')
+
+class SingleBlockManager(BaseBlockManager):
+
+    @property
+    def ndim(self) -> Literal[1]:
+        return 1
+    _is_consolidated = True
+    _known_consolidated = True
+    __slots__ = ()
+    is_single_block = True
+
+    def __init__(self, block: Block, axis: Index, verify_integrity: bool=False) -> None:
+        self.axes = [axis]
+        self.blocks = (block,)
+
+    @classmethod
+    def from_blocks(cls, blocks: list[Block], axes: list[Index]) -> Self:
+        assert len(blocks) == 1
+        assert len(axes) == 1
+        return cls(blocks[0], axes[0], verify_integrity=False)
+
+    @classmethod
+    def from_array(cls, array: ArrayLike, index: Index, refs: BlockValuesRefs | None=None) -> SingleBlockManager:
+        array = maybe_coerce_values(array)
+        bp = BlockPlacement(slice(0, len(index)))
+        block = new_block(array, placement=bp, ndim=1, refs=refs)
+        return cls(block, index)
+
+    def to_2d_mgr(self, columns: Index) -> BlockManager:
+        blk = self.blocks[0]
+        arr = ensure_block_shape(blk.values, ndim=2)
+        bp = BlockPlacement(0)
+        new_blk = type(blk)(arr, placement=bp, ndim=2, refs=blk.refs)
+        axes = [columns, self.axes[0]]
+        return BlockManager([new_blk], axes=axes, verify_integrity=False)
+
+    def _has_no_reference(self, i: int=0) -> bool:
+        return not self.blocks[0].refs.has_reference()
+
+    def __getstate__(self):
+        block_values = [b.values for b in self.blocks]
+        block_items = [self.items[b.mgr_locs.indexer] for b in self.blocks]
+        axes_array = list(self.axes)
+        extra_state = {'0.14.1': {'axes': axes_array, 'blocks': [{'values': b.values, 'mgr_locs': b.mgr_locs.indexer} for b in self.blocks]}}
+        return (axes_array, block_values, block_items, extra_state)
+
+    def __setstate__(self, state) -> None:
+
+        def unpickle_block(values, mgr_locs, ndim: int) -> Block:
+            values = extract_array(values, extract_numpy=True)
+            if not isinstance(mgr_locs, BlockPlacement):
+                mgr_locs = BlockPlacement(mgr_locs)
+            values = maybe_coerce_values(values)
+            return new_block(values, placement=mgr_locs, ndim=ndim)
+        if isinstance(state, tuple) and len(state) >= 4 and ('0.14.1' in state[3]):
+            state = state[3]['0.14.1']
+            self.axes = [ensure_index(ax) for ax in state['axes']]
+            ndim = len(self.axes)
+            self.blocks = tuple((unpickle_block(b['values'], b['mgr_locs'], ndim=ndim) for b in state['blocks']))
+        else:
+            raise NotImplementedError('pre-0.14.1 pickles are no longer supported')
+        self._post_setstate()
+
+    def _post_setstate(self) -> None:
+        pass
+
+    @cache_readonly
+    def _block(self) -> Block:
+        return self.blocks[0]
+
+    @final
+    @property
+    def array(self) -> ArrayLike:
+        return self.blocks[0].values
+
+    @property
+    def _blknos(self) -> None:
+        return None
+
+    @property
+    def _blklocs(self) -> None:
+        return None
+
+    def get_rows_with_mask(self, indexer: npt.NDArray[np.bool_]) -> Self:
+        blk = self._block
+        if len(indexer) > 0 and indexer.all():
+            return type(self)(blk.copy(deep=False), self.index)
+        array = blk.values[indexer]
+        if isinstance(indexer, np.ndarray) and indexer.dtype.kind == 'b':
+            refs = None
+        else:
+            refs = blk.refs
+        bp = BlockPlacement(slice(0, len(array)))
+        block = type(blk)(array, placement=bp, ndim=1, refs=refs)
+        new_idx = self.index[indexer]
+        return type(self)(block, new_idx)
+
+    def get_slice(self, slobj: slice, axis: AxisInt=0) -> SingleBlockManager:
+        if axis >= self.ndim:
+            raise IndexError('Requested axis not found in manager')
+        blk = self._block
+        array = blk.values[slobj]
+        bp = BlockPlacement(slice(0, len(array)))
+        block = type(blk)(array, placement=bp, ndim=1, refs=blk.refs)
+        new_index = self.index._getitem_slice(slobj)
+        return type(self)(block, new_index)
+
+    @property
+    def index(self) -> Index:
+        return self.axes[0]
+
+    @property
+    def dtype(self) -> DtypeObj:
+        return self._block.dtype
+
+    def get_dtypes(self) -> npt.NDArray[np.object_]:
+        return np.array([self._block.dtype], dtype=object)
+
+    def external_values(self):
+        return self._block.external_values()
+
+    def internal_values(self):
+        return self._block.values
+
+    def array_values(self) -> ExtensionArray:
+        return self._block.array_values
+
+    def get_numeric_data(self) -> Self:
+        if self._block.is_numeric:
+            return self.copy(deep=False)
+        return self.make_empty()
+
+    @property
+    def _can_hold_na(self) -> bool:
+        return self._block._can_hold_na
+
+    def setitem_inplace(self, indexer, value) -> None:
+        if not self._has_no_reference(0):
+            self.blocks = (self._block.copy(),)
+            self._reset_cache()
+        arr = self.array
+        if isinstance(arr, np.ndarray):
+            value = np_can_hold_element(arr.dtype, value)
+        if isinstance(value, np.ndarray) and value.ndim == 1 and (len(value) == 1):
+            value = value[0, ...]
+        arr[indexer] = value
+
+    def idelete(self, indexer) -> SingleBlockManager:
+        nb = self._block.delete(indexer)[0]
+        self.blocks = (nb,)
+        self.axes[0] = self.axes[0].delete(indexer)
+        self._reset_cache()
+        return self
+
+    def fast_xs(self, loc):
+        raise NotImplementedError('Use series._values[loc] instead')
+
+    def set_values(self, values: ArrayLike) -> None:
+        self.blocks[0].values = values
+        self.blocks[0]._mgr_locs = BlockPlacement(slice(len(values)))
+
+    def _equal_values(self, other: Self) -> bool:
+        if other.ndim != 1:
+            return False
+        left = self.blocks[0].values
+        right = other.blocks[0].values
+        return array_equals(left, right)
+
+    def grouped_reduce(self, func):
+        arr = self.array
+        res = func(arr)
+        index = default_index(len(res))
+        mgr = type(self).from_array(res, index)
+        return mgr
+
+def create_block_manager_from_blocks(blocks: list[Block], axes: list[Index], consolidate: bool=True, verify_integrity: bool=True) -> BlockManager:
+    try:
+        mgr = BlockManager(blocks, axes, verify_integrity=verify_integrity)
+    except ValueError as err:
+        arrays = [blk.values for blk in blocks]
+        tot_items = sum((arr.shape[0] for arr in arrays))
+        raise_construction_error(tot_items, arrays[0].shape[1:], axes, err)
+    if consolidate:
+        mgr._consolidate_inplace()
+    return mgr
+
+def create_block_manager_from_column_arrays(arrays: list[ArrayLike], axes: list[Index], consolidate: bool, refs: list) -> BlockManager:
+    try:
+        blocks = _form_blocks(arrays, consolidate, refs)
+        mgr = BlockManager(blocks, axes, verify_integrity=False)
+    except ValueError as e:
+        raise_construction_error(len(arrays), arrays[0].shape, axes, e)
+    if consolidate:
+        mgr._consolidate_inplace()
+    return mgr
+
+def raise_construction_error(tot_items: int, block_shape: Shape, axes: list[Index], e: ValueError | None=None) -> NoReturn:
+    passed = tuple(map(int, [tot_items] + list(block_shape)))
+    if len(passed) <= 2:
+        passed = passed[::-1]
+    implied = tuple((len(ax) for ax in axes))
+    if len(implied) <= 2:
+        implied = implied[::-1]
+    if passed == implied and e is not None:
+        raise e
+    if block_shape[0] == 0:
+        raise ValueError('Empty data passed with indices specified.')
+    raise ValueError(f'Shape of passed values is {passed}, indices imply {implied}')
+
+def _grouping_func(tup: tuple[int, ArrayLike]) -> tuple[int, DtypeObj]:
+    dtype = tup[1].dtype
+    if is_1d_only_ea_dtype(dtype):
+        sep = id(dtype)
+    else:
+        sep = 0
+    return (sep, dtype)
+
+def _form_blocks(arrays: list[ArrayLike], consolidate: bool, refs: list) -> list[Block]:
+    tuples = enumerate(arrays)
+    if not consolidate:
+        return _tuples_to_blocks_no_consolidate(tuples, refs)
+    grouper = itertools.groupby(tuples, _grouping_func)
+    nbs: list[Block] = []
+    for ((_, dtype), tup_block) in grouper:
+        block_type = get_block_type(dtype)
+        if isinstance(dtype, np.dtype):
+            is_dtlike = dtype.kind in 'mM'
+            if issubclass(dtype.type, (str, bytes)):
+                dtype = np.dtype(object)
+            (values, placement) = _stack_arrays(tup_block, dtype)
+            if is_dtlike:
+                values = ensure_wrapped_if_datetimelike(values)
+            blk = block_type(values, placement=BlockPlacement(placement), ndim=2)
+            nbs.append(blk)
+        elif is_1d_only_ea_dtype(dtype):
+            dtype_blocks = [block_type(x[1], placement=BlockPlacement(x[0]), ndim=2) for x in tup_block]
+            nbs.extend(dtype_blocks)
+        else:
+            dtype_blocks = [block_type(ensure_block_shape(x[1], 2), placement=BlockPlacement(x[0]), ndim=2) for x in tup_block]
+            nbs.extend(dtype_blocks)
+    return nbs
+
+def _tuples_to_blocks_no_consolidate(tuples, refs) -> list[Block]:
+    return [new_block_2d(ensure_block_shape(arr, ndim=2), placement=BlockPlacement(i), refs=ref) for ((i, arr), ref) in zip(tuples, refs)]
+
+def _stack_arrays(tuples, dtype: np.dtype):
+    (placement, arrays) = zip(*tuples)
+    first = arrays[0]
+    shape = (len(arrays),) + first.shape
+    stacked = np.empty(shape, dtype=dtype)
+    for (i, arr) in enumerate(arrays):
+        stacked[i] = arr
+    return (stacked, placement)
+
+def _consolidate(blocks: tuple[Block, ...]) -> tuple[Block, ...]:
+    gkey = lambda x: x._consolidate_key
+    grouper = itertools.groupby(sorted(blocks, key=gkey), gkey)
+    new_blocks: list[Block] = []
+    for ((_can_consolidate, dtype), group_blocks) in grouper:
+        (merged_blocks, _) = _merge_blocks(list(group_blocks), dtype=dtype, can_consolidate=_can_consolidate)
+        new_blocks = extend_blocks(merged_blocks, new_blocks)
+    return tuple(new_blocks)
+
+def _merge_blocks(blocks: list[Block], dtype: DtypeObj, can_consolidate: bool) -> tuple[list[Block], bool]:
+    if len(blocks) == 1:
+        return (blocks, False)
+    if can_consolidate:
+        new_mgr_locs = np.concatenate([b.mgr_locs.as_array for b in blocks])
+        new_values: ArrayLike
+        if isinstance(blocks[0].dtype, np.dtype):
+            new_values = np.vstack([b.values for b in blocks])
+        else:
+            bvals = [blk.values for blk in blocks]
+            bvals2 = cast(Sequence[NDArrayBackedExtensionArray], bvals)
+            new_values = bvals2[0]._concat_same_type(bvals2, axis=0)
+        argsort = np.argsort(new_mgr_locs)
+        new_values = new_values[argsort]
+        new_mgr_locs = new_mgr_locs[argsort]
+        bp = BlockPlacement(new_mgr_locs)
+        return ([new_block_2d(new_values, placement=bp)], True)
+    return (blocks, False)
+
+def _preprocess_slice_or_indexer(slice_or_indexer: slice | np.ndarray, length: int, allow_fill: bool):
+    if isinstance(slice_or_indexer, slice):
+        return ('slice', slice_or_indexer, libinternals.slice_len(slice_or_indexer, length))
+    else:
+        if not isinstance(slice_or_indexer, np.ndarray) or slice_or_indexer.dtype.kind != 'i':
+            dtype = getattr(slice_or_indexer, 'dtype', None)
+            raise TypeError(type(slice_or_indexer), dtype)
+        indexer = ensure_platform_int(slice_or_indexer)
+        if not allow_fill:
+            indexer = maybe_convert_indices(indexer, length)
+        return ('fancy', indexer, len(indexer))
+
+def make_na_array(dtype: DtypeObj, shape: Shape, fill_value) -> ArrayLike:
+    if isinstance(dtype, DatetimeTZDtype):
+        ts = Timestamp(fill_value).as_unit(dtype.unit)
+        i8values = np.full(shape, ts._value)
+        dt64values = i8values.view(f'M8[{dtype.unit}]')
+        return DatetimeArray._simple_new(dt64values, dtype=dtype)
+    elif is_1d_only_ea_dtype(dtype):
+        dtype = cast(ExtensionDtype, dtype)
+        cls = dtype.construct_array_type()
+        missing_arr = cls._from_sequence([], dtype=dtype)
+        (ncols, nrows) = shape
+        assert ncols == 1, ncols
+        empty_arr = -1 * np.ones((nrows,), dtype=np.intp)
+        return missing_arr.take(empty_arr, allow_fill=True, fill_value=fill_value)
+    elif isinstance(dtype, ExtensionDtype):
+        cls = dtype.construct_array_type()
+        missing_arr = cls._empty(shape=shape, dtype=dtype)
+        missing_arr[:] = fill_value
+        return missing_arr
+    else:
+        missing_arr_np = np.empty(shape, dtype=dtype)
+        missing_arr_np.fill(fill_value)
+        if dtype.kind in 'mM':
+            missing_arr_np = ensure_wrapped_if_datetimelike(missing_arr_np)
+        return missing_arr_np
+
+# File: pandas-main/pandas/core/internals/ops.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, NamedTuple
+from pandas.core.dtypes.common import is_1d_only_ea_dtype
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from pandas._libs.internals import BlockPlacement
+    from pandas._typing import ArrayLike
+    from pandas.core.internals.blocks import Block
+    from pandas.core.internals.managers import BlockManager
+
+class BlockPairInfo(NamedTuple):
+    lvals: ArrayLike
+    rvals: ArrayLike
+    locs: BlockPlacement
+    left_ea: bool
+    right_ea: bool
+    rblk: Block
+
+def _iter_block_pairs(left: BlockManager, right: BlockManager) -> Iterator[BlockPairInfo]:
+    for blk in left.blocks:
+        locs = blk.mgr_locs
+        blk_vals = blk.values
+        left_ea = blk_vals.ndim == 1
+        rblks = right._slice_take_blocks_ax0(locs.indexer, only_slice=True)
+        for rblk in rblks:
+            right_ea = rblk.values.ndim == 1
+            (lvals, rvals) = _get_same_shape_values(blk, rblk, left_ea, right_ea)
+            info = BlockPairInfo(lvals, rvals, locs, left_ea, right_ea, rblk)
+            yield info
+
+def operate_blockwise(left: BlockManager, right: BlockManager, array_op) -> BlockManager:
+    res_blks: list[Block] = []
+    for (lvals, rvals, locs, left_ea, right_ea, rblk) in _iter_block_pairs(left, right):
+        res_values = array_op(lvals, rvals)
+        if left_ea and (not right_ea) and hasattr(res_values, 'reshape') and (not is_1d_only_ea_dtype(res_values.dtype)):
+            res_values = res_values.reshape(1, -1)
+        nbs = rblk._split_op_result(res_values)
+        _reset_block_mgr_locs(nbs, locs)
+        res_blks.extend(nbs)
+    new_mgr = type(right)(tuple(res_blks), axes=right.axes, verify_integrity=False)
+    return new_mgr
+
+def _reset_block_mgr_locs(nbs: list[Block], locs) -> None:
+    for nb in nbs:
+        nblocs = locs[nb.mgr_locs.indexer]
+        nb.mgr_locs = nblocs
+
+def _get_same_shape_values(lblk: Block, rblk: Block, left_ea: bool, right_ea: bool) -> tuple[ArrayLike, ArrayLike]:
+    lvals = lblk.values
+    rvals = rblk.values
+    assert rblk.mgr_locs.is_slice_like, rblk.mgr_locs
+    if not (left_ea or right_ea):
+        lvals = lvals[rblk.mgr_locs.indexer, :]
+        assert lvals.shape == rvals.shape, (lvals.shape, rvals.shape)
+    elif left_ea and right_ea:
+        assert lvals.shape == rvals.shape, (lvals.shape, rvals.shape)
+    elif right_ea:
+        lvals = lvals[rblk.mgr_locs.indexer, :]
+        assert lvals.shape[0] == 1, lvals.shape
+        lvals = lvals[0, :]
+    else:
+        assert rvals.shape[0] == 1, rvals.shape
+        rvals = rvals[0, :]
+    return (lvals, rvals)
+
+def blockwise_all(left: BlockManager, right: BlockManager, op) -> bool:
+    for info in _iter_block_pairs(left, right):
+        res = op(info.lvals, info.rvals)
+        if not res:
+            return False
+    return True
+
+# File: pandas-main/pandas/core/methods/describe.py
+""""""
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, cast
+import numpy as np
+from pandas._typing import DtypeObj, NDFrameT, npt
+from pandas.util._validators import validate_percentile
+from pandas.core.dtypes.common import is_bool_dtype, is_numeric_dtype
+from pandas.core.dtypes.dtypes import ArrowDtype, DatetimeTZDtype, ExtensionDtype
+from pandas.core.arrays.floating import Float64Dtype
+from pandas.core.reshape.concat import concat
+from pandas.io.formats.format import format_percentiles
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Sequence
+    from pandas import DataFrame, Series
+
+def describe_ndframe(*, obj: NDFrameT, include: str | Sequence[str] | None, exclude: str | Sequence[str] | None, percentiles: Sequence[float] | np.ndarray | None) -> NDFrameT:
+    percentiles = _refine_percentiles(percentiles)
+    describer: NDFrameDescriberAbstract
+    if obj.ndim == 1:
+        describer = SeriesDescriber(obj=cast('Series', obj))
+    else:
+        describer = DataFrameDescriber(obj=cast('DataFrame', obj), include=include, exclude=exclude)
+    result = describer.describe(percentiles=percentiles)
+    return cast(NDFrameT, result)
+
+class NDFrameDescriberAbstract(ABC):
+
+    def __init__(self, obj: DataFrame | Series) -> None:
+        self.obj = obj
+
+    @abstractmethod
+    def describe(self, percentiles: Sequence[float] | np.ndarray) -> DataFrame | Series:
+
+class SeriesDescriber(NDFrameDescriberAbstract):
+    obj: Series
+
+    def describe(self, percentiles: Sequence[float] | np.ndarray) -> Series:
+        describe_func = select_describe_func(self.obj)
+        return describe_func(self.obj, percentiles)
+
+class DataFrameDescriber(NDFrameDescriberAbstract):
+    obj: DataFrame
+
+    def __init__(self, obj: DataFrame, *, include: str | Sequence[str] | None, exclude: str | Sequence[str] | None) -> None:
+        self.include = include
+        self.exclude = exclude
+        if obj.ndim == 2 and obj.columns.size == 0:
+            raise ValueError('Cannot describe a DataFrame without columns')
+        super().__init__(obj)
+
+    def describe(self, percentiles: Sequence[float] | np.ndarray) -> DataFrame:
+        data = self._select_data()
+        ldesc: list[Series] = []
+        for (_, series) in data.items():
+            describe_func = select_describe_func(series)
+            ldesc.append(describe_func(series, percentiles))
+        col_names = reorder_columns(ldesc)
+        d = concat([x.reindex(col_names) for x in ldesc], axis=1, ignore_index=True, sort=False)
+        d.columns = data.columns.copy()
+        return d
+
+    def _select_data(self) -> DataFrame:
+        if self.include is None and self.exclude is None:
+            default_include: list[npt.DTypeLike] = [np.number, 'datetime']
+            data = self.obj.select_dtypes(include=default_include)
+            if len(data.columns) == 0:
+                data = self.obj
+        elif self.include == 'all':
+            if self.exclude is not None:
+                msg = "exclude must be None when include is 'all'"
+                raise ValueError(msg)
+            data = self.obj
+        else:
+            data = self.obj.select_dtypes(include=self.include, exclude=self.exclude)
+        return data
+
+def reorder_columns(ldesc: Sequence[Series]) -> list[Hashable]:
+    names: list[Hashable] = []
+    seen_names: set[Hashable] = set()
+    ldesc_indexes = sorted((x.index for x in ldesc), key=len)
+    for idxnames in ldesc_indexes:
+        for name in idxnames:
+            if name not in seen_names:
+                seen_names.add(name)
+                names.append(name)
+    return names
+
+def describe_numeric_1d(series: Series, percentiles: Sequence[float]) -> Series:
+    from pandas import Series
+    formatted_percentiles = format_percentiles(percentiles)
+    stat_index = ['count', 'mean', 'std', 'min'] + formatted_percentiles + ['max']
+    d = [series.count(), series.mean(), series.std(), series.min()] + series.quantile(percentiles).tolist() + [series.max()]
+    dtype: DtypeObj | None
+    if isinstance(series.dtype, ExtensionDtype):
+        if isinstance(series.dtype, ArrowDtype):
+            if series.dtype.kind == 'm':
+                dtype = None
+            else:
+                import pyarrow as pa
+                dtype = ArrowDtype(pa.float64())
+        else:
+            dtype = Float64Dtype()
+    elif series.dtype.kind in 'iufb':
+        dtype = np.dtype('float')
+    else:
+        dtype = None
+    return Series(d, index=stat_index, name=series.name, dtype=dtype)
+
+def describe_categorical_1d(data: Series, percentiles_ignored: Sequence[float]) -> Series:
+    names = ['count', 'unique', 'top', 'freq']
+    objcounts = data.value_counts()
+    count_unique = len(objcounts[objcounts != 0])
+    if count_unique > 0:
+        (top, freq) = (objcounts.index[0], objcounts.iloc[0])
+        dtype = None
+    else:
+        (top, freq) = (np.nan, np.nan)
+        dtype = 'object'
+    result = [data.count(), count_unique, top, freq]
+    from pandas import Series
+    return Series(result, index=names, name=data.name, dtype=dtype)
+
+def describe_timestamp_1d(data: Series, percentiles: Sequence[float]) -> Series:
+    from pandas import Series
+    formatted_percentiles = format_percentiles(percentiles)
+    stat_index = ['count', 'mean', 'min'] + formatted_percentiles + ['max']
+    d = [data.count(), data.mean(), data.min()] + data.quantile(percentiles).tolist() + [data.max()]
+    return Series(d, index=stat_index, name=data.name)
+
+def select_describe_func(data: Series) -> Callable:
+    if is_bool_dtype(data.dtype):
+        return describe_categorical_1d
+    elif is_numeric_dtype(data):
+        return describe_numeric_1d
+    elif data.dtype.kind == 'M' or isinstance(data.dtype, DatetimeTZDtype):
+        return describe_timestamp_1d
+    elif data.dtype.kind == 'm':
+        return describe_numeric_1d
+    else:
+        return describe_categorical_1d
+
+def _refine_percentiles(percentiles: Sequence[float] | np.ndarray | None) -> npt.NDArray[np.float64]:
+    if percentiles is None:
+        return np.array([0.25, 0.5, 0.75])
+    percentiles = list(percentiles)
+    validate_percentile(percentiles)
+    if 0.5 not in percentiles:
+        percentiles.append(0.5)
+    percentiles = np.asarray(percentiles)
+    unique_pcts = np.unique(percentiles)
+    assert percentiles is not None
+    if len(unique_pcts) < len(percentiles):
+        raise ValueError('percentiles cannot contain duplicates')
+    return unique_pcts
+
+# File: pandas-main/pandas/core/methods/selectn.py
+""""""
+from __future__ import annotations
+from collections.abc import Hashable, Sequence
+from typing import TYPE_CHECKING, Generic, cast, final
+import numpy as np
+from pandas._libs import algos as libalgos
+from pandas.core.dtypes.common import is_bool_dtype, is_complex_dtype, is_integer_dtype, is_list_like, is_numeric_dtype, needs_i8_conversion
+from pandas.core.dtypes.dtypes import BaseMaskedDtype
+from pandas.core.indexes.api import default_index
+if TYPE_CHECKING:
+    from pandas._typing import DtypeObj, IndexLabel, NDFrameT
+    from pandas import DataFrame, Index, Series
+else:
+    from pandas._typing import T
+    NDFrameT = T
+    DataFrame = T
+    Series = T
+
+class SelectN(Generic[NDFrameT]):
+
+    def __init__(self, obj: NDFrameT, n: int, keep: str) -> None:
+        self.obj = obj
+        self.n = n
+        self.keep = keep
+        if self.keep not in ('first', 'last', 'all'):
+            raise ValueError('keep must be either "first", "last" or "all"')
+
+    def compute(self, method: str) -> NDFrameT:
+        raise NotImplementedError
+
+    @final
+    def nlargest(self) -> NDFrameT:
+        return self.compute('nlargest')
+
+    @final
+    def nsmallest(self) -> NDFrameT:
+        return self.compute('nsmallest')
+
+    @final
+    @staticmethod
+    def is_valid_dtype_n_method(dtype: DtypeObj) -> bool:
+        if is_numeric_dtype(dtype):
+            return not is_complex_dtype(dtype)
+        return needs_i8_conversion(dtype)
+
+class SelectNSeries(SelectN[Series]):
+
+    def compute(self, method: str) -> Series:
+        from pandas.core.reshape.concat import concat
+        n = self.n
+        dtype = self.obj.dtype
+        if not self.is_valid_dtype_n_method(dtype):
+            raise TypeError(f"Cannot use method '{method}' with dtype {dtype}")
+        if n <= 0:
+            return self.obj[[]]
+        dropped = self.obj.dropna()
+        nan_index = self.obj.drop(dropped.index)
+        if n >= len(self.obj):
+            ascending = method == 'nsmallest'
+            return self.obj.sort_values(ascending=ascending).head(n)
+        new_dtype = dropped.dtype
+        arr = dropped._values
+        if needs_i8_conversion(arr.dtype):
+            arr = arr.view('i8')
+        elif isinstance(arr.dtype, BaseMaskedDtype):
+            arr = arr._data
+        else:
+            arr = np.asarray(arr)
+        if arr.dtype.kind == 'b':
+            arr = arr.view(np.uint8)
+        if method == 'nlargest':
+            arr = -arr
+            if is_integer_dtype(new_dtype):
+                arr -= 1
+            elif is_bool_dtype(new_dtype):
+                arr = 1 - -arr
+        if self.keep == 'last':
+            arr = arr[::-1]
+        nbase = n
+        narr = len(arr)
+        n = min(n, narr)
+        if len(arr) > 0:
+            kth_val = libalgos.kth_smallest(arr.copy(order='C'), n - 1)
+        else:
+            kth_val = np.nan
+        (ns,) = np.nonzero(arr <= kth_val)
+        inds = ns[arr[ns].argsort(kind='mergesort')]
+        if self.keep != 'all':
+            inds = inds[:n]
+            findex = nbase
+        elif len(inds) < nbase <= len(nan_index) + len(inds):
+            findex = len(nan_index) + len(inds)
+        else:
+            findex = len(inds)
+        if self.keep == 'last':
+            inds = narr - 1 - inds
+        return concat([dropped.iloc[inds], nan_index]).iloc[:findex]
+
+class SelectNFrame(SelectN[DataFrame]):
+
+    def __init__(self, obj: DataFrame, n: int, keep: str, columns: IndexLabel) -> None:
+        super().__init__(obj, n, keep)
+        if not is_list_like(columns) or isinstance(columns, tuple):
+            columns = [columns]
+        columns = cast(Sequence[Hashable], columns)
+        columns = list(columns)
+        self.columns = columns
+
+    def compute(self, method: str) -> DataFrame:
+        n = self.n
+        frame = self.obj
+        columns = self.columns
+        for column in columns:
+            dtype = frame[column].dtype
+            if not self.is_valid_dtype_n_method(dtype):
+                raise TypeError(f'Column {column!r} has dtype {dtype}, cannot use method {method!r} with this dtype')
+
+        def get_indexer(current_indexer: Index, other_indexer: Index) -> Index:
+            if method == 'nsmallest':
+                return current_indexer.append(other_indexer)
+            else:
+                return other_indexer.append(current_indexer)
+        original_index = frame.index
+        cur_frame = frame = frame.reset_index(drop=True)
+        cur_n = n
+        indexer: Index = default_index(0)
+        for (i, column) in enumerate(columns):
+            series = cur_frame[column]
+            is_last_column = len(columns) - 1 == i
+            values = getattr(series, method)(cur_n, keep=self.keep if is_last_column else 'all')
+            if is_last_column or len(values) <= cur_n:
+                indexer = get_indexer(indexer, values.index)
+                break
+            border_value = values == values[values.index[-1]]
+            unsafe_values = values[border_value]
+            safe_values = values[~border_value]
+            indexer = get_indexer(indexer, safe_values.index)
+            cur_frame = cur_frame.loc[unsafe_values.index]
+            cur_n = n - len(indexer)
+        frame = frame.take(indexer)
+        frame.index = original_index.take(indexer)
+        if len(columns) == 1:
+            return frame
+        ascending = method == 'nsmallest'
+        return frame.sort_values(columns, ascending=ascending, kind='mergesort')
+
+# File: pandas-main/pandas/core/methods/to_dict.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, Literal, overload
+import warnings
+import numpy as np
+from pandas._libs import lib, missing as libmissing
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.cast import maybe_box_native
+from pandas.core.dtypes.dtypes import BaseMaskedDtype, ExtensionDtype
+from pandas.core import common as com
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from pandas._typing import MutableMappingT
+    from pandas import DataFrame
+
+def create_data_for_split(df: DataFrame, are_all_object_dtype_cols: bool, object_dtype_indices: list[int]) -> Generator[list, None, None]:
+    if are_all_object_dtype_cols:
+        for tup in df.itertuples(index=False, name=None):
+            yield list(map(maybe_box_native, tup))
+    else:
+        for tup in df.itertuples(index=False, name=None):
+            data = list(tup)
+            if object_dtype_indices:
+                for i in object_dtype_indices:
+                    data[i] = maybe_box_native(data[i])
+            yield data
+
+@overload
+def to_dict(df: DataFrame, orient: Literal['dict', 'list', 'series', 'split', 'tight', 'index']=..., *, into: type[MutableMappingT] | MutableMappingT, index: bool=...) -> MutableMappingT:
+    ...
+
+@overload
+def to_dict(df: DataFrame, orient: Literal['records'], *, into: type[MutableMappingT] | MutableMappingT, index: bool=...) -> list[MutableMappingT]:
+    ...
+
+@overload
+def to_dict(df: DataFrame, orient: Literal['dict', 'list', 'series', 'split', 'tight', 'index']=..., *, into: type[dict]=..., index: bool=...) -> dict:
+    ...
+
+@overload
+def to_dict(df: DataFrame, orient: Literal['records'], *, into: type[dict]=..., index: bool=...) -> list[dict]:
+    ...
+
+def to_dict(df: DataFrame, orient: Literal['dict', 'list', 'series', 'split', 'tight', 'records', 'index']='dict', *, into: type[MutableMappingT] | MutableMappingT=dict, index: bool=True) -> MutableMappingT | list[MutableMappingT]:
+    if orient != 'tight' and (not df.columns.is_unique):
+        warnings.warn('DataFrame columns are not unique, some columns will be omitted.', UserWarning, stacklevel=find_stack_level())
+    into_c = com.standardize_mapping(into)
+    orient = orient.lower()
+    if not index and orient not in ['split', 'tight']:
+        raise ValueError("'index=False' is only valid when 'orient' is 'split' or 'tight'")
+    if orient == 'series':
+        return into_c(((k, v) for (k, v) in df.items()))
+    if orient == 'dict':
+        return into_c(((k, v.to_dict(into=into)) for (k, v) in df.items()))
+    box_native_indices = [i for (i, col_dtype) in enumerate(df.dtypes.values) if col_dtype == np.dtype(object) or isinstance(col_dtype, ExtensionDtype)]
+    are_all_object_dtype_cols = len(box_native_indices) == len(df.dtypes)
+    if orient == 'list':
+        object_dtype_indices_as_set: set[int] = set(box_native_indices)
+        box_na_values = (lib.no_default if not isinstance(col_dtype, BaseMaskedDtype) else libmissing.NA for col_dtype in df.dtypes.values)
+        return into_c(((k, list(map(maybe_box_native, v.to_numpy(na_value=box_na_value))) if i in object_dtype_indices_as_set else list(map(maybe_box_native, v.to_numpy()))) for (i, (box_na_value, (k, v))) in enumerate(zip(box_na_values, df.items()))))
+    elif orient == 'split':
+        data = list(create_data_for_split(df, are_all_object_dtype_cols, box_native_indices))
+        return into_c(((('index', df.index.tolist()),) if index else ()) + (('columns', df.columns.tolist()), ('data', data)))
+    elif orient == 'tight':
+        return into_c(((('index', df.index.tolist()),) if index else ()) + (('columns', df.columns.tolist()), ('data', [list(map(maybe_box_native, t)) for t in df.itertuples(index=False, name=None)])) + ((('index_names', list(df.index.names)),) if index else ()) + (('column_names', list(df.columns.names)),))
+    elif orient == 'records':
+        columns = df.columns.tolist()
+        if are_all_object_dtype_cols:
+            return [into_c(zip(columns, map(maybe_box_native, row))) for row in df.itertuples(index=False, name=None)]
+        else:
+            data = [into_c(zip(columns, t)) for t in df.itertuples(index=False, name=None)]
+            if box_native_indices:
+                object_dtype_indices_as_set = set(box_native_indices)
+                object_dtype_cols = {col for (i, col) in enumerate(df.columns) if i in object_dtype_indices_as_set}
+                for row in data:
+                    for col in object_dtype_cols:
+                        row[col] = maybe_box_native(row[col])
+            return data
+    elif orient == 'index':
+        if not df.index.is_unique:
+            raise ValueError("DataFrame index must be unique for orient='index'.")
+        columns = df.columns.tolist()
+        if are_all_object_dtype_cols:
+            return into_c(((t[0], dict(zip(df.columns, map(maybe_box_native, t[1:])))) for t in df.itertuples(name=None)))
+        elif box_native_indices:
+            object_dtype_indices_as_set = set(box_native_indices)
+            return into_c(((t[0], {column: maybe_box_native(v) if i in object_dtype_indices_as_set else v for (i, (column, v)) in enumerate(zip(columns, t[1:]))}) for t in df.itertuples(name=None)))
+        else:
+            return into_c(((t[0], dict(zip(columns, t[1:]))) for t in df.itertuples(name=None)))
+    else:
+        raise ValueError(f"orient '{orient}' not understood")
+
+# File: pandas-main/pandas/core/missing.py
+""""""
+from __future__ import annotations
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
+import numpy as np
+from pandas._libs import NaT, algos, lib
+from pandas._typing import ArrayLike, AxisInt, F, ReindexMethod, npt
+from pandas.compat._optional import import_optional_dependency
+from pandas.core.dtypes.cast import infer_dtype_from
+from pandas.core.dtypes.common import is_array_like, is_bool_dtype, is_numeric_dtype, is_numeric_v_string_like, is_object_dtype, needs_i8_conversion
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+from pandas.core.dtypes.missing import is_valid_na_for_dtype, isna, na_value_for_dtype
+if TYPE_CHECKING:
+    from pandas import Index
+
+def check_value_size(value, mask: npt.NDArray[np.bool_], length: int):
+    if is_array_like(value):
+        if len(value) != length:
+            raise ValueError(f"Length of 'value' does not match. Got ({len(value)})  expected {length}")
+        value = value[mask]
+    return value
+
+def mask_missing(arr: ArrayLike, values_to_mask) -> npt.NDArray[np.bool_]:
+    (dtype, values_to_mask) = infer_dtype_from(values_to_mask)
+    if isinstance(dtype, np.dtype):
+        values_to_mask = np.array(values_to_mask, dtype=dtype)
+    else:
+        cls = dtype.construct_array_type()
+        if not lib.is_list_like(values_to_mask):
+            values_to_mask = [values_to_mask]
+        values_to_mask = cls._from_sequence(values_to_mask, dtype=dtype, copy=False)
+    potential_na = False
+    if is_object_dtype(arr.dtype):
+        potential_na = True
+        arr_mask = ~isna(arr)
+    na_mask = isna(values_to_mask)
+    nonna = values_to_mask[~na_mask]
+    mask = np.zeros(arr.shape, dtype=bool)
+    if is_numeric_dtype(arr.dtype) and (not is_bool_dtype(arr.dtype)) and is_bool_dtype(nonna.dtype):
+        pass
+    elif is_bool_dtype(arr.dtype) and is_numeric_dtype(nonna.dtype) and (not is_bool_dtype(nonna.dtype)):
+        pass
+    else:
+        for x in nonna:
+            if is_numeric_v_string_like(arr, x):
+                pass
+            else:
+                if potential_na:
+                    new_mask = np.zeros(arr.shape, dtype=np.bool_)
+                    new_mask[arr_mask] = arr[arr_mask] == x
+                else:
+                    new_mask = arr == x
+                    if not isinstance(new_mask, np.ndarray):
+                        new_mask = new_mask.to_numpy(dtype=bool, na_value=False)
+                mask |= new_mask
+    if na_mask.any():
+        mask |= isna(arr)
+    return mask
+
+@overload
+def clean_fill_method(method: Literal['ffill', 'pad', 'bfill', 'backfill'], *, allow_nearest: Literal[False]=...) -> Literal['pad', 'backfill']:
+    ...
+
+@overload
+def clean_fill_method(method: Literal['ffill', 'pad', 'bfill', 'backfill', 'nearest'], *, allow_nearest: Literal[True]) -> Literal['pad', 'backfill', 'nearest']:
+    ...
+
+def clean_fill_method(method: Literal['ffill', 'pad', 'bfill', 'backfill', 'nearest'], *, allow_nearest: bool=False) -> Literal['pad', 'backfill', 'nearest']:
+    if isinstance(method, str):
+        method = method.lower()
+        if method == 'ffill':
+            method = 'pad'
+        elif method == 'bfill':
+            method = 'backfill'
+    valid_methods = ['pad', 'backfill']
+    expecting = 'pad (ffill) or backfill (bfill)'
+    if allow_nearest:
+        valid_methods.append('nearest')
+        expecting = 'pad (ffill), backfill (bfill) or nearest'
+    if method not in valid_methods:
+        raise ValueError(f'Invalid fill method. Expecting {expecting}. Got {method}')
+    return method
+NP_METHODS = ['linear', 'time', 'index', 'values']
+SP_METHODS = ['nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'barycentric', 'krogh', 'spline', 'polynomial', 'from_derivatives', 'piecewise_polynomial', 'pchip', 'akima', 'cubicspline']
+
+def clean_interp_method(method: str, index: Index, **kwargs) -> str:
+    order = kwargs.get('order')
+    if method in ('spline', 'polynomial') and order is None:
+        raise ValueError('You must specify the order of the spline or polynomial.')
+    valid = NP_METHODS + SP_METHODS
+    if method not in valid:
+        raise ValueError(f"method must be one of {valid}. Got '{method}' instead.")
+    if method in ('krogh', 'piecewise_polynomial', 'pchip'):
+        if not index.is_monotonic_increasing:
+            raise ValueError(f'{method} interpolation requires that the index be monotonic.')
+    return method
+
+def find_valid_index(how: str, is_valid: npt.NDArray[np.bool_]) -> int | None:
+    assert how in ['first', 'last']
+    if len(is_valid) == 0:
+        return None
+    if is_valid.ndim == 2:
+        is_valid = is_valid.any(axis=1)
+    if how == 'first':
+        idxpos = is_valid[:].argmax()
+    elif how == 'last':
+        idxpos = len(is_valid) - 1 - is_valid[::-1].argmax()
+    chk_notna = is_valid[idxpos]
+    if not chk_notna:
+        return None
+    return idxpos
+
+def validate_limit_direction(limit_direction: str) -> Literal['forward', 'backward', 'both']:
+    valid_limit_directions = ['forward', 'backward', 'both']
+    limit_direction = limit_direction.lower()
+    if limit_direction not in valid_limit_directions:
+        raise ValueError(f"Invalid limit_direction: expecting one of {valid_limit_directions}, got '{limit_direction}'.")
+    return limit_direction
+
+def validate_limit_area(limit_area: str | None) -> Literal['inside', 'outside'] | None:
+    if limit_area is not None:
+        valid_limit_areas = ['inside', 'outside']
+        limit_area = limit_area.lower()
+        if limit_area not in valid_limit_areas:
+            raise ValueError(f'Invalid limit_area: expecting one of {valid_limit_areas}, got {limit_area}.')
+    return limit_area
+
+def infer_limit_direction(limit_direction: Literal['backward', 'forward', 'both'] | None, method: str) -> Literal['backward', 'forward', 'both']:
+    if limit_direction is None:
+        if method in ('backfill', 'bfill'):
+            limit_direction = 'backward'
+        else:
+            limit_direction = 'forward'
+    else:
+        if method in ('pad', 'ffill') and limit_direction != 'forward':
+            raise ValueError(f"`limit_direction` must be 'forward' for method `{method}`")
+        if method in ('backfill', 'bfill') and limit_direction != 'backward':
+            raise ValueError(f"`limit_direction` must be 'backward' for method `{method}`")
+    return limit_direction
+
+def get_interp_index(method, index: Index) -> Index:
+    if method == 'linear':
+        from pandas import Index
+        if isinstance(index.dtype, DatetimeTZDtype) or lib.is_np_dtype(index.dtype, 'mM'):
+            index = Index(index.view('i8'))
+        elif not is_numeric_dtype(index.dtype):
+            index = Index(range(len(index)))
+    else:
+        methods = {'index', 'values', 'nearest', 'time'}
+        is_numeric_or_datetime = is_numeric_dtype(index.dtype) or isinstance(index.dtype, DatetimeTZDtype) or lib.is_np_dtype(index.dtype, 'mM')
+        valid = NP_METHODS + SP_METHODS
+        if method in valid:
+            if method not in methods and (not is_numeric_or_datetime):
+                raise ValueError(f'Index column must be numeric or datetime type when using {method} method other than linear. Try setting a numeric or datetime index column before interpolating.')
+        else:
+            raise ValueError(f'Can not interpolate with method={method}.')
+    if isna(index).any():
+        raise NotImplementedError('Interpolation with NaNs in the index has not been implemented. Try filling those NaNs before interpolating.')
+    return index
+
+def interpolate_2d_inplace(data: np.ndarray, index: Index, axis: AxisInt, method: str='linear', limit: int | None=None, limit_direction: str='forward', limit_area: str | None=None, fill_value: Any | None=None, mask=None, **kwargs) -> None:
+    clean_interp_method(method, index, **kwargs)
+    if is_valid_na_for_dtype(fill_value, data.dtype):
+        fill_value = na_value_for_dtype(data.dtype, compat=False)
+    if method == 'time':
+        if not needs_i8_conversion(index.dtype):
+            raise ValueError('time-weighted interpolation only works on Series or DataFrames with a DatetimeIndex')
+        method = 'values'
+    limit_direction = validate_limit_direction(limit_direction)
+    limit_area_validated = validate_limit_area(limit_area)
+    limit = algos.validate_limit(nobs=None, limit=limit)
+    indices = _index_to_interp_indices(index, method)
+
+    def func(yvalues: np.ndarray) -> None:
+        _interpolate_1d(indices=indices, yvalues=yvalues, method=method, limit=limit, limit_direction=limit_direction, limit_area=limit_area_validated, fill_value=fill_value, bounds_error=False, mask=mask, **kwargs)
+    np.apply_along_axis(func, axis, data)
+
+def _index_to_interp_indices(index: Index, method: str) -> np.ndarray:
+    xarr = index._values
+    if needs_i8_conversion(xarr.dtype):
+        xarr = xarr.view('i8')
+    if method == 'linear':
+        inds = xarr
+        inds = cast(np.ndarray, inds)
+    else:
+        inds = np.asarray(xarr)
+        if method in ('values', 'index'):
+            if inds.dtype == np.object_:
+                inds = lib.maybe_convert_objects(inds)
+    return inds
+
+def _interpolate_1d(indices: np.ndarray, yvalues: np.ndarray, method: str='linear', limit: int | None=None, limit_direction: str='forward', limit_area: Literal['inside', 'outside'] | None=None, fill_value: Any | None=None, bounds_error: bool=False, order: int | None=None, mask=None, **kwargs) -> None:
+    if mask is not None:
+        invalid = mask
+    else:
+        invalid = isna(yvalues)
+    valid = ~invalid
+    if not valid.any():
+        return
+    if valid.all():
+        return
+    all_nans = np.flatnonzero(invalid)
+    first_valid_index = find_valid_index(how='first', is_valid=valid)
+    if first_valid_index is None:
+        first_valid_index = 0
+    start_nans = np.arange(first_valid_index)
+    last_valid_index = find_valid_index(how='last', is_valid=valid)
+    if last_valid_index is None:
+        last_valid_index = len(yvalues)
+    end_nans = np.arange(1 + last_valid_index, len(valid))
+    if limit_direction == 'forward':
+        preserve_nans = np.union1d(start_nans, _interp_limit(invalid, limit, 0))
+    elif limit_direction == 'backward':
+        preserve_nans = np.union1d(end_nans, _interp_limit(invalid, 0, limit))
+    else:
+        preserve_nans = np.unique(_interp_limit(invalid, limit, limit))
+    if limit_area == 'inside':
+        preserve_nans = np.union1d(preserve_nans, start_nans)
+        preserve_nans = np.union1d(preserve_nans, end_nans)
+    elif limit_area == 'outside':
+        mid_nans = np.setdiff1d(all_nans, start_nans, assume_unique=True)
+        mid_nans = np.setdiff1d(mid_nans, end_nans, assume_unique=True)
+        preserve_nans = np.union1d(preserve_nans, mid_nans)
+    is_datetimelike = yvalues.dtype.kind in 'mM'
+    if is_datetimelike:
+        yvalues = yvalues.view('i8')
+    if method in NP_METHODS:
+        indexer = np.argsort(indices[valid])
+        yvalues[invalid] = np.interp(indices[invalid], indices[valid][indexer], yvalues[valid][indexer])
+    else:
+        yvalues[invalid] = _interpolate_scipy_wrapper(indices[valid], yvalues[valid], indices[invalid], method=method, fill_value=fill_value, bounds_error=bounds_error, order=order, **kwargs)
+    if mask is not None:
+        mask[:] = False
+        mask[preserve_nans] = True
+    elif is_datetimelike:
+        yvalues[preserve_nans] = NaT.value
+    else:
+        yvalues[preserve_nans] = np.nan
+    return
+
+def _interpolate_scipy_wrapper(x: np.ndarray, y: np.ndarray, new_x: np.ndarray, method: str, fill_value=None, bounds_error: bool=False, order=None, **kwargs):
+    extra = f'{method} interpolation requires SciPy.'
+    import_optional_dependency('scipy', extra=extra)
+    from scipy import interpolate
+    new_x = np.asarray(new_x)
+    alt_methods = {'barycentric': interpolate.barycentric_interpolate, 'krogh': interpolate.krogh_interpolate, 'from_derivatives': _from_derivatives, 'piecewise_polynomial': _from_derivatives, 'cubicspline': _cubicspline_interpolate, 'akima': _akima_interpolate, 'pchip': interpolate.pchip_interpolate}
+    interp1d_methods = ['nearest', 'zero', 'slinear', 'quadratic', 'cubic', 'polynomial']
+    if method in interp1d_methods:
+        if method == 'polynomial':
+            kind = order
+        else:
+            kind = method
+        terp = interpolate.interp1d(x, y, kind=kind, fill_value=fill_value, bounds_error=bounds_error)
+        new_y = terp(new_x)
+    elif method == 'spline':
+        if isna(order) or order <= 0:
+            raise ValueError(f'order needs to be specified and greater than 0; got order: {order}')
+        terp = interpolate.UnivariateSpline(x, y, k=order, **kwargs)
+        new_y = terp(new_x)
+    else:
+        if not x.flags.writeable:
+            x = x.copy()
+        if not y.flags.writeable:
+            y = y.copy()
+        if not new_x.flags.writeable:
+            new_x = new_x.copy()
+        terp = alt_methods.get(method, None)
+        if terp is None:
+            raise ValueError(f'Can not interpolate with method={method}.')
+        kwargs.pop('downcast', None)
+        new_y = terp(x, y, new_x, **kwargs)
+    return new_y
+
+def _from_derivatives(xi: np.ndarray, yi: np.ndarray, x: np.ndarray, order=None, der: int | list[int] | None=0, extrapolate: bool=False):
+    from scipy import interpolate
+    method = interpolate.BPoly.from_derivatives
+    m = method(xi, yi.reshape(-1, 1), orders=order, extrapolate=extrapolate)
+    return m(x)
+
+def _akima_interpolate(xi: np.ndarray, yi: np.ndarray, x: np.ndarray, der: int | list[int] | None=0, axis: AxisInt=0):
+    from scipy import interpolate
+    P = interpolate.Akima1DInterpolator(xi, yi, axis=axis)
+    return P(x, nu=der)
+
+def _cubicspline_interpolate(xi: np.ndarray, yi: np.ndarray, x: np.ndarray, axis: AxisInt=0, bc_type: str | tuple[Any, Any]='not-a-knot', extrapolate=None):
+    from scipy import interpolate
+    P = interpolate.CubicSpline(xi, yi, axis=axis, bc_type=bc_type, extrapolate=extrapolate)
+    return P(x)
+
+def pad_or_backfill_inplace(values: np.ndarray, method: Literal['pad', 'backfill']='pad', axis: AxisInt=0, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None) -> None:
+    transf = (lambda x: x) if axis == 0 else lambda x: x.T
+    if values.ndim == 1:
+        if axis != 0:
+            raise AssertionError('cannot interpolate on a ndim == 1 with axis != 0')
+        values = values.reshape(tuple((1,) + values.shape))
+    method = clean_fill_method(method)
+    tvalues = transf(values)
+    func = get_fill_func(method, ndim=2)
+    func(tvalues, limit=limit, limit_area=limit_area)
+
+def _fillna_prep(values, mask: npt.NDArray[np.bool_] | None=None) -> npt.NDArray[np.bool_]:
+    if mask is None:
+        mask = isna(values)
+    return mask
+
+def _datetimelike_compat(func: F) -> F:
+
+    @wraps(func)
+    def new_func(values, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None, mask=None):
+        if needs_i8_conversion(values.dtype):
+            if mask is None:
+                mask = isna(values)
+            (result, mask) = func(values.view('i8'), limit=limit, limit_area=limit_area, mask=mask)
+            return (result.view(values.dtype), mask)
+        return func(values, limit=limit, limit_area=limit_area, mask=mask)
+    return cast(F, new_func)
+
+@_datetimelike_compat
+def _pad_1d(values: np.ndarray, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None, mask: npt.NDArray[np.bool_] | None=None) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
+    mask = _fillna_prep(values, mask)
+    if limit_area is not None and (not mask.all()):
+        _fill_limit_area_1d(mask, limit_area)
+    algos.pad_inplace(values, mask, limit=limit)
+    return (values, mask)
+
+@_datetimelike_compat
+def _backfill_1d(values: np.ndarray, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None, mask: npt.NDArray[np.bool_] | None=None) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
+    mask = _fillna_prep(values, mask)
+    if limit_area is not None and (not mask.all()):
+        _fill_limit_area_1d(mask, limit_area)
+    algos.backfill_inplace(values, mask, limit=limit)
+    return (values, mask)
+
+@_datetimelike_compat
+def _pad_2d(values: np.ndarray, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None, mask: npt.NDArray[np.bool_] | None=None) -> tuple[np.ndarray, npt.NDArray[np.bool_]]:
+    mask = _fillna_prep(values, mask)
+    if limit_area is not None:
+        _fill_limit_area_2d(mask, limit_area)
+    if values.size:
+        algos.pad_2d_inplace(values, mask, limit=limit)
+    return (values, mask)
+
+@_datetimelike_compat
+def _backfill_2d(values, limit: int | None=None, limit_area: Literal['inside', 'outside'] | None=None, mask: npt.NDArray[np.bool_] | None=None):
+    mask = _fillna_prep(values, mask)
+    if limit_area is not None:
+        _fill_limit_area_2d(mask, limit_area)
+    if values.size:
+        algos.backfill_2d_inplace(values, mask, limit=limit)
+    else:
+        pass
+    return (values, mask)
+
+def _fill_limit_area_1d(mask: npt.NDArray[np.bool_], limit_area: Literal['outside', 'inside']) -> None:
+    neg_mask = ~mask
+    first = neg_mask.argmax()
+    last = len(neg_mask) - neg_mask[::-1].argmax() - 1
+    if limit_area == 'inside':
+        mask[:first] = False
+        mask[last + 1:] = False
+    elif limit_area == 'outside':
+        mask[first + 1:last] = False
+
+def _fill_limit_area_2d(mask: npt.NDArray[np.bool_], limit_area: Literal['outside', 'inside']) -> None:
+    neg_mask = ~mask.T
+    if limit_area == 'outside':
+        la_mask = np.maximum.accumulate(neg_mask, axis=0) & np.maximum.accumulate(neg_mask[::-1], axis=0)[::-1]
+    else:
+        la_mask = ~np.maximum.accumulate(neg_mask, axis=0) | ~np.maximum.accumulate(neg_mask[::-1], axis=0)[::-1]
+    mask[la_mask.T] = False
+_fill_methods = {'pad': _pad_1d, 'backfill': _backfill_1d}
+
+def get_fill_func(method, ndim: int=1):
+    method = clean_fill_method(method)
+    if ndim == 1:
+        return _fill_methods[method]
+    return {'pad': _pad_2d, 'backfill': _backfill_2d}[method]
+
+def clean_reindex_fill_method(method) -> ReindexMethod | None:
+    if method is None:
+        return None
+    return clean_fill_method(method, allow_nearest=True)
+
+def _interp_limit(invalid: npt.NDArray[np.bool_], fw_limit: int | None, bw_limit: int | None) -> np.ndarray:
+    N = len(invalid)
+    f_idx = np.array([], dtype=np.int64)
+    b_idx = np.array([], dtype=np.int64)
+    assume_unique = True
+
+    def inner(invalid, limit: int):
+        limit = min(limit, N)
+        windowed = np.lib.stride_tricks.sliding_window_view(invalid, limit + 1).all(1)
+        idx = np.union1d(np.where(windowed)[0] + limit, np.where((~invalid[:limit + 1]).cumsum() == 0)[0])
+        return idx
+    if fw_limit is not None:
+        if fw_limit == 0:
+            f_idx = np.where(invalid)[0]
+            assume_unique = False
+        else:
+            f_idx = inner(invalid, fw_limit)
+    if bw_limit is not None:
+        if bw_limit == 0:
+            return f_idx
+        else:
+            b_idx = N - 1 - inner(invalid[::-1], bw_limit)
+            if fw_limit == 0:
+                return b_idx
+    return np.intersect1d(f_idx, b_idx, assume_unique=assume_unique)
+
+# File: pandas-main/pandas/core/nanops.py
+from __future__ import annotations
+import functools
+import itertools
+from typing import TYPE_CHECKING, Any, cast
+import warnings
+import numpy as np
+from pandas._config import get_option
+from pandas._libs import NaT, NaTType, iNaT, lib
+from pandas._typing import ArrayLike, AxisInt, CorrelationMethod, Dtype, DtypeObj, F, Scalar, Shape, npt
+from pandas.compat._optional import import_optional_dependency
+from pandas.core.dtypes.common import is_complex, is_float, is_float_dtype, is_integer, is_numeric_dtype, is_object_dtype, needs_i8_conversion, pandas_dtype
+from pandas.core.dtypes.missing import isna, na_value_for_dtype, notna
+if TYPE_CHECKING:
+    from collections.abc import Callable
+bn = import_optional_dependency('bottleneck', errors='warn')
+_BOTTLENECK_INSTALLED = bn is not None
+_USE_BOTTLENECK = False
+
+def set_use_bottleneck(v: bool=True) -> None:
+    global _USE_BOTTLENECK
+    if _BOTTLENECK_INSTALLED:
+        _USE_BOTTLENECK = v
+set_use_bottleneck(get_option('compute.use_bottleneck'))
+
+class disallow:
+
+    def __init__(self, *dtypes: Dtype) -> None:
+        super().__init__()
+        self.dtypes = tuple((pandas_dtype(dtype).type for dtype in dtypes))
+
+    def check(self, obj) -> bool:
+        return hasattr(obj, 'dtype') and issubclass(obj.dtype.type, self.dtypes)
+
+    def __call__(self, f: F) -> F:
+
+        @functools.wraps(f)
+        def _f(*args, **kwargs):
+            obj_iter = itertools.chain(args, kwargs.values())
+            if any((self.check(obj) for obj in obj_iter)):
+                f_name = f.__name__.replace('nan', '')
+                raise TypeError(f"reduction operation '{f_name}' not allowed for this dtype")
+            try:
+                return f(*args, **kwargs)
+            except ValueError as e:
+                if is_object_dtype(args[0]):
+                    raise TypeError(e) from e
+                raise
+        return cast(F, _f)
+
+class bottleneck_switch:
+
+    def __init__(self, name=None, **kwargs) -> None:
+        self.name = name
+        self.kwargs = kwargs
+
+    def __call__(self, alt: F) -> F:
+        bn_name = self.name or alt.__name__
+        try:
+            bn_func = getattr(bn, bn_name)
+        except (AttributeError, NameError):
+            bn_func = None
+
+        @functools.wraps(alt)
+        def f(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, **kwds):
+            if len(self.kwargs) > 0:
+                for (k, v) in self.kwargs.items():
+                    if k not in kwds:
+                        kwds[k] = v
+            if values.size == 0 and kwds.get('min_count') is None:
+                return _na_for_min_count(values, axis)
+            if _USE_BOTTLENECK and skipna and _bn_ok_dtype(values.dtype, bn_name):
+                if kwds.get('mask', None) is None:
+                    kwds.pop('mask', None)
+                    result = bn_func(values, axis=axis, **kwds)
+                    if _has_infs(result):
+                        result = alt(values, axis=axis, skipna=skipna, **kwds)
+                else:
+                    result = alt(values, axis=axis, skipna=skipna, **kwds)
+            else:
+                result = alt(values, axis=axis, skipna=skipna, **kwds)
+            return result
+        return cast(F, f)
+
+def _bn_ok_dtype(dtype: DtypeObj, name: str) -> bool:
+    if dtype != object and (not needs_i8_conversion(dtype)):
+        return name not in ['nansum', 'nanprod', 'nanmean']
+    return False
+
+def _has_infs(result) -> bool:
+    if isinstance(result, np.ndarray):
+        if result.dtype in ('f8', 'f4'):
+            return lib.has_infs(result.ravel('K'))
+    try:
+        return np.isinf(result).any()
+    except (TypeError, NotImplementedError):
+        return False
+
+def _get_fill_value(dtype: DtypeObj, fill_value: Scalar | None=None, fill_value_typ=None):
+    if fill_value is not None:
+        return fill_value
+    if _na_ok_dtype(dtype):
+        if fill_value_typ is None:
+            return np.nan
+        elif fill_value_typ == '+inf':
+            return np.inf
+        else:
+            return -np.inf
+    elif fill_value_typ == '+inf':
+        return lib.i8max
+    else:
+        return iNaT
+
+def _maybe_get_mask(values: np.ndarray, skipna: bool, mask: npt.NDArray[np.bool_] | None) -> npt.NDArray[np.bool_] | None:
+    if mask is None:
+        if values.dtype.kind in 'biu':
+            return None
+        if skipna or values.dtype.kind in 'mM':
+            mask = isna(values)
+    return mask
+
+def _get_values(values: np.ndarray, skipna: bool, fill_value: Any=None, fill_value_typ: str | None=None, mask: npt.NDArray[np.bool_] | None=None) -> tuple[np.ndarray, npt.NDArray[np.bool_] | None]:
+    mask = _maybe_get_mask(values, skipna, mask)
+    dtype = values.dtype
+    datetimelike = False
+    if values.dtype.kind in 'mM':
+        values = np.asarray(values.view('i8'))
+        datetimelike = True
+    if skipna and mask is not None:
+        fill_value = _get_fill_value(dtype, fill_value=fill_value, fill_value_typ=fill_value_typ)
+        if fill_value is not None:
+            if mask.any():
+                if datetimelike or _na_ok_dtype(dtype):
+                    values = values.copy()
+                    np.putmask(values, mask, fill_value)
+                else:
+                    values = np.where(~mask, values, fill_value)
+    return (values, mask)
+
+def _get_dtype_max(dtype: np.dtype) -> np.dtype:
+    dtype_max = dtype
+    if dtype.kind in 'bi':
+        dtype_max = np.dtype(np.int64)
+    elif dtype.kind == 'u':
+        dtype_max = np.dtype(np.uint64)
+    elif dtype.kind == 'f':
+        dtype_max = np.dtype(np.float64)
+    return dtype_max
+
+def _na_ok_dtype(dtype: DtypeObj) -> bool:
+    if needs_i8_conversion(dtype):
+        return False
+    return not issubclass(dtype.type, np.integer)
+
+def _wrap_results(result, dtype: np.dtype, fill_value=None):
+    if result is NaT:
+        pass
+    elif dtype.kind == 'M':
+        if fill_value is None:
+            fill_value = iNaT
+        if not isinstance(result, np.ndarray):
+            assert not isna(fill_value), 'Expected non-null fill_value'
+            if result == fill_value:
+                result = np.nan
+            if isna(result):
+                result = np.datetime64('NaT', 'ns').astype(dtype)
+            else:
+                result = np.int64(result).view(dtype)
+            result = result.astype(dtype, copy=False)
+        else:
+            result = result.astype(dtype)
+    elif dtype.kind == 'm':
+        if not isinstance(result, np.ndarray):
+            if result == fill_value or np.isnan(result):
+                result = np.timedelta64('NaT').astype(dtype)
+            elif np.fabs(result) > lib.i8max:
+                raise ValueError('overflow in timedelta operation')
+            else:
+                result = np.int64(result).astype(dtype, copy=False)
+        else:
+            result = result.astype('m8[ns]').view(dtype)
+    return result
+
+def _datetimelike_compat(func: F) -> F:
+
+    @functools.wraps(func)
+    def new_func(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, mask: npt.NDArray[np.bool_] | None=None, **kwargs):
+        orig_values = values
+        datetimelike = values.dtype.kind in 'mM'
+        if datetimelike and mask is None:
+            mask = isna(values)
+        result = func(values, axis=axis, skipna=skipna, mask=mask, **kwargs)
+        if datetimelike:
+            result = _wrap_results(result, orig_values.dtype, fill_value=iNaT)
+            if not skipna:
+                assert mask is not None
+                result = _mask_datetimelike_result(result, axis, mask, orig_values)
+        return result
+    return cast(F, new_func)
+
+def _na_for_min_count(values: np.ndarray, axis: AxisInt | None) -> Scalar | np.ndarray:
+    if values.dtype.kind in 'iufcb':
+        values = values.astype('float64')
+    fill_value = na_value_for_dtype(values.dtype)
+    if values.ndim == 1:
+        return fill_value
+    elif axis is None:
+        return fill_value
+    else:
+        result_shape = values.shape[:axis] + values.shape[axis + 1:]
+        return np.full(result_shape, fill_value, dtype=values.dtype)
+
+def maybe_operate_rowwise(func: F) -> F:
+
+    @functools.wraps(func)
+    def newfunc(values: np.ndarray, *, axis: AxisInt | None=None, **kwargs):
+        if axis == 1 and values.ndim == 2 and values.flags['C_CONTIGUOUS'] and (values.shape[1] / 1000 > values.shape[0]) and (values.dtype != object) and (values.dtype != bool):
+            arrs = list(values)
+            if kwargs.get('mask') is not None:
+                mask = kwargs.pop('mask')
+                results = [func(arrs[i], mask=mask[i], **kwargs) for i in range(len(arrs))]
+            else:
+                results = [func(x, **kwargs) for x in arrs]
+            return np.array(results)
+        return func(values, axis=axis, **kwargs)
+    return cast(F, newfunc)
+
+def nanany(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, mask: npt.NDArray[np.bool_] | None=None) -> bool:
+    if values.dtype.kind in 'iub' and mask is None:
+        return values.any(axis)
+    if values.dtype.kind == 'M':
+        raise TypeError("datetime64 type does not support operation 'any'")
+    (values, _) = _get_values(values, skipna, fill_value=False, mask=mask)
+    if values.dtype == object:
+        values = values.astype(bool)
+    return values.any(axis)
+
+def nanall(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, mask: npt.NDArray[np.bool_] | None=None) -> bool:
+    if values.dtype.kind in 'iub' and mask is None:
+        return values.all(axis)
+    if values.dtype.kind == 'M':
+        raise TypeError("datetime64 type does not support operation 'all'")
+    (values, _) = _get_values(values, skipna, fill_value=True, mask=mask)
+    if values.dtype == object:
+        values = values.astype(bool)
+    return values.all(axis)
+
+@disallow('M8')
+@_datetimelike_compat
+@maybe_operate_rowwise
+def nansum(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, min_count: int=0, mask: npt.NDArray[np.bool_] | None=None) -> float:
+    dtype = values.dtype
+    (values, mask) = _get_values(values, skipna, fill_value=0, mask=mask)
+    dtype_sum = _get_dtype_max(dtype)
+    if dtype.kind == 'f':
+        dtype_sum = dtype
+    elif dtype.kind == 'm':
+        dtype_sum = np.dtype(np.float64)
+    the_sum = values.sum(axis, dtype=dtype_sum)
+    the_sum = _maybe_null_out(the_sum, axis, mask, values.shape, min_count=min_count)
+    return the_sum
+
+def _mask_datetimelike_result(result: np.ndarray | np.datetime64 | np.timedelta64, axis: AxisInt | None, mask: npt.NDArray[np.bool_], orig_values: np.ndarray) -> np.ndarray | np.datetime64 | np.timedelta64 | NaTType:
+    if isinstance(result, np.ndarray):
+        result = result.astype('i8').view(orig_values.dtype)
+        axis_mask = mask.any(axis=axis)
+        result[axis_mask] = iNaT
+    elif mask.any():
+        return np.int64(iNaT).view(orig_values.dtype)
+    return result
+
+@bottleneck_switch()
+@_datetimelike_compat
+def nanmean(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, mask: npt.NDArray[np.bool_] | None=None) -> float:
+    dtype = values.dtype
+    (values, mask) = _get_values(values, skipna, fill_value=0, mask=mask)
+    dtype_sum = _get_dtype_max(dtype)
+    dtype_count = np.dtype(np.float64)
+    if dtype.kind in 'mM':
+        dtype_sum = np.dtype(np.float64)
+    elif dtype.kind in 'iu':
+        dtype_sum = np.dtype(np.float64)
+    elif dtype.kind == 'f':
+        dtype_sum = dtype
+        dtype_count = dtype
+    count = _get_counts(values.shape, mask, axis, dtype=dtype_count)
+    the_sum = values.sum(axis, dtype=dtype_sum)
+    the_sum = _ensure_numeric(the_sum)
+    if axis is not None and getattr(the_sum, 'ndim', False):
+        count = cast(np.ndarray, count)
+        with np.errstate(all='ignore'):
+            the_mean = the_sum / count
+        ct_mask = count == 0
+        if ct_mask.any():
+            the_mean[ct_mask] = np.nan
+    else:
+        the_mean = the_sum / count if count > 0 else np.nan
+    return the_mean
+
+@bottleneck_switch()
+def nanmedian(values, *, axis: AxisInt | None=None, skipna: bool=True, mask=None):
+    using_nan_sentinel = values.dtype.kind == 'f' and mask is None
+
+    def get_median(x, _mask=None):
+        if _mask is None:
+            _mask = notna(x)
+        else:
+            _mask = ~_mask
+        if not skipna and (not _mask.all()):
+            return np.nan
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', 'All-NaN slice encountered', RuntimeWarning)
+            warnings.filterwarnings('ignore', 'Mean of empty slice', RuntimeWarning)
+            res = np.nanmedian(x[_mask])
+        return res
+    dtype = values.dtype
+    (values, mask) = _get_values(values, skipna, mask=mask, fill_value=None)
+    if values.dtype.kind != 'f':
+        if values.dtype == object:
+            inferred = lib.infer_dtype(values)
+            if inferred in ['string', 'mixed']:
+                raise TypeError(f'Cannot convert {values} to numeric')
+        try:
+            values = values.astype('f8')
+        except ValueError as err:
+            raise TypeError(str(err)) from err
+    if not using_nan_sentinel and mask is not None:
+        if not values.flags.writeable:
+            values = values.copy()
+        values[mask] = np.nan
+    notempty = values.size
+    if values.ndim > 1 and axis is not None:
+        if notempty:
+            if not skipna:
+                res = np.apply_along_axis(get_median, axis, values)
+            else:
+                with warnings.catch_warnings():
+                    warnings.filterwarnings('ignore', 'All-NaN slice encountered', RuntimeWarning)
+                    if values.shape[1] == 1 and axis == 0 or (values.shape[0] == 1 and axis == 1):
+                        res = np.nanmedian(np.squeeze(values), keepdims=True)
+                    else:
+                        res = np.nanmedian(values, axis=axis)
+        else:
+            res = _get_empty_reduction_result(values.shape, axis)
+    else:
+        res = get_median(values, mask) if notempty else np.nan
+    return _wrap_results(res, dtype)
+
+def _get_empty_reduction_result(shape: Shape, axis: AxisInt) -> np.ndarray:
+    shp = np.array(shape)
+    dims = np.arange(len(shape))
+    ret = np.empty(shp[dims != axis], dtype=np.float64)
+    ret.fill(np.nan)
+    return ret
+
+def _get_counts_nanvar(values_shape: Shape, mask: npt.NDArray[np.bool_] | None, axis: AxisInt | None, ddof: int, dtype: np.dtype=np.dtype(np.float64)) -> tuple[float | np.ndarray, float | np.ndarray]:
+    count = _get_counts(values_shape, mask, axis, dtype=dtype)
+    d = count - dtype.type(ddof)
+    if is_float(count):
+        if count <= ddof:
+            count = np.nan
+            d = np.nan
+    else:
+        count = cast(np.ndarray, count)
+        mask = count <= ddof
+        if mask.any():
+            np.putmask(d, mask, np.nan)
+            np.putmask(count, mask, np.nan)
+    return (count, d)
+
+@bottleneck_switch(ddof=1)
+def nanstd(values, *, axis: AxisInt | None=None, skipna: bool=True, ddof: int=1, mask=None):
+    if values.dtype == 'M8[ns]':
+        values = values.view('m8[ns]')
+    orig_dtype = values.dtype
+    (values, mask) = _get_values(values, skipna, mask=mask)
+    result = np.sqrt(nanvar(values, axis=axis, skipna=skipna, ddof=ddof, mask=mask))
+    return _wrap_results(result, orig_dtype)
+
+@disallow('M8', 'm8')
+@bottleneck_switch(ddof=1)
+def nanvar(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, ddof: int=1, mask=None):
+    dtype = values.dtype
+    mask = _maybe_get_mask(values, skipna, mask)
+    if dtype.kind in 'iu':
+        values = values.astype('f8')
+        if mask is not None:
+            values[mask] = np.nan
+    if values.dtype.kind == 'f':
+        (count, d) = _get_counts_nanvar(values.shape, mask, axis, ddof, values.dtype)
+    else:
+        (count, d) = _get_counts_nanvar(values.shape, mask, axis, ddof)
+    if skipna and mask is not None:
+        values = values.copy()
+        np.putmask(values, mask, 0)
+    avg = _ensure_numeric(values.sum(axis=axis, dtype=np.float64)) / count
+    if axis is not None:
+        avg = np.expand_dims(avg, axis)
+    sqr = _ensure_numeric((avg - values) ** 2)
+    if mask is not None:
+        np.putmask(sqr, mask, 0)
+    result = sqr.sum(axis=axis, dtype=np.float64) / d
+    if dtype.kind == 'f':
+        result = result.astype(dtype, copy=False)
+    return result
+
+@disallow('M8', 'm8')
+def nansem(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, ddof: int=1, mask: npt.NDArray[np.bool_] | None=None) -> float:
+    nanvar(values, axis=axis, skipna=skipna, ddof=ddof, mask=mask)
+    mask = _maybe_get_mask(values, skipna, mask)
+    if values.dtype.kind != 'f':
+        values = values.astype('f8')
+    if not skipna and mask is not None and mask.any():
+        return np.nan
+    (count, _) = _get_counts_nanvar(values.shape, mask, axis, ddof, values.dtype)
+    var = nanvar(values, axis=axis, skipna=skipna, ddof=ddof, mask=mask)
+    return np.sqrt(var) / np.sqrt(count)
+
+def _nanminmax(meth, fill_value_typ):
+
+    @bottleneck_switch(name=f'nan{meth}')
+    @_datetimelike_compat
+    def reduction(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, mask: npt.NDArray[np.bool_] | None=None):
+        if values.size == 0:
+            return _na_for_min_count(values, axis)
+        (values, mask) = _get_values(values, skipna, fill_value_typ=fill_value_typ, mask=mask)
+        result = getattr(values, meth)(axis)
+        result = _maybe_null_out(result, axis, mask, values.shape)
+        return result
+    return reduction
+nanmin = _nanminmax('min', fill_value_typ='+inf')
+nanmax = _nanminmax('max', fill_value_typ='-inf')
+
+def nanargmax(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, mask: npt.NDArray[np.bool_] | None=None) -> int | np.ndarray:
+    (values, mask) = _get_values(values, True, fill_value_typ='-inf', mask=mask)
+    result = values.argmax(axis)
+    result = _maybe_arg_null_out(result, axis, mask, skipna)
+    return result
+
+def nanargmin(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, mask: npt.NDArray[np.bool_] | None=None) -> int | np.ndarray:
+    (values, mask) = _get_values(values, True, fill_value_typ='+inf', mask=mask)
+    result = values.argmin(axis)
+    result = _maybe_arg_null_out(result, axis, mask, skipna)
+    return result
+
+@disallow('M8', 'm8')
+@maybe_operate_rowwise
+def nanskew(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, mask: npt.NDArray[np.bool_] | None=None) -> float:
+    mask = _maybe_get_mask(values, skipna, mask)
+    if values.dtype.kind != 'f':
+        values = values.astype('f8')
+        count = _get_counts(values.shape, mask, axis)
+    else:
+        count = _get_counts(values.shape, mask, axis, dtype=values.dtype)
+    if skipna and mask is not None:
+        values = values.copy()
+        np.putmask(values, mask, 0)
+    elif not skipna and mask is not None and mask.any():
+        return np.nan
+    with np.errstate(invalid='ignore', divide='ignore'):
+        mean = values.sum(axis, dtype=np.float64) / count
+    if axis is not None:
+        mean = np.expand_dims(mean, axis)
+    adjusted = values - mean
+    if skipna and mask is not None:
+        np.putmask(adjusted, mask, 0)
+    adjusted2 = adjusted ** 2
+    adjusted3 = adjusted2 * adjusted
+    m2 = adjusted2.sum(axis, dtype=np.float64)
+    m3 = adjusted3.sum(axis, dtype=np.float64)
+    m2 = _zero_out_fperr(m2)
+    m3 = _zero_out_fperr(m3)
+    with np.errstate(invalid='ignore', divide='ignore'):
+        result = count * (count - 1) ** 0.5 / (count - 2) * (m3 / m2 ** 1.5)
+    dtype = values.dtype
+    if dtype.kind == 'f':
+        result = result.astype(dtype, copy=False)
+    if isinstance(result, np.ndarray):
+        result = np.where(m2 == 0, 0, result)
+        result[count < 3] = np.nan
+    else:
+        result = dtype.type(0) if m2 == 0 else result
+        if count < 3:
+            return np.nan
+    return result
+
+@disallow('M8', 'm8')
+@maybe_operate_rowwise
+def nankurt(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, mask: npt.NDArray[np.bool_] | None=None) -> float:
+    mask = _maybe_get_mask(values, skipna, mask)
+    if values.dtype.kind != 'f':
+        values = values.astype('f8')
+        count = _get_counts(values.shape, mask, axis)
+    else:
+        count = _get_counts(values.shape, mask, axis, dtype=values.dtype)
+    if skipna and mask is not None:
+        values = values.copy()
+        np.putmask(values, mask, 0)
+    elif not skipna and mask is not None and mask.any():
+        return np.nan
+    with np.errstate(invalid='ignore', divide='ignore'):
+        mean = values.sum(axis, dtype=np.float64) / count
+    if axis is not None:
+        mean = np.expand_dims(mean, axis)
+    adjusted = values - mean
+    if skipna and mask is not None:
+        np.putmask(adjusted, mask, 0)
+    adjusted2 = adjusted ** 2
+    adjusted4 = adjusted2 ** 2
+    m2 = adjusted2.sum(axis, dtype=np.float64)
+    m4 = adjusted4.sum(axis, dtype=np.float64)
+    with np.errstate(invalid='ignore', divide='ignore'):
+        adj = 3 * (count - 1) ** 2 / ((count - 2) * (count - 3))
+        numerator = count * (count + 1) * (count - 1) * m4
+        denominator = (count - 2) * (count - 3) * m2 ** 2
+    numerator = _zero_out_fperr(numerator)
+    denominator = _zero_out_fperr(denominator)
+    if not isinstance(denominator, np.ndarray):
+        if count < 4:
+            return np.nan
+        if denominator == 0:
+            return values.dtype.type(0)
+    with np.errstate(invalid='ignore', divide='ignore'):
+        result = numerator / denominator - adj
+    dtype = values.dtype
+    if dtype.kind == 'f':
+        result = result.astype(dtype, copy=False)
+    if isinstance(result, np.ndarray):
+        result = np.where(denominator == 0, 0, result)
+        result[count < 4] = np.nan
+    return result
+
+@disallow('M8', 'm8')
+@maybe_operate_rowwise
+def nanprod(values: np.ndarray, *, axis: AxisInt | None=None, skipna: bool=True, min_count: int=0, mask: npt.NDArray[np.bool_] | None=None) -> float:
+    mask = _maybe_get_mask(values, skipna, mask)
+    if skipna and mask is not None:
+        values = values.copy()
+        values[mask] = 1
+    result = values.prod(axis)
+    return _maybe_null_out(result, axis, mask, values.shape, min_count=min_count)
+
+def _maybe_arg_null_out(result: np.ndarray, axis: AxisInt | None, mask: npt.NDArray[np.bool_] | None, skipna: bool) -> np.ndarray | int:
+    if mask is None:
+        return result
+    if axis is None or not getattr(result, 'ndim', False):
+        if skipna and mask.all():
+            raise ValueError('Encountered all NA values')
+        elif not skipna and mask.any():
+            raise ValueError('Encountered an NA value with skipna=False')
+    elif skipna and mask.all(axis).any():
+        raise ValueError('Encountered all NA values')
+    elif not skipna and mask.any(axis).any():
+        raise ValueError('Encountered an NA value with skipna=False')
+    return result
+
+def _get_counts(values_shape: Shape, mask: npt.NDArray[np.bool_] | None, axis: AxisInt | None, dtype: np.dtype[np.floating]=np.dtype(np.float64)) -> np.floating | npt.NDArray[np.floating]:
+    if axis is None:
+        if mask is not None:
+            n = mask.size - mask.sum()
+        else:
+            n = np.prod(values_shape)
+        return dtype.type(n)
+    if mask is not None:
+        count = mask.shape[axis] - mask.sum(axis)
+    else:
+        count = values_shape[axis]
+    if is_integer(count):
+        return dtype.type(count)
+    return count.astype(dtype, copy=False)
+
+def _maybe_null_out(result: np.ndarray | float | NaTType, axis: AxisInt | None, mask: npt.NDArray[np.bool_] | None, shape: tuple[int, ...], min_count: int=1) -> np.ndarray | float | NaTType:
+    if mask is None and min_count == 0:
+        return result
+    if axis is not None and isinstance(result, np.ndarray):
+        if mask is not None:
+            null_mask = mask.shape[axis] - mask.sum(axis) - min_count < 0
+        else:
+            below_count = shape[axis] - min_count < 0
+            new_shape = shape[:axis] + shape[axis + 1:]
+            null_mask = np.broadcast_to(below_count, new_shape)
+        if np.any(null_mask):
+            if is_numeric_dtype(result):
+                if np.iscomplexobj(result):
+                    result = result.astype('c16')
+                elif not is_float_dtype(result):
+                    result = result.astype('f8', copy=False)
+                result[null_mask] = np.nan
+            else:
+                result[null_mask] = None
+    elif result is not NaT:
+        if check_below_min_count(shape, mask, min_count):
+            result_dtype = getattr(result, 'dtype', None)
+            if is_float_dtype(result_dtype):
+                result = result_dtype.type('nan')
+            else:
+                result = np.nan
+    return result
+
+def check_below_min_count(shape: tuple[int, ...], mask: npt.NDArray[np.bool_] | None, min_count: int) -> bool:
+    if min_count > 0:
+        if mask is None:
+            non_nulls = np.prod(shape)
+        else:
+            non_nulls = mask.size - mask.sum()
+        if non_nulls < min_count:
+            return True
+    return False
+
+def _zero_out_fperr(arg):
+    if isinstance(arg, np.ndarray):
+        return np.where(np.abs(arg) < 1e-14, 0, arg)
+    else:
+        return arg.dtype.type(0) if np.abs(arg) < 1e-14 else arg
+
+@disallow('M8', 'm8')
+def nancorr(a: np.ndarray, b: np.ndarray, *, method: CorrelationMethod='pearson', min_periods: int | None=None) -> float:
+    if len(a) != len(b):
+        raise AssertionError('Operands to nancorr must have same size')
+    if min_periods is None:
+        min_periods = 1
+    valid = notna(a) & notna(b)
+    if not valid.all():
+        a = a[valid]
+        b = b[valid]
+    if len(a) < min_periods:
+        return np.nan
+    a = _ensure_numeric(a)
+    b = _ensure_numeric(b)
+    f = get_corr_func(method)
+    return f(a, b)
+
+def get_corr_func(method: CorrelationMethod) -> Callable[[np.ndarray, np.ndarray], float]:
+    if method == 'kendall':
+        from scipy.stats import kendalltau
+
+        def func(a, b):
+            return kendalltau(a, b)[0]
+        return func
+    elif method == 'spearman':
+        from scipy.stats import spearmanr
+
+        def func(a, b):
+            return spearmanr(a, b)[0]
+        return func
+    elif method == 'pearson':
+
+        def func(a, b):
+            return np.corrcoef(a, b)[0, 1]
+        return func
+    elif callable(method):
+        return method
+    raise ValueError(f"Unknown method '{method}', expected one of 'kendall', 'spearman', 'pearson', or callable")
+
+@disallow('M8', 'm8')
+def nancov(a: np.ndarray, b: np.ndarray, *, min_periods: int | None=None, ddof: int | None=1) -> float:
+    if len(a) != len(b):
+        raise AssertionError('Operands to nancov must have same size')
+    if min_periods is None:
+        min_periods = 1
+    valid = notna(a) & notna(b)
+    if not valid.all():
+        a = a[valid]
+        b = b[valid]
+    if len(a) < min_periods:
+        return np.nan
+    a = _ensure_numeric(a)
+    b = _ensure_numeric(b)
+    return np.cov(a, b, ddof=ddof)[0, 1]
+
+def _ensure_numeric(x):
+    if isinstance(x, np.ndarray):
+        if x.dtype.kind in 'biu':
+            x = x.astype(np.float64)
+        elif x.dtype == object:
+            inferred = lib.infer_dtype(x)
+            if inferred in ['string', 'mixed']:
+                raise TypeError(f'Could not convert {x} to numeric')
+            try:
+                x = x.astype(np.complex128)
+            except (TypeError, ValueError):
+                try:
+                    x = x.astype(np.float64)
+                except ValueError as err:
+                    raise TypeError(f'Could not convert {x} to numeric') from err
+            else:
+                if not np.any(np.imag(x)):
+                    x = x.real
+    elif not (is_float(x) or is_integer(x) or is_complex(x)):
+        if isinstance(x, str):
+            raise TypeError(f"Could not convert string '{x}' to numeric")
+        try:
+            x = float(x)
+        except (TypeError, ValueError):
+            try:
+                x = complex(x)
+            except ValueError as err:
+                raise TypeError(f'Could not convert {x} to numeric') from err
+    return x
+
+def na_accum_func(values: ArrayLike, accum_func, *, skipna: bool) -> ArrayLike:
+    (mask_a, mask_b) = {np.cumprod: (1.0, np.nan), np.maximum.accumulate: (-np.inf, np.nan), np.cumsum: (0.0, np.nan), np.minimum.accumulate: (np.inf, np.nan)}[accum_func]
+    assert values.dtype.kind not in 'mM'
+    if skipna and (not issubclass(values.dtype.type, (np.integer, np.bool_))):
+        vals = values.copy()
+        mask = isna(vals)
+        vals[mask] = mask_a
+        result = accum_func(vals, axis=0)
+        result[mask] = mask_b
+    else:
+        result = accum_func(values, axis=0)
+    return result
+
+# File: pandas-main/pandas/core/ops/__init__.py
+""""""
+from __future__ import annotations
+from pandas.core.ops.array_ops import arithmetic_op, comp_method_OBJECT_ARRAY, comparison_op, fill_binop, get_array_op, logical_op, maybe_prepare_scalar_for_op
+from pandas.core.ops.common import get_op_result_name, unpack_zerodim_and_defer
+from pandas.core.ops.docstrings import make_flex_doc
+from pandas.core.ops.invalid import invalid_comparison
+from pandas.core.ops.mask_ops import kleene_and, kleene_or, kleene_xor
+from pandas.core.roperator import radd, rand_, rdiv, rdivmod, rfloordiv, rmod, rmul, ror_, rpow, rsub, rtruediv, rxor
+ARITHMETIC_BINOPS: set[str] = {'add', 'sub', 'mul', 'pow', 'mod', 'floordiv', 'truediv', 'divmod', 'radd', 'rsub', 'rmul', 'rpow', 'rmod', 'rfloordiv', 'rtruediv', 'rdivmod'}
+__all__ = ['ARITHMETIC_BINOPS', 'arithmetic_op', 'comparison_op', 'comp_method_OBJECT_ARRAY', 'invalid_comparison', 'fill_binop', 'kleene_and', 'kleene_or', 'kleene_xor', 'logical_op', 'make_flex_doc', 'radd', 'rand_', 'rdiv', 'rdivmod', 'rfloordiv', 'rmod', 'rmul', 'ror_', 'rpow', 'rsub', 'rtruediv', 'rxor', 'unpack_zerodim_and_defer', 'get_op_result_name', 'maybe_prepare_scalar_for_op', 'get_array_op']
+
+# File: pandas-main/pandas/core/ops/array_ops.py
+""""""
+from __future__ import annotations
+import datetime
+from functools import partial
+import operator
+from typing import TYPE_CHECKING, Any
+import numpy as np
+from pandas._libs import NaT, Timedelta, Timestamp, lib, ops as libops
+from pandas._libs.tslibs import BaseOffset, get_supported_dtype, is_supported_dtype, is_unitless
+from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike, find_common_type
+from pandas.core.dtypes.common import ensure_object, is_bool_dtype, is_list_like, is_numeric_v_string_like, is_object_dtype, is_scalar
+from pandas.core.dtypes.generic import ABCExtensionArray, ABCIndex, ABCSeries
+from pandas.core.dtypes.missing import isna, notna
+from pandas.core import roperator
+from pandas.core.computation import expressions
+from pandas.core.construction import ensure_wrapped_if_datetimelike
+from pandas.core.ops import missing
+from pandas.core.ops.dispatch import should_extension_dispatch
+from pandas.core.ops.invalid import invalid_comparison
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike, Shape
+
+def fill_binop(left, right, fill_value):
+    if fill_value is not None:
+        left_mask = isna(left)
+        right_mask = isna(right)
+        mask = left_mask ^ right_mask
+        if left_mask.any():
+            left = left.copy()
+            left[left_mask & mask] = fill_value
+        if right_mask.any():
+            right = right.copy()
+            right[right_mask & mask] = fill_value
+    return (left, right)
+
+def comp_method_OBJECT_ARRAY(op, x, y):
+    if isinstance(y, list):
+        y = construct_1d_object_array_from_listlike(y)
+    if isinstance(y, (np.ndarray, ABCSeries, ABCIndex)):
+        if not is_object_dtype(y.dtype):
+            y = y.astype(np.object_)
+        if isinstance(y, (ABCSeries, ABCIndex)):
+            y = y._values
+        if x.shape != y.shape:
+            raise ValueError('Shapes must match', x.shape, y.shape)
+        result = libops.vec_compare(x.ravel(), y.ravel(), op)
+    else:
+        result = libops.scalar_compare(x.ravel(), y, op)
+    return result.reshape(x.shape)
+
+def _masked_arith_op(x: np.ndarray, y, op) -> np.ndarray:
+    xrav = x.ravel()
+    if isinstance(y, np.ndarray):
+        dtype = find_common_type([x.dtype, y.dtype])
+        result = np.empty(x.size, dtype=dtype)
+        if len(x) != len(y):
+            raise ValueError(x.shape, y.shape)
+        ymask = notna(y)
+        yrav = y.ravel()
+        mask = notna(xrav) & ymask.ravel()
+        if mask.any():
+            result[mask] = op(xrav[mask], yrav[mask])
+    else:
+        if not is_scalar(y):
+            raise TypeError(f'Cannot broadcast np.ndarray with operand of type {type(y)}')
+        result = np.empty(x.size, dtype=x.dtype)
+        mask = notna(xrav)
+        if op is pow:
+            mask = np.where(x == 1, False, mask)
+        elif op is roperator.rpow:
+            mask = np.where(y == 1, False, mask)
+        if mask.any():
+            result[mask] = op(xrav[mask], y)
+    np.putmask(result, ~mask, np.nan)
+    result = result.reshape(x.shape)
+    return result
+
+def _na_arithmetic_op(left: np.ndarray, right, op, is_cmp: bool=False):
+    if isinstance(right, str):
+        func = op
+    else:
+        func = partial(expressions.evaluate, op)
+    try:
+        result = func(left, right)
+    except TypeError:
+        if not is_cmp and (left.dtype == object or getattr(right, 'dtype', None) == object):
+            result = _masked_arith_op(left, right, op)
+        else:
+            raise
+    if is_cmp and (is_scalar(result) or result is NotImplemented):
+        return invalid_comparison(left, right, op)
+    return missing.dispatch_fill_zeros(op, left, right, result)
+
+def arithmetic_op(left: ArrayLike, right: Any, op):
+    if should_extension_dispatch(left, right) or isinstance(right, (Timedelta, BaseOffset, Timestamp)) or right is NaT:
+        res_values = op(left, right)
+    else:
+        _bool_arith_check(op, left, right)
+        res_values = _na_arithmetic_op(left, right, op)
+    return res_values
+
+def comparison_op(left: ArrayLike, right: Any, op) -> ArrayLike:
+    lvalues = ensure_wrapped_if_datetimelike(left)
+    rvalues = ensure_wrapped_if_datetimelike(right)
+    rvalues = lib.item_from_zerodim(rvalues)
+    if isinstance(rvalues, list):
+        rvalues = np.asarray(rvalues)
+    if isinstance(rvalues, (np.ndarray, ABCExtensionArray)):
+        if len(lvalues) != len(rvalues):
+            raise ValueError('Lengths must match to compare', lvalues.shape, rvalues.shape)
+    if should_extension_dispatch(lvalues, rvalues) or ((isinstance(rvalues, (Timedelta, BaseOffset, Timestamp)) or right is NaT) and lvalues.dtype != object):
+        res_values = op(lvalues, rvalues)
+    elif is_scalar(rvalues) and isna(rvalues):
+        if op is operator.ne:
+            res_values = np.ones(lvalues.shape, dtype=bool)
+        else:
+            res_values = np.zeros(lvalues.shape, dtype=bool)
+    elif is_numeric_v_string_like(lvalues, rvalues):
+        return invalid_comparison(lvalues, rvalues, op)
+    elif lvalues.dtype == object or isinstance(rvalues, str):
+        res_values = comp_method_OBJECT_ARRAY(op, lvalues, rvalues)
+    else:
+        res_values = _na_arithmetic_op(lvalues, rvalues, op, is_cmp=True)
+    return res_values
+
+def na_logical_op(x: np.ndarray, y, op):
+    try:
+        result = op(x, y)
+    except TypeError:
+        if isinstance(y, np.ndarray):
+            assert not (x.dtype.kind == 'b' and y.dtype.kind == 'b')
+            x = ensure_object(x)
+            y = ensure_object(y)
+            result = libops.vec_binop(x.ravel(), y.ravel(), op)
+        else:
+            assert lib.is_scalar(y)
+            if not isna(y):
+                y = bool(y)
+            try:
+                result = libops.scalar_binop(x, y, op)
+            except (TypeError, ValueError, AttributeError, OverflowError, NotImplementedError) as err:
+                typ = type(y).__name__
+                raise TypeError(f"Cannot perform '{op.__name__}' with a dtyped [{x.dtype}] array and scalar of type [{typ}]") from err
+    return result.reshape(x.shape)
+
+def logical_op(left: ArrayLike, right: Any, op) -> ArrayLike:
+
+    def fill_bool(x, left=None):
+        if x.dtype.kind in 'cfO':
+            mask = isna(x)
+            if mask.any():
+                x = x.astype(object)
+                x[mask] = False
+        if left is None or left.dtype.kind == 'b':
+            x = x.astype(bool)
+        return x
+    right = lib.item_from_zerodim(right)
+    if is_list_like(right) and (not hasattr(right, 'dtype')):
+        raise TypeError('Logical ops (and, or, xor) between Pandas objects and dtype-less sequences (e.g. list, tuple) are no longer supported. Wrap the object in a Series, Index, or np.array before operating instead.')
+    lvalues = ensure_wrapped_if_datetimelike(left)
+    rvalues = right
+    if should_extension_dispatch(lvalues, rvalues):
+        res_values = op(lvalues, rvalues)
+    else:
+        if isinstance(rvalues, np.ndarray):
+            is_other_int_dtype = rvalues.dtype.kind in 'iu'
+            if not is_other_int_dtype:
+                rvalues = fill_bool(rvalues, lvalues)
+        else:
+            is_other_int_dtype = lib.is_integer(rvalues)
+        res_values = na_logical_op(lvalues, rvalues, op)
+        if not (left.dtype.kind in 'iu' and is_other_int_dtype):
+            res_values = fill_bool(res_values)
+    return res_values
+
+def get_array_op(op):
+    if isinstance(op, partial):
+        return op
+    op_name = op.__name__.strip('_').lstrip('r')
+    if op_name == 'arith_op':
+        return op
+    if op_name in {'eq', 'ne', 'lt', 'le', 'gt', 'ge'}:
+        return partial(comparison_op, op=op)
+    elif op_name in {'and', 'or', 'xor', 'rand', 'ror', 'rxor'}:
+        return partial(logical_op, op=op)
+    elif op_name in {'add', 'sub', 'mul', 'truediv', 'floordiv', 'mod', 'divmod', 'pow'}:
+        return partial(arithmetic_op, op=op)
+    else:
+        raise NotImplementedError(op_name)
+
+def maybe_prepare_scalar_for_op(obj, shape: Shape):
+    if type(obj) is datetime.timedelta:
+        return Timedelta(obj)
+    elif type(obj) is datetime.datetime:
+        return Timestamp(obj)
+    elif isinstance(obj, np.datetime64):
+        if isna(obj):
+            from pandas.core.arrays import DatetimeArray
+            if is_unitless(obj.dtype):
+                obj = obj.astype('datetime64[ns]')
+            elif not is_supported_dtype(obj.dtype):
+                new_dtype = get_supported_dtype(obj.dtype)
+                obj = obj.astype(new_dtype)
+            right = np.broadcast_to(obj, shape)
+            return DatetimeArray._simple_new(right, dtype=right.dtype)
+        return Timestamp(obj)
+    elif isinstance(obj, np.timedelta64):
+        if isna(obj):
+            from pandas.core.arrays import TimedeltaArray
+            if is_unitless(obj.dtype):
+                obj = obj.astype('timedelta64[ns]')
+            elif not is_supported_dtype(obj.dtype):
+                new_dtype = get_supported_dtype(obj.dtype)
+                obj = obj.astype(new_dtype)
+            right = np.broadcast_to(obj, shape)
+            return TimedeltaArray._simple_new(right, dtype=right.dtype)
+        return Timedelta(obj)
+    elif isinstance(obj, np.integer):
+        return int(obj)
+    elif isinstance(obj, np.floating):
+        return float(obj)
+    return obj
+_BOOL_OP_NOT_ALLOWED = {operator.truediv, roperator.rtruediv, operator.floordiv, roperator.rfloordiv, operator.pow, roperator.rpow}
+
+def _bool_arith_check(op, a: np.ndarray, b) -> None:
+    if op in _BOOL_OP_NOT_ALLOWED:
+        if a.dtype.kind == 'b' and (is_bool_dtype(b) or lib.is_bool(b)):
+            op_name = op.__name__.strip('_').lstrip('r')
+            raise NotImplementedError(f"operator '{op_name}' not implemented for bool dtypes")
+
+# File: pandas-main/pandas/core/ops/common.py
+""""""
+from __future__ import annotations
+from functools import wraps
+from typing import TYPE_CHECKING
+from pandas._libs.lib import item_from_zerodim
+from pandas._libs.missing import is_matching_na
+from pandas.core.dtypes.generic import ABCIndex, ABCSeries
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import F
+
+def unpack_zerodim_and_defer(name: str) -> Callable[[F], F]:
+
+    def wrapper(method: F) -> F:
+        return _unpack_zerodim_and_defer(method, name)
+    return wrapper
+
+def _unpack_zerodim_and_defer(method: F, name: str) -> F:
+    stripped_name = name.removeprefix('__').removesuffix('__')
+    is_cmp = stripped_name in {'eq', 'ne', 'lt', 'le', 'gt', 'ge'}
+
+    @wraps(method)
+    def new_method(self, other):
+        if is_cmp and isinstance(self, ABCIndex) and isinstance(other, ABCSeries):
+            pass
+        else:
+            prio = getattr(other, '__pandas_priority__', None)
+            if prio is not None:
+                if prio > self.__pandas_priority__:
+                    return NotImplemented
+        other = item_from_zerodim(other)
+        return method(self, other)
+    return new_method
+
+def get_op_result_name(left, right):
+    if isinstance(right, (ABCSeries, ABCIndex)):
+        name = _maybe_match_name(left, right)
+    else:
+        name = left.name
+    return name
+
+def _maybe_match_name(a, b):
+    a_has = hasattr(a, 'name')
+    b_has = hasattr(b, 'name')
+    if a_has and b_has:
+        try:
+            if a.name == b.name:
+                return a.name
+            elif is_matching_na(a.name, b.name):
+                return a.name
+            else:
+                return None
+        except TypeError:
+            if is_matching_na(a.name, b.name):
+                return a.name
+            return None
+        except ValueError:
+            return None
+    elif a_has:
+        return a.name
+    elif b_has:
+        return b.name
+    return None
+
+# File: pandas-main/pandas/core/ops/dispatch.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from pandas.core.dtypes.generic import ABCExtensionArray
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike
+
+def should_extension_dispatch(left: ArrayLike, right: Any) -> bool:
+    return isinstance(left, ABCExtensionArray) or isinstance(right, ABCExtensionArray)
+
+# File: pandas-main/pandas/core/ops/docstrings.py
+""""""
+from __future__ import annotations
+
+def make_flex_doc(op_name: str, typ: str) -> str:
+    op_name = op_name.replace('__', '')
+    op_desc = _op_descriptions[op_name]
+    op_desc_op = op_desc['op']
+    assert op_desc_op is not None
+    if op_name.startswith('r'):
+        equiv = f'other {op_desc_op} {typ}'
+    elif op_name == 'divmod':
+        equiv = f'{op_name}({typ}, other)'
+    else:
+        equiv = f'{typ} {op_desc_op} other'
+    if typ == 'series':
+        base_doc = _flex_doc_SERIES
+        if op_desc['reverse']:
+            base_doc += _see_also_reverse_SERIES.format(reverse=op_desc['reverse'], see_also_desc=op_desc['see_also_desc'])
+        doc_no_examples = base_doc.format(desc=op_desc['desc'], op_name=op_name, equiv=equiv, series_returns=op_desc['series_returns'])
+        ser_example = op_desc['series_examples']
+        if ser_example:
+            doc = doc_no_examples + ser_example
+        else:
+            doc = doc_no_examples
+    elif typ == 'dataframe':
+        if op_name in ['eq', 'ne', 'le', 'lt', 'ge', 'gt']:
+            base_doc = _flex_comp_doc_FRAME
+            doc = _flex_comp_doc_FRAME.format(op_name=op_name, desc=op_desc['desc'])
+        else:
+            base_doc = _flex_doc_FRAME
+            doc = base_doc.format(desc=op_desc['desc'], op_name=op_name, equiv=equiv, reverse=op_desc['reverse'])
+    else:
+        raise AssertionError('Invalid typ argument.')
+    return doc
+_common_examples_algebra_SERIES = "\nExamples\n--------\n>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])\n>>> a\na    1.0\nb    1.0\nc    1.0\nd    NaN\ndtype: float64\n>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])\n>>> b\na    1.0\nb    NaN\nd    1.0\ne    NaN\ndtype: float64"
+_common_examples_comparison_SERIES = "\nExamples\n--------\n>>> a = pd.Series([1, 1, 1, np.nan, 1], index=['a', 'b', 'c', 'd', 'e'])\n>>> a\na    1.0\nb    1.0\nc    1.0\nd    NaN\ne    1.0\ndtype: float64\n>>> b = pd.Series([0, 1, 2, np.nan, 1], index=['a', 'b', 'c', 'd', 'f'])\n>>> b\na    0.0\nb    1.0\nc    2.0\nd    NaN\nf    1.0\ndtype: float64"
+_add_example_SERIES = _common_examples_algebra_SERIES + '\n>>> a.add(b, fill_value=0)\na    2.0\nb    1.0\nc    1.0\nd    1.0\ne    NaN\ndtype: float64\n'
+_sub_example_SERIES = _common_examples_algebra_SERIES + '\n>>> a.subtract(b, fill_value=0)\na    0.0\nb    1.0\nc    1.0\nd   -1.0\ne    NaN\ndtype: float64\n'
+_mul_example_SERIES = _common_examples_algebra_SERIES + '\n>>> a.multiply(b, fill_value=0)\na    1.0\nb    0.0\nc    0.0\nd    0.0\ne    NaN\ndtype: float64\n'
+_div_example_SERIES = _common_examples_algebra_SERIES + '\n>>> a.divide(b, fill_value=0)\na    1.0\nb    inf\nc    inf\nd    0.0\ne    NaN\ndtype: float64\n'
+_floordiv_example_SERIES = _common_examples_algebra_SERIES + '\n>>> a.floordiv(b, fill_value=0)\na    1.0\nb    inf\nc    inf\nd    0.0\ne    NaN\ndtype: float64\n'
+_divmod_example_SERIES = _common_examples_algebra_SERIES + '\n>>> a.divmod(b, fill_value=0)\n(a    1.0\n b    inf\n c    inf\n d    0.0\n e    NaN\n dtype: float64,\n a    0.0\n b    NaN\n c    NaN\n d    0.0\n e    NaN\n dtype: float64)\n'
+_mod_example_SERIES = _common_examples_algebra_SERIES + '\n>>> a.mod(b, fill_value=0)\na    0.0\nb    NaN\nc    NaN\nd    0.0\ne    NaN\ndtype: float64\n'
+_pow_example_SERIES = _common_examples_algebra_SERIES + '\n>>> a.pow(b, fill_value=0)\na    1.0\nb    1.0\nc    1.0\nd    0.0\ne    NaN\ndtype: float64\n'
+_ne_example_SERIES = _common_examples_algebra_SERIES + '\n>>> a.ne(b, fill_value=0)\na    False\nb     True\nc     True\nd     True\ne     True\ndtype: bool\n'
+_eq_example_SERIES = _common_examples_algebra_SERIES + '\n>>> a.eq(b, fill_value=0)\na     True\nb    False\nc    False\nd    False\ne    False\ndtype: bool\n'
+_lt_example_SERIES = _common_examples_comparison_SERIES + '\n>>> a.lt(b, fill_value=0)\na    False\nb    False\nc     True\nd    False\ne    False\nf     True\ndtype: bool\n'
+_le_example_SERIES = _common_examples_comparison_SERIES + '\n>>> a.le(b, fill_value=0)\na    False\nb     True\nc     True\nd    False\ne    False\nf     True\ndtype: bool\n'
+_gt_example_SERIES = _common_examples_comparison_SERIES + '\n>>> a.gt(b, fill_value=0)\na     True\nb    False\nc    False\nd    False\ne     True\nf    False\ndtype: bool\n'
+_ge_example_SERIES = _common_examples_comparison_SERIES + '\n>>> a.ge(b, fill_value=0)\na     True\nb     True\nc    False\nd    False\ne     True\nf    False\ndtype: bool\n'
+_returns_series = 'Series\n    The result of the operation.'
+_returns_tuple = '2-Tuple of Series\n    The result of the operation.'
+_op_descriptions: dict[str, dict[str, str | None]] = {'add': {'op': '+', 'desc': 'Addition', 'reverse': 'radd', 'series_examples': _add_example_SERIES, 'series_returns': _returns_series}, 'sub': {'op': '-', 'desc': 'Subtraction', 'reverse': 'rsub', 'series_examples': _sub_example_SERIES, 'series_returns': _returns_series}, 'mul': {'op': '*', 'desc': 'Multiplication', 'reverse': 'rmul', 'series_examples': _mul_example_SERIES, 'series_returns': _returns_series, 'df_examples': None}, 'mod': {'op': '%', 'desc': 'Modulo', 'reverse': 'rmod', 'series_examples': _mod_example_SERIES, 'series_returns': _returns_series}, 'pow': {'op': '**', 'desc': 'Exponential power', 'reverse': 'rpow', 'series_examples': _pow_example_SERIES, 'series_returns': _returns_series, 'df_examples': None}, 'truediv': {'op': '/', 'desc': 'Floating division', 'reverse': 'rtruediv', 'series_examples': _div_example_SERIES, 'series_returns': _returns_series, 'df_examples': None}, 'floordiv': {'op': '//', 'desc': 'Integer division', 'reverse': 'rfloordiv', 'series_examples': _floordiv_example_SERIES, 'series_returns': _returns_series, 'df_examples': None}, 'divmod': {'op': 'divmod', 'desc': 'Integer division and modulo', 'reverse': 'rdivmod', 'series_examples': _divmod_example_SERIES, 'series_returns': _returns_tuple, 'df_examples': None}, 'eq': {'op': '==', 'desc': 'Equal to', 'reverse': None, 'series_examples': _eq_example_SERIES, 'series_returns': _returns_series}, 'ne': {'op': '!=', 'desc': 'Not equal to', 'reverse': 'eq', 'series_examples': _ne_example_SERIES, 'series_returns': _returns_series}, 'lt': {'op': '<', 'desc': 'Less than', 'reverse': None, 'series_examples': _lt_example_SERIES, 'series_returns': _returns_series}, 'le': {'op': '<=', 'desc': 'Less than or equal to', 'reverse': None, 'series_examples': _le_example_SERIES, 'series_returns': _returns_series}, 'gt': {'op': '>', 'desc': 'Greater than', 'reverse': 'lt', 'series_examples': _gt_example_SERIES, 'series_returns': _returns_series}, 'ge': {'op': '>=', 'desc': 'Greater than or equal to', 'reverse': 'le', 'series_examples': _ge_example_SERIES, 'series_returns': _returns_series}}
+_py_num_ref = 'see\n    `Python documentation\n    <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>`_\n    for more details'
+_op_names = list(_op_descriptions.keys())
+for key in _op_names:
+    reverse_op = _op_descriptions[key]['reverse']
+    if reverse_op is not None:
+        _op_descriptions[reverse_op] = _op_descriptions[key].copy()
+        _op_descriptions[reverse_op]['reverse'] = key
+        _op_descriptions[key]['see_also_desc'] = f"Reverse of the {_op_descriptions[key]['desc']} operator, {_py_num_ref}"
+        _op_descriptions[reverse_op]['see_also_desc'] = f"Element-wise {_op_descriptions[key]['desc']}, {_py_num_ref}"
+_flex_doc_SERIES = "\nReturn {desc} of series and other, element-wise (binary operator `{op_name}`).\n\nEquivalent to ``{equiv}``, but with support to substitute a fill_value for\nmissing data in either one of the inputs.\n\nParameters\n----------\nother : Series or scalar value\n    The second operand in this operation.\nlevel : int or name\n    Broadcast across a level, matching Index values on the\n    passed MultiIndex level.\nfill_value : None or float value, default None (NaN)\n    Fill existing missing (NaN) values, and any new element needed for\n    successful Series alignment, with this value before computation.\n    If data in both corresponding Series locations is missing\n    the result of filling (at that location) will be missing.\naxis : {{0 or 'index'}}\n    Unused. Parameter needed for compatibility with DataFrame.\n\nReturns\n-------\n{series_returns}\n"
+_see_also_reverse_SERIES = '\nSee Also\n--------\nSeries.{reverse} : {see_also_desc}.\n'
+_flex_doc_FRAME = "\nGet {desc} of dataframe and other, element-wise (binary operator `{op_name}`).\n\nEquivalent to ``{equiv}``, but with support to substitute a fill_value\nfor missing data in one of the inputs. With reverse version, `{reverse}`.\n\nAmong flexible wrappers (`add`, `sub`, `mul`, `div`, `floordiv`, `mod`, `pow`) to\narithmetic operators: `+`, `-`, `*`, `/`, `//`, `%`, `**`.\n\nParameters\n----------\nother : scalar, sequence, Series, dict or DataFrame\n    Any single or multiple element data structure, or list-like object.\naxis : {{0 or 'index', 1 or 'columns'}}\n    Whether to compare by the index (0 or 'index') or columns.\n    (1 or 'columns'). For Series input, axis to match Series index on.\nlevel : int or label\n    Broadcast across a level, matching Index values on the\n    passed MultiIndex level.\nfill_value : float or None, default None\n    Fill existing missing (NaN) values, and any new element needed for\n    successful DataFrame alignment, with this value before computation.\n    If data in both corresponding DataFrame locations is missing\n    the result will be missing.\n\nReturns\n-------\nDataFrame\n    Result of the arithmetic operation.\n\nSee Also\n--------\nDataFrame.add : Add DataFrames.\nDataFrame.sub : Subtract DataFrames.\nDataFrame.mul : Multiply DataFrames.\nDataFrame.div : Divide DataFrames (float division).\nDataFrame.truediv : Divide DataFrames (float division).\nDataFrame.floordiv : Divide DataFrames (integer division).\nDataFrame.mod : Calculate modulo (remainder after division).\nDataFrame.pow : Calculate exponential power.\n\nNotes\n-----\nMismatched indices will be unioned together.\n\nExamples\n--------\n>>> df = pd.DataFrame({{'angles': [0, 3, 4],\n...                    'degrees': [360, 180, 360]}},\n...                   index=['circle', 'triangle', 'rectangle'])\n>>> df\n           angles  degrees\ncircle          0      360\ntriangle        3      180\nrectangle       4      360\n\nAdd a scalar with operator version which return the same\nresults.\n\n>>> df + 1\n           angles  degrees\ncircle          1      361\ntriangle        4      181\nrectangle       5      361\n\n>>> df.add(1)\n           angles  degrees\ncircle          1      361\ntriangle        4      181\nrectangle       5      361\n\nDivide by constant with reverse version.\n\n>>> df.div(10)\n           angles  degrees\ncircle        0.0     36.0\ntriangle      0.3     18.0\nrectangle     0.4     36.0\n\n>>> df.rdiv(10)\n             angles   degrees\ncircle          inf  0.027778\ntriangle   3.333333  0.055556\nrectangle  2.500000  0.027778\n\nSubtract a list and Series by axis with operator version.\n\n>>> df - [1, 2]\n           angles  degrees\ncircle         -1      358\ntriangle        2      178\nrectangle       3      358\n\n>>> df.sub([1, 2], axis='columns')\n           angles  degrees\ncircle         -1      358\ntriangle        2      178\nrectangle       3      358\n\n>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),\n...        axis='index')\n           angles  degrees\ncircle         -1      359\ntriangle        2      179\nrectangle       3      359\n\nMultiply a dictionary by axis.\n\n>>> df.mul({{'angles': 0, 'degrees': 2}})\n            angles  degrees\ncircle           0      720\ntriangle         0      360\nrectangle        0      720\n\n>>> df.mul({{'circle': 0, 'triangle': 2, 'rectangle': 3}}, axis='index')\n            angles  degrees\ncircle           0        0\ntriangle         6      360\nrectangle       12     1080\n\nMultiply a DataFrame of different shape with operator version.\n\n>>> other = pd.DataFrame({{'angles': [0, 3, 4]}},\n...                      index=['circle', 'triangle', 'rectangle'])\n>>> other\n           angles\ncircle          0\ntriangle        3\nrectangle       4\n\n>>> df * other\n           angles  degrees\ncircle          0      NaN\ntriangle        9      NaN\nrectangle      16      NaN\n\n>>> df.mul(other, fill_value=0)\n           angles  degrees\ncircle          0      0.0\ntriangle        9      0.0\nrectangle      16      0.0\n\nDivide by a MultiIndex by level.\n\n>>> df_multindex = pd.DataFrame({{'angles': [0, 3, 4, 4, 5, 6],\n...                              'degrees': [360, 180, 360, 360, 540, 720]}},\n...                             index=[['A', 'A', 'A', 'B', 'B', 'B'],\n...                                    ['circle', 'triangle', 'rectangle',\n...                                     'square', 'pentagon', 'hexagon']])\n>>> df_multindex\n             angles  degrees\nA circle          0      360\n  triangle        3      180\n  rectangle       4      360\nB square          4      360\n  pentagon        5      540\n  hexagon         6      720\n\n>>> df.div(df_multindex, level=1, fill_value=0)\n             angles  degrees\nA circle        NaN      1.0\n  triangle      1.0      1.0\n  rectangle     1.0      1.0\nB square        0.0      0.0\n  pentagon      0.0      0.0\n  hexagon       0.0      0.0\n\n>>> df_pow = pd.DataFrame({{'A': [2, 3, 4, 5],\n...                        'B': [6, 7, 8, 9]}})\n>>> df_pow.pow(2)\n    A   B\n0   4  36\n1   9  49\n2  16  64\n3  25  81\n"
+_flex_comp_doc_FRAME = '\nGet {desc} of dataframe and other, element-wise (binary operator `{op_name}`).\n\nAmong flexible wrappers (`eq`, `ne`, `le`, `lt`, `ge`, `gt`) to comparison\noperators.\n\nEquivalent to `==`, `!=`, `<=`, `<`, `>=`, `>` with support to choose axis\n(rows or columns) and level for comparison.\n\nParameters\n----------\nother : scalar, sequence, Series, or DataFrame\n    Any single or multiple element data structure, or list-like object.\naxis : {{0 or \'index\', 1 or \'columns\'}}, default \'columns\'\n    Whether to compare by the index (0 or \'index\') or columns\n    (1 or \'columns\').\nlevel : int or label\n    Broadcast across a level, matching Index values on the passed\n    MultiIndex level.\n\nReturns\n-------\nDataFrame of bool\n    Result of the comparison.\n\nSee Also\n--------\nDataFrame.eq : Compare DataFrames for equality elementwise.\nDataFrame.ne : Compare DataFrames for inequality elementwise.\nDataFrame.le : Compare DataFrames for less than inequality\n    or equality elementwise.\nDataFrame.lt : Compare DataFrames for strictly less than\n    inequality elementwise.\nDataFrame.ge : Compare DataFrames for greater than inequality\n    or equality elementwise.\nDataFrame.gt : Compare DataFrames for strictly greater than\n    inequality elementwise.\n\nNotes\n-----\nMismatched indices will be unioned together.\n`NaN` values are considered different (i.e. `NaN` != `NaN`).\n\nExamples\n--------\n>>> df = pd.DataFrame({{\'cost\': [250, 150, 100],\n...                    \'revenue\': [100, 250, 300]}},\n...                   index=[\'A\', \'B\', \'C\'])\n>>> df\n   cost  revenue\nA   250      100\nB   150      250\nC   100      300\n\nComparison with a scalar, using either the operator or method:\n\n>>> df == 100\n    cost  revenue\nA  False     True\nB  False    False\nC   True    False\n\n>>> df.eq(100)\n    cost  revenue\nA  False     True\nB  False    False\nC   True    False\n\nWhen `other` is a :class:`Series`, the columns of a DataFrame are aligned\nwith the index of `other` and broadcast:\n\n>>> df != pd.Series([100, 250], index=["cost", "revenue"])\n    cost  revenue\nA   True     True\nB   True    False\nC  False     True\n\nUse the method to control the broadcast axis:\n\n>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis=\'index\')\n   cost  revenue\nA  True    False\nB  True     True\nC  True     True\nD  True     True\n\nWhen comparing to an arbitrary sequence, the number of columns must\nmatch the number elements in `other`:\n\n>>> df == [250, 100]\n    cost  revenue\nA   True     True\nB  False    False\nC  False    False\n\nUse the method to control the axis:\n\n>>> df.eq([250, 250, 100], axis=\'index\')\n    cost  revenue\nA   True    False\nB  False     True\nC   True    False\n\nCompare to a DataFrame of different shape.\n\n>>> other = pd.DataFrame({{\'revenue\': [300, 250, 100, 150]}},\n...                      index=[\'A\', \'B\', \'C\', \'D\'])\n>>> other\n   revenue\nA      300\nB      250\nC      100\nD      150\n\n>>> df.gt(other)\n    cost  revenue\nA  False    False\nB  False    False\nC  False     True\nD  False    False\n\nCompare to a MultiIndex by level.\n\n>>> df_multindex = pd.DataFrame({{\'cost\': [250, 150, 100, 150, 300, 220],\n...                              \'revenue\': [100, 250, 300, 200, 175, 225]}},\n...                             index=[[\'Q1\', \'Q1\', \'Q1\', \'Q2\', \'Q2\', \'Q2\'],\n...                                    [\'A\', \'B\', \'C\', \'A\', \'B\', \'C\']])\n>>> df_multindex\n      cost  revenue\nQ1 A   250      100\n   B   150      250\n   C   100      300\nQ2 A   150      200\n   B   300      175\n   C   220      225\n\n>>> df.le(df_multindex, level=1)\n       cost  revenue\nQ1 A   True     True\n   B   True     True\n   C   True     True\nQ2 A  False     True\n   B   True    False\n   C   True    False\n'
+
+# File: pandas-main/pandas/core/ops/invalid.py
+""""""
+from __future__ import annotations
+import operator
+from typing import TYPE_CHECKING, Any, NoReturn
+import numpy as np
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import ArrayLike, Scalar, npt
+
+def invalid_comparison(left: ArrayLike, right: ArrayLike | Scalar, op: Callable[[Any, Any], bool]) -> npt.NDArray[np.bool_]:
+    if op is operator.eq:
+        res_values = np.zeros(left.shape, dtype=bool)
+    elif op is operator.ne:
+        res_values = np.ones(left.shape, dtype=bool)
+    else:
+        typ = type(right).__name__
+        raise TypeError(f'Invalid comparison between dtype={left.dtype} and {typ}')
+    return res_values
+
+def make_invalid_op(name: str) -> Callable[..., NoReturn]:
+
+    def invalid_op(self: object, other: object=None) -> NoReturn:
+        typ = type(self).__name__
+        raise TypeError(f'cannot perform {name} with this index type: {typ}')
+    invalid_op.__name__ = name
+    return invalid_op
+
+# File: pandas-main/pandas/core/ops/mask_ops.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs import lib, missing as libmissing
+if TYPE_CHECKING:
+    from pandas._typing import npt
+
+def kleene_or(left: bool | np.ndarray | libmissing.NAType, right: bool | np.ndarray | libmissing.NAType, left_mask: np.ndarray | None, right_mask: np.ndarray | None) -> tuple[npt.NDArray[np.bool_], npt.NDArray[np.bool_]]:
+    if left_mask is None:
+        return kleene_or(right, left, right_mask, left_mask)
+    if not isinstance(left, np.ndarray):
+        raise TypeError('Either `left` or `right` need to be a np.ndarray.')
+    raise_for_nan(right, method='or')
+    if right is libmissing.NA:
+        result = left.copy()
+    else:
+        result = left | right
+    if right_mask is not None:
+        left_false = ~(left | left_mask)
+        right_false = ~(right | right_mask)
+        mask = left_false & right_mask | right_false & left_mask | left_mask & right_mask
+    elif right is True:
+        mask = np.zeros_like(left_mask)
+    elif right is libmissing.NA:
+        mask = ~left & ~left_mask | left_mask
+    else:
+        mask = left_mask.copy()
+    return (result, mask)
+
+def kleene_xor(left: bool | np.ndarray | libmissing.NAType, right: bool | np.ndarray | libmissing.NAType, left_mask: np.ndarray | None, right_mask: np.ndarray | None) -> tuple[npt.NDArray[np.bool_], npt.NDArray[np.bool_]]:
+    if left_mask is None:
+        return kleene_xor(right, left, right_mask, left_mask)
+    if not isinstance(left, np.ndarray):
+        raise TypeError('Either `left` or `right` need to be a np.ndarray.')
+    raise_for_nan(right, method='xor')
+    if right is libmissing.NA:
+        result = np.zeros_like(left)
+    else:
+        result = left ^ right
+    if right_mask is None:
+        if right is libmissing.NA:
+            mask = np.ones_like(left_mask)
+        else:
+            mask = left_mask.copy()
+    else:
+        mask = left_mask | right_mask
+    return (result, mask)
+
+def kleene_and(left: bool | libmissing.NAType | np.ndarray, right: bool | libmissing.NAType | np.ndarray, left_mask: np.ndarray | None, right_mask: np.ndarray | None) -> tuple[npt.NDArray[np.bool_], npt.NDArray[np.bool_]]:
+    if left_mask is None:
+        return kleene_and(right, left, right_mask, left_mask)
+    if not isinstance(left, np.ndarray):
+        raise TypeError('Either `left` or `right` need to be a np.ndarray.')
+    raise_for_nan(right, method='and')
+    if right is libmissing.NA:
+        result = np.zeros_like(left)
+    else:
+        result = left & right
+    if right_mask is None:
+        if right is libmissing.NA:
+            mask = left & ~left_mask | left_mask
+        else:
+            mask = left_mask.copy()
+            if right is False:
+                mask[:] = False
+    else:
+        left_false = ~(left | left_mask)
+        right_false = ~(right | right_mask)
+        mask = left_mask & ~right_false | right_mask & ~left_false
+    return (result, mask)
+
+def raise_for_nan(value: object, method: str) -> None:
+    if lib.is_float(value) and np.isnan(value):
+        raise ValueError(f"Cannot perform logical '{method}' with floating NaN")
+
+# File: pandas-main/pandas/core/ops/missing.py
+""""""
+from __future__ import annotations
+import operator
+import numpy as np
+from pandas.core import roperator
+
+def _fill_zeros(result: np.ndarray, x, y) -> np.ndarray:
+    if result.dtype.kind == 'f':
+        return result
+    is_variable_type = hasattr(y, 'dtype')
+    is_scalar_type = not isinstance(y, np.ndarray)
+    if not is_variable_type and (not is_scalar_type):
+        return result
+    if is_scalar_type:
+        y = np.array(y)
+    if y.dtype.kind in 'iu':
+        ymask = y == 0
+        if ymask.any():
+            mask = ymask & ~np.isnan(result)
+            result = result.astype('float64', copy=False)
+            np.putmask(result, mask, np.nan)
+    return result
+
+def mask_zero_div_zero(x, y, result: np.ndarray) -> np.ndarray:
+    if not hasattr(y, 'dtype'):
+        y = np.array(y)
+    if not hasattr(x, 'dtype'):
+        x = np.array(x)
+    zmask = y == 0
+    if zmask.any():
+        zneg_mask = zmask & np.signbit(y)
+        zpos_mask = zmask & ~zneg_mask
+        x_lt0 = x < 0
+        x_gt0 = x > 0
+        nan_mask = zmask & (x == 0)
+        neginf_mask = zpos_mask & x_lt0 | zneg_mask & x_gt0
+        posinf_mask = zpos_mask & x_gt0 | zneg_mask & x_lt0
+        if nan_mask.any() or neginf_mask.any() or posinf_mask.any():
+            result = result.astype('float64', copy=False)
+            result[nan_mask] = np.nan
+            result[posinf_mask] = np.inf
+            result[neginf_mask] = -np.inf
+    return result
+
+def dispatch_fill_zeros(op, left, right, result):
+    if op is divmod:
+        result = (mask_zero_div_zero(left, right, result[0]), _fill_zeros(result[1], left, right))
+    elif op is roperator.rdivmod:
+        result = (mask_zero_div_zero(right, left, result[0]), _fill_zeros(result[1], right, left))
+    elif op is operator.floordiv:
+        result = mask_zero_div_zero(left, right, result)
+    elif op is roperator.rfloordiv:
+        result = mask_zero_div_zero(right, left, result)
+    elif op is operator.mod:
+        result = _fill_zeros(result, left, right)
+    elif op is roperator.rmod:
+        result = _fill_zeros(result, right, left)
+    return result
+
+# File: pandas-main/pandas/core/resample.py
+from __future__ import annotations
+import copy
+from textwrap import dedent
+from typing import TYPE_CHECKING, Literal, cast, final, no_type_check, overload
+import warnings
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.tslibs import BaseOffset, IncompatibleFrequency, NaT, Period, Timedelta, Timestamp, to_offset
+from pandas._typing import NDFrameT
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import Appender, Substitution, doc
+from pandas.util._exceptions import find_stack_level, rewrite_warning
+from pandas.core.dtypes.dtypes import ArrowDtype, PeriodDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+import pandas.core.algorithms as algos
+from pandas.core.apply import ResamplerWindowApply
+from pandas.core.arrays import ArrowExtensionArray
+from pandas.core.base import PandasObject, SelectionMixin
+from pandas.core.generic import NDFrame, _shared_docs
+from pandas.core.groupby.groupby import BaseGroupBy, GroupBy, _apply_groupings_depr, _pipe_template, get_groupby
+from pandas.core.groupby.grouper import Grouper
+from pandas.core.groupby.ops import BinGrouper
+from pandas.core.indexes.api import MultiIndex
+from pandas.core.indexes.base import Index
+from pandas.core.indexes.datetimes import DatetimeIndex, date_range
+from pandas.core.indexes.period import PeriodIndex, period_range
+from pandas.core.indexes.timedeltas import TimedeltaIndex, timedelta_range
+from pandas.core.reshape.concat import concat
+from pandas.tseries.frequencies import is_subperiod, is_superperiod
+from pandas.tseries.offsets import Day, Tick
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable
+    from pandas._typing import Any, AnyArrayLike, Axis, Concatenate, FreqIndexT, Frequency, IndexLabel, InterpolateOptions, P, Self, T, TimedeltaConvertibleTypes, TimeGrouperOrigin, TimestampConvertibleTypes, npt
+    from pandas import DataFrame, Series
+_shared_docs_kwargs: dict[str, str] = {}
+
+class Resampler(BaseGroupBy, PandasObject):
+    _grouper: BinGrouper
+    _timegrouper: TimeGrouper
+    binner: DatetimeIndex | TimedeltaIndex | PeriodIndex
+    exclusions: frozenset[Hashable] = frozenset()
+    _internal_names_set = set({'obj', 'ax', '_indexer'})
+    _attributes = ['freq', 'closed', 'label', 'convention', 'origin', 'offset']
+
+    def __init__(self, obj: NDFrame, timegrouper: TimeGrouper, *, gpr_index: Index, group_keys: bool=False, selection=None, include_groups: bool=True) -> None:
+        self._timegrouper = timegrouper
+        self.keys = None
+        self.sort = True
+        self.group_keys = group_keys
+        self.as_index = True
+        self.include_groups = include_groups
+        (self.obj, self.ax, self._indexer) = self._timegrouper._set_grouper(self._convert_obj(obj), sort=True, gpr_index=gpr_index)
+        (self.binner, self._grouper) = self._get_binner()
+        self._selection = selection
+        if self._timegrouper.key is not None:
+            self.exclusions = frozenset([self._timegrouper.key])
+        else:
+            self.exclusions = frozenset()
+
+    @final
+    def __str__(self) -> str:
+        attrs = (f'{k}={getattr(self._timegrouper, k)}' for k in self._attributes if getattr(self._timegrouper, k, None) is not None)
+        return f"{type(self).__name__} [{', '.join(attrs)}]"
+
+    @final
+    def __getattr__(self, attr: str):
+        if attr in self._internal_names_set:
+            return object.__getattribute__(self, attr)
+        if attr in self._attributes:
+            return getattr(self._timegrouper, attr)
+        if attr in self.obj:
+            return self[attr]
+        return object.__getattribute__(self, attr)
+
+    @final
+    @property
+    def _from_selection(self) -> bool:
+        return self._timegrouper is not None and (self._timegrouper.key is not None or self._timegrouper.level is not None)
+
+    def _convert_obj(self, obj: NDFrameT) -> NDFrameT:
+        return obj._consolidate()
+
+    def _get_binner_for_time(self):
+        raise AbstractMethodError(self)
+
+    @final
+    def _get_binner(self):
+        (binner, bins, binlabels) = self._get_binner_for_time()
+        assert len(bins) == len(binlabels)
+        bin_grouper = BinGrouper(bins, binlabels, indexer=self._indexer)
+        return (binner, bin_grouper)
+
+    @overload
+    def pipe(self, func: Callable[Concatenate[Self, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+        ...
+
+    @overload
+    def pipe(self, func: tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T:
+        ...
+
+    @final
+    @Substitution(klass='Resampler', examples="\n    >>> df = pd.DataFrame({'A': [1, 2, 3, 4]},\n    ...                   index=pd.date_range('2012-08-02', periods=4))\n    >>> df\n                A\n    2012-08-02  1\n    2012-08-03  2\n    2012-08-04  3\n    2012-08-05  4\n\n    To get the difference between each 2-day period's maximum and minimum\n    value in one pass, you can do\n\n    >>> df.resample('2D').pipe(lambda x: x.max() - x.min())\n                A\n    2012-08-02  1\n    2012-08-04  1")
+    @Appender(_pipe_template)
+    def pipe(self, func: Callable[Concatenate[Self, P], T] | tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T:
+        return super().pipe(func, *args, **kwargs)
+    _agg_see_also_doc = dedent('\n    See Also\n    --------\n    DataFrame.groupby.aggregate : Aggregate using callable, string, dict,\n        or list of string/callables.\n    DataFrame.resample.transform : Transforms the Series on each group\n        based on the given function.\n    DataFrame.aggregate: Aggregate using one or more\n        operations over the specified axis.\n    ')
+    _agg_examples_doc = dedent('\n    Examples\n    --------\n    >>> s = pd.Series([1, 2, 3, 4, 5],\n    ...               index=pd.date_range(\'20130101\', periods=5, freq=\'s\'))\n    >>> s\n    2013-01-01 00:00:00    1\n    2013-01-01 00:00:01    2\n    2013-01-01 00:00:02    3\n    2013-01-01 00:00:03    4\n    2013-01-01 00:00:04    5\n    Freq: s, dtype: int64\n\n    >>> r = s.resample(\'2s\')\n\n    >>> r.agg("sum")\n    2013-01-01 00:00:00    3\n    2013-01-01 00:00:02    7\n    2013-01-01 00:00:04    5\n    Freq: 2s, dtype: int64\n\n    >>> r.agg([\'sum\', \'mean\', \'max\'])\n                         sum  mean  max\n    2013-01-01 00:00:00    3   1.5    2\n    2013-01-01 00:00:02    7   3.5    4\n    2013-01-01 00:00:04    5   5.0    5\n\n    >>> r.agg({\'result\': lambda x: x.mean() / x.std(),\n    ...        \'total\': "sum"})\n                           result  total\n    2013-01-01 00:00:00  2.121320      3\n    2013-01-01 00:00:02  4.949747      7\n    2013-01-01 00:00:04       NaN      5\n\n    >>> r.agg(average="mean", total="sum")\n                             average  total\n    2013-01-01 00:00:00      1.5      3\n    2013-01-01 00:00:02      3.5      7\n    2013-01-01 00:00:04      5.0      5\n    ')
+
+    @final
+    @doc(_shared_docs['aggregate'], see_also=_agg_see_also_doc, examples=_agg_examples_doc, klass='DataFrame', axis='')
+    def aggregate(self, func=None, *args, **kwargs):
+        result = ResamplerWindowApply(self, func, args=args, kwargs=kwargs).agg()
+        if result is None:
+            how = func
+            result = self._groupby_and_aggregate(how, *args, **kwargs)
+        return result
+    agg = aggregate
+    apply = aggregate
+
+    @final
+    def transform(self, arg, *args, **kwargs):
+        return self._selected_obj.groupby(self._timegrouper).transform(arg, *args, **kwargs)
+
+    def _downsample(self, f, **kwargs):
+        raise AbstractMethodError(self)
+
+    def _upsample(self, f, limit: int | None=None, fill_value=None):
+        raise AbstractMethodError(self)
+
+    def _gotitem(self, key, ndim: int, subset=None):
+        grouper = self._grouper
+        if subset is None:
+            subset = self.obj
+            if key is not None:
+                subset = subset[key]
+            else:
+                assert subset.ndim == 1
+        if ndim == 1:
+            assert subset.ndim == 1
+        grouped = get_groupby(subset, by=None, grouper=grouper, group_keys=self.group_keys)
+        return grouped
+
+    def _groupby_and_aggregate(self, how, *args, **kwargs):
+        grouper = self._grouper
+        obj = self._obj_with_exclusions
+        grouped = get_groupby(obj, by=None, grouper=grouper, group_keys=self.group_keys)
+        try:
+            if callable(how):
+                func = lambda x: how(x, *args, **kwargs)
+                result = grouped.aggregate(func)
+            else:
+                result = grouped.aggregate(how, *args, **kwargs)
+        except (AttributeError, KeyError):
+            result = _apply(grouped, how, *args, include_groups=self.include_groups, **kwargs)
+        except ValueError as err:
+            if 'Must produce aggregated value' in str(err):
+                pass
+            else:
+                raise
+            result = _apply(grouped, how, *args, include_groups=self.include_groups, **kwargs)
+        return self._wrap_result(result)
+
+    @final
+    def _get_resampler_for_grouping(self, groupby: GroupBy, key, include_groups: bool=True):
+        return self._resampler_for_grouping(groupby=groupby, key=key, parent=self, include_groups=include_groups)
+
+    def _wrap_result(self, result):
+        obj = self.obj
+        if isinstance(result, ABCDataFrame) and len(result) == 0 and (not isinstance(result.index, PeriodIndex)):
+            result = result.set_index(_asfreq_compat(obj.index[:0], freq=self.freq), append=True)
+        if isinstance(result, ABCSeries) and self._selection is not None:
+            result.name = self._selection
+        if isinstance(result, ABCSeries) and result.empty:
+            result.index = _asfreq_compat(obj.index[:0], freq=self.freq)
+            result.name = getattr(obj, 'name', None)
+        if self._timegrouper._arrow_dtype is not None:
+            result.index = result.index.astype(self._timegrouper._arrow_dtype)
+        return result
+
+    @final
+    def ffill(self, limit: int | None=None):
+        return self._upsample('ffill', limit=limit)
+
+    @final
+    def nearest(self, limit: int | None=None):
+        return self._upsample('nearest', limit=limit)
+
+    @final
+    def bfill(self, limit: int | None=None):
+        return self._upsample('bfill', limit=limit)
+
+    @final
+    def interpolate(self, method: InterpolateOptions='linear', *, axis: Axis=0, limit: int | None=None, inplace: bool=False, limit_direction: Literal['forward', 'backward', 'both']='forward', limit_area=None, downcast=lib.no_default, **kwargs):
+        assert downcast is lib.no_default
+        result = self._upsample('asfreq')
+        obj = self._selected_obj
+        is_period_index = isinstance(obj.index, PeriodIndex)
+        if not is_period_index:
+            final_index = result.index
+            if isinstance(final_index, MultiIndex):
+                raise NotImplementedError('Direct interpolation of MultiIndex data frames is not supported. If you tried to resample and interpolate on a grouped data frame, please use:\n`df.groupby(...).apply(lambda x: x.resample(...).interpolate(...), include_groups=False)`\ninstead, as resampling and interpolation has to be performed for each group independently.')
+            missing_data_points_index = obj.index.difference(final_index)
+            if len(missing_data_points_index) > 0:
+                result = concat([result, obj.loc[missing_data_points_index]]).sort_index()
+        result_interpolated = result.interpolate(method=method, axis=axis, limit=limit, inplace=inplace, limit_direction=limit_direction, limit_area=limit_area, downcast=downcast, **kwargs)
+        if is_period_index:
+            return result_interpolated
+        result_interpolated = result_interpolated.loc[final_index]
+        result_interpolated.index = final_index
+        return result_interpolated
+
+    @final
+    def asfreq(self, fill_value=None):
+        return self._upsample('asfreq', fill_value=fill_value)
+
+    @final
+    def sum(self, numeric_only: bool=False, min_count: int=0):
+        return self._downsample('sum', numeric_only=numeric_only, min_count=min_count)
+
+    @final
+    def prod(self, numeric_only: bool=False, min_count: int=0):
+        return self._downsample('prod', numeric_only=numeric_only, min_count=min_count)
+
+    @final
+    def min(self, numeric_only: bool=False, min_count: int=0):
+        return self._downsample('min', numeric_only=numeric_only, min_count=min_count)
+
+    @final
+    def max(self, numeric_only: bool=False, min_count: int=0):
+        return self._downsample('max', numeric_only=numeric_only, min_count=min_count)
+
+    @final
+    @doc(GroupBy.first)
+    def first(self, numeric_only: bool=False, min_count: int=0, skipna: bool=True):
+        return self._downsample('first', numeric_only=numeric_only, min_count=min_count, skipna=skipna)
+
+    @final
+    @doc(GroupBy.last)
+    def last(self, numeric_only: bool=False, min_count: int=0, skipna: bool=True):
+        return self._downsample('last', numeric_only=numeric_only, min_count=min_count, skipna=skipna)
+
+    @final
+    @doc(GroupBy.median)
+    def median(self, numeric_only: bool=False):
+        return self._downsample('median', numeric_only=numeric_only)
+
+    @final
+    def mean(self, numeric_only: bool=False):
+        return self._downsample('mean', numeric_only=numeric_only)
+
+    @final
+    def std(self, ddof: int=1, numeric_only: bool=False):
+        return self._downsample('std', ddof=ddof, numeric_only=numeric_only)
+
+    @final
+    def var(self, ddof: int=1, numeric_only: bool=False):
+        return self._downsample('var', ddof=ddof, numeric_only=numeric_only)
+
+    @final
+    @doc(GroupBy.sem)
+    def sem(self, ddof: int=1, numeric_only: bool=False):
+        return self._downsample('sem', ddof=ddof, numeric_only=numeric_only)
+
+    @final
+    @doc(GroupBy.ohlc)
+    def ohlc(self):
+        ax = self.ax
+        obj = self._obj_with_exclusions
+        if len(ax) == 0:
+            obj = obj.copy()
+            obj.index = _asfreq_compat(obj.index, self.freq)
+            if obj.ndim == 1:
+                obj = obj.to_frame()
+                obj = obj.reindex(['open', 'high', 'low', 'close'], axis=1)
+            else:
+                mi = MultiIndex.from_product([obj.columns, ['open', 'high', 'low', 'close']])
+                obj = obj.reindex(mi, axis=1)
+            return obj
+        return self._downsample('ohlc')
+
+    @final
+    def nunique(self):
+        return self._downsample('nunique')
+
+    @final
+    @doc(GroupBy.size)
+    def size(self):
+        result = self._downsample('size')
+        if isinstance(result, ABCDataFrame) and (not result.empty):
+            result = result.stack()
+        if not len(self.ax):
+            from pandas import Series
+            if self._selected_obj.ndim == 1:
+                name = self._selected_obj.name
+            else:
+                name = None
+            result = Series([], index=result.index, dtype='int64', name=name)
+        return result
+
+    @final
+    @doc(GroupBy.count)
+    def count(self):
+        result = self._downsample('count')
+        if not len(self.ax):
+            if self._selected_obj.ndim == 1:
+                result = type(self._selected_obj)([], index=result.index, dtype='int64', name=self._selected_obj.name)
+            else:
+                from pandas import DataFrame
+                result = DataFrame([], index=result.index, columns=result.columns, dtype='int64')
+        return result
+
+    @final
+    def quantile(self, q: float | list[float] | AnyArrayLike=0.5, **kwargs):
+        return self._downsample('quantile', q=q, **kwargs)
+
+class _GroupByMixin(PandasObject, SelectionMixin):
+    _attributes: list[str]
+    _selection: IndexLabel | None = None
+    _groupby: GroupBy
+    _timegrouper: TimeGrouper
+
+    def __init__(self, *, parent: Resampler, groupby: GroupBy, key=None, selection: IndexLabel | None=None, include_groups: bool=False) -> None:
+        assert isinstance(groupby, GroupBy), type(groupby)
+        assert isinstance(parent, Resampler), type(parent)
+        for attr in self._attributes:
+            setattr(self, attr, getattr(parent, attr))
+        self._selection = selection
+        self.binner = parent.binner
+        self.key = key
+        self._groupby = groupby
+        self._timegrouper = copy.copy(parent._timegrouper)
+        self.ax = parent.ax
+        self.obj = parent.obj
+        self.include_groups = include_groups
+
+    @no_type_check
+    def _apply(self, f, *args, **kwargs):
+
+        def func(x):
+            x = self._resampler_cls(x, timegrouper=self._timegrouper, gpr_index=self.ax)
+            if isinstance(f, str):
+                return getattr(x, f)(**kwargs)
+            return x.apply(f, *args, **kwargs)
+        result = _apply(self._groupby, func, include_groups=self.include_groups)
+        return self._wrap_result(result)
+    _upsample = _apply
+    _downsample = _apply
+    _groupby_and_aggregate = _apply
+
+    @final
+    def _gotitem(self, key, ndim, subset=None):
+        if subset is None:
+            subset = self.obj
+            if key is not None:
+                subset = subset[key]
+            else:
+                assert subset.ndim == 1
+        try:
+            if isinstance(key, list) and self.key not in key and (self.key is not None):
+                key.append(self.key)
+            groupby = self._groupby[key]
+        except IndexError:
+            groupby = self._groupby
+        selection = self._infer_selection(key, subset)
+        new_rs = type(self)(groupby=groupby, parent=cast(Resampler, self), selection=selection)
+        return new_rs
+
+class DatetimeIndexResampler(Resampler):
+    ax: DatetimeIndex
+
+    @property
+    def _resampler_for_grouping(self) -> type[DatetimeIndexResamplerGroupby]:
+        return DatetimeIndexResamplerGroupby
+
+    def _get_binner_for_time(self):
+        if isinstance(self.ax, PeriodIndex):
+            return self._timegrouper._get_time_period_bins(self.ax)
+        return self._timegrouper._get_time_bins(self.ax)
+
+    def _downsample(self, how, **kwargs):
+        ax = self.ax
+        obj = self._obj_with_exclusions
+        if not len(ax):
+            obj = obj.copy()
+            obj.index = obj.index._with_freq(self.freq)
+            assert obj.index.freq == self.freq, (obj.index.freq, self.freq)
+            return obj
+        if (ax.freq is not None or ax.inferred_freq is not None) and len(self._grouper.binlabels) > len(ax) and (how is None):
+            return self.asfreq()
+        result = obj.groupby(self._grouper).aggregate(how, **kwargs)
+        return self._wrap_result(result)
+
+    def _adjust_binner_for_upsample(self, binner):
+        if self.closed == 'right':
+            binner = binner[1:]
+        else:
+            binner = binner[:-1]
+        return binner
+
+    def _upsample(self, method, limit: int | None=None, fill_value=None):
+        if self._from_selection:
+            raise ValueError('Upsampling from level= or on= selection is not supported, use .set_index(...) to explicitly set index to datetime-like')
+        ax = self.ax
+        obj = self._selected_obj
+        binner = self.binner
+        res_index = self._adjust_binner_for_upsample(binner)
+        if limit is None and to_offset(ax.inferred_freq) == self.freq and (len(obj) == len(res_index)):
+            result = obj.copy()
+            result.index = res_index
+        else:
+            if method == 'asfreq':
+                method = None
+            result = obj.reindex(res_index, method=method, limit=limit, fill_value=fill_value)
+        return self._wrap_result(result)
+
+    def _wrap_result(self, result):
+        result = super()._wrap_result(result)
+        if isinstance(self.ax, PeriodIndex) and (not isinstance(result.index, PeriodIndex)):
+            if isinstance(result.index, MultiIndex):
+                if not isinstance(result.index.levels[-1], PeriodIndex):
+                    new_level = result.index.levels[-1].to_period(self.freq)
+                    result.index = result.index.set_levels(new_level, level=-1)
+            else:
+                result.index = result.index.to_period(self.freq)
+        return result
+
+class DatetimeIndexResamplerGroupby(_GroupByMixin, DatetimeIndexResampler):
+
+    @property
+    def _resampler_cls(self):
+        return DatetimeIndexResampler
+
+class PeriodIndexResampler(DatetimeIndexResampler):
+    ax: PeriodIndex
+
+    @property
+    def _resampler_for_grouping(self):
+        warnings.warn('Resampling a groupby with a PeriodIndex is deprecated. Cast to DatetimeIndex before resampling instead.', FutureWarning, stacklevel=find_stack_level())
+        return PeriodIndexResamplerGroupby
+
+    def _get_binner_for_time(self):
+        if isinstance(self.ax, DatetimeIndex):
+            return super()._get_binner_for_time()
+        return self._timegrouper._get_period_bins(self.ax)
+
+    def _convert_obj(self, obj: NDFrameT) -> NDFrameT:
+        obj = super()._convert_obj(obj)
+        if self._from_selection:
+            msg = 'Resampling from level= or on= selection with a PeriodIndex is not currently supported, use .set_index(...) to explicitly set index'
+            raise NotImplementedError(msg)
+        if isinstance(obj, DatetimeIndex):
+            obj = obj.to_timestamp(how=self.convention)
+        return obj
+
+    def _downsample(self, how, **kwargs):
+        if isinstance(self.ax, DatetimeIndex):
+            return super()._downsample(how, **kwargs)
+        ax = self.ax
+        if is_subperiod(ax.freq, self.freq):
+            return self._groupby_and_aggregate(how, **kwargs)
+        elif is_superperiod(ax.freq, self.freq):
+            if how == 'ohlc':
+                return self._groupby_and_aggregate(how)
+            return self.asfreq()
+        elif ax.freq == self.freq:
+            return self.asfreq()
+        raise IncompatibleFrequency(f'Frequency {ax.freq} cannot be resampled to {self.freq}, as they are not sub or super periods')
+
+    def _upsample(self, method, limit: int | None=None, fill_value=None):
+        if isinstance(self.ax, DatetimeIndex):
+            return super()._upsample(method, limit=limit, fill_value=fill_value)
+        ax = self.ax
+        obj = self.obj
+        new_index = self.binner
+        memb = ax.asfreq(self.freq, how=self.convention)
+        if method == 'asfreq':
+            method = None
+        indexer = memb.get_indexer(new_index, method=method, limit=limit)
+        new_obj = _take_new_index(obj, indexer, new_index)
+        return self._wrap_result(new_obj)
+
+class PeriodIndexResamplerGroupby(_GroupByMixin, PeriodIndexResampler):
+
+    @property
+    def _resampler_cls(self):
+        return PeriodIndexResampler
+
+class TimedeltaIndexResampler(DatetimeIndexResampler):
+    ax: TimedeltaIndex
+
+    @property
+    def _resampler_for_grouping(self):
+        return TimedeltaIndexResamplerGroupby
+
+    def _get_binner_for_time(self):
+        return self._timegrouper._get_time_delta_bins(self.ax)
+
+    def _adjust_binner_for_upsample(self, binner):
+        return binner
+
+class TimedeltaIndexResamplerGroupby(_GroupByMixin, TimedeltaIndexResampler):
+
+    @property
+    def _resampler_cls(self):
+        return TimedeltaIndexResampler
+
+def get_resampler(obj: Series | DataFrame, **kwds) -> Resampler:
+    tg = TimeGrouper(obj, **kwds)
+    return tg._get_resampler(obj)
+get_resampler.__doc__ = Resampler.__doc__
+
+def get_resampler_for_grouping(groupby: GroupBy, rule, how=None, fill_method=None, limit: int | None=None, on=None, include_groups: bool=True, **kwargs) -> Resampler:
+    tg = TimeGrouper(freq=rule, key=on, **kwargs)
+    resampler = tg._get_resampler(groupby.obj)
+    return resampler._get_resampler_for_grouping(groupby=groupby, include_groups=include_groups, key=tg.key)
+
+class TimeGrouper(Grouper):
+    _attributes = Grouper._attributes + ('closed', 'label', 'how', 'convention', 'origin', 'offset')
+    origin: TimeGrouperOrigin
+
+    def __init__(self, obj: Grouper | None=None, freq: Frequency='Min', key: str | None=None, closed: Literal['left', 'right'] | None=None, label: Literal['left', 'right'] | None=None, how: str='mean', fill_method=None, limit: int | None=None, convention: Literal['start', 'end', 'e', 's'] | None=None, origin: Literal['epoch', 'start', 'start_day', 'end', 'end_day'] | TimestampConvertibleTypes='start_day', offset: TimedeltaConvertibleTypes | None=None, group_keys: bool=False, **kwargs) -> None:
+        if label not in {None, 'left', 'right'}:
+            raise ValueError(f'Unsupported value {label} for `label`')
+        if closed not in {None, 'left', 'right'}:
+            raise ValueError(f'Unsupported value {closed} for `closed`')
+        if convention not in {None, 'start', 'end', 'e', 's'}:
+            raise ValueError(f'Unsupported value {convention} for `convention`')
+        if key is None and obj is not None and isinstance(obj.index, PeriodIndex) or (key is not None and obj is not None and (getattr(obj[key], 'dtype', None) == 'period')):
+            freq = to_offset(freq, is_period=True)
+        else:
+            freq = to_offset(freq)
+        end_types = {'ME', 'YE', 'QE', 'BME', 'BYE', 'BQE', 'W'}
+        rule = freq.rule_code
+        if rule in end_types or ('-' in rule and rule[:rule.find('-')] in end_types):
+            if closed is None:
+                closed = 'right'
+            if label is None:
+                label = 'right'
+        elif origin in ['end', 'end_day']:
+            if closed is None:
+                closed = 'right'
+            if label is None:
+                label = 'right'
+        else:
+            if closed is None:
+                closed = 'left'
+            if label is None:
+                label = 'left'
+        self.closed = closed
+        self.label = label
+        self.convention = convention if convention is not None else 'e'
+        self.how = how
+        self.fill_method = fill_method
+        self.limit = limit
+        self.group_keys = group_keys
+        self._arrow_dtype: ArrowDtype | None = None
+        if origin in ('epoch', 'start', 'start_day', 'end', 'end_day'):
+            self.origin = origin
+        else:
+            try:
+                self.origin = Timestamp(origin)
+            except (ValueError, TypeError) as err:
+                raise ValueError(f"'origin' should be equal to 'epoch', 'start', 'start_day', 'end', 'end_day' or should be a Timestamp convertible type. Got '{origin}' instead.") from err
+        try:
+            self.offset = Timedelta(offset) if offset is not None else None
+        except (ValueError, TypeError) as err:
+            raise ValueError(f"'offset' should be a Timedelta convertible type. Got '{offset}' instead.") from err
+        kwargs['sort'] = True
+        super().__init__(freq=freq, key=key, **kwargs)
+
+    def _get_resampler(self, obj: NDFrame) -> Resampler:
+        (_, ax, _) = self._set_grouper(obj, gpr_index=None)
+        if isinstance(ax, DatetimeIndex):
+            return DatetimeIndexResampler(obj, timegrouper=self, group_keys=self.group_keys, gpr_index=ax)
+        elif isinstance(ax, PeriodIndex):
+            if isinstance(ax, PeriodIndex):
+                warnings.warn('Resampling with a PeriodIndex is deprecated. Cast index to DatetimeIndex before resampling instead.', FutureWarning, stacklevel=find_stack_level())
+            return PeriodIndexResampler(obj, timegrouper=self, group_keys=self.group_keys, gpr_index=ax)
+        elif isinstance(ax, TimedeltaIndex):
+            return TimedeltaIndexResampler(obj, timegrouper=self, group_keys=self.group_keys, gpr_index=ax)
+        raise TypeError(f"Only valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, but got an instance of '{type(ax).__name__}'")
+
+    def _get_grouper(self, obj: NDFrameT, validate: bool=True) -> tuple[BinGrouper, NDFrameT]:
+        r = self._get_resampler(obj)
+        return (r._grouper, cast(NDFrameT, r.obj))
+
+    def _get_time_bins(self, ax: DatetimeIndex):
+        if not isinstance(ax, DatetimeIndex):
+            raise TypeError(f'axis must be a DatetimeIndex, but got an instance of {type(ax).__name__}')
+        if len(ax) == 0:
+            binner = labels = DatetimeIndex(data=[], freq=self.freq, name=ax.name, dtype=ax.dtype)
+            return (binner, [], labels)
+        (first, last) = _get_timestamp_range_edges(ax.min(), ax.max(), self.freq, unit=ax.unit, closed=self.closed, origin=self.origin, offset=self.offset)
+        binner = labels = date_range(freq=self.freq, start=first, end=last, tz=ax.tz, name=ax.name, ambiguous=True, nonexistent='shift_forward', unit=ax.unit)
+        ax_values = ax.asi8
+        (binner, bin_edges) = self._adjust_bin_edges(binner, ax_values)
+        bins = lib.generate_bins_dt64(ax_values, bin_edges, self.closed, hasnans=ax.hasnans)
+        if self.closed == 'right':
+            labels = binner
+            if self.label == 'right':
+                labels = labels[1:]
+        elif self.label == 'right':
+            labels = labels[1:]
+        if ax.hasnans:
+            binner = binner.insert(0, NaT)
+            labels = labels.insert(0, NaT)
+        if len(bins) < len(labels):
+            labels = labels[:len(bins)]
+        return (binner, bins, labels)
+
+    def _adjust_bin_edges(self, binner: DatetimeIndex, ax_values: npt.NDArray[np.int64]) -> tuple[DatetimeIndex, npt.NDArray[np.int64]]:
+        if self.freq.name in ('BME', 'ME', 'W') or self.freq.name.split('-')[0] in ('BQE', 'BYE', 'QE', 'YE', 'W'):
+            if self.closed == 'right':
+                edges_dti = binner.tz_localize(None)
+                edges_dti = edges_dti + Timedelta(days=1, unit=edges_dti.unit).as_unit(edges_dti.unit) - Timedelta(1, unit=edges_dti.unit).as_unit(edges_dti.unit)
+                bin_edges = edges_dti.tz_localize(binner.tz).asi8
+            else:
+                bin_edges = binner.asi8
+            if bin_edges[-2] > ax_values.max():
+                bin_edges = bin_edges[:-1]
+                binner = binner[:-1]
+        else:
+            bin_edges = binner.asi8
+        return (binner, bin_edges)
+
+    def _get_time_delta_bins(self, ax: TimedeltaIndex):
+        if not isinstance(ax, TimedeltaIndex):
+            raise TypeError(f'axis must be a TimedeltaIndex, but got an instance of {type(ax).__name__}')
+        if not isinstance(self.freq, Tick):
+            raise ValueError(f"Resampling on a TimedeltaIndex requires fixed-duration `freq`, e.g. '24h' or '3D', not {self.freq}")
+        if not len(ax):
+            binner = labels = TimedeltaIndex(data=[], freq=self.freq, name=ax.name)
+            return (binner, [], labels)
+        (start, end) = (ax.min(), ax.max())
+        if self.closed == 'right':
+            end += self.freq
+        labels = binner = timedelta_range(start=start, end=end, freq=self.freq, name=ax.name)
+        end_stamps = labels
+        if self.closed == 'left':
+            end_stamps += self.freq
+        bins = ax.searchsorted(end_stamps, side=self.closed)
+        if self.offset:
+            labels += self.offset
+        return (binner, bins, labels)
+
+    def _get_time_period_bins(self, ax: DatetimeIndex):
+        if not isinstance(ax, DatetimeIndex):
+            raise TypeError(f'axis must be a DatetimeIndex, but got an instance of {type(ax).__name__}')
+        freq = self.freq
+        if len(ax) == 0:
+            binner = labels = PeriodIndex(data=[], freq=freq, name=ax.name, dtype=ax.dtype)
+            return (binner, [], labels)
+        labels = binner = period_range(start=ax[0], end=ax[-1], freq=freq, name=ax.name)
+        end_stamps = (labels + freq).asfreq(freq, 's').to_timestamp()
+        if ax.tz:
+            end_stamps = end_stamps.tz_localize(ax.tz)
+        bins = ax.searchsorted(end_stamps, side='left')
+        return (binner, bins, labels)
+
+    def _get_period_bins(self, ax: PeriodIndex):
+        if not isinstance(ax, PeriodIndex):
+            raise TypeError(f'axis must be a PeriodIndex, but got an instance of {type(ax).__name__}')
+        memb = ax.asfreq(self.freq, how=self.convention)
+        nat_count = 0
+        if memb.hasnans:
+            nat_count = np.sum(memb._isnan)
+            memb = memb[~memb._isnan]
+        if not len(memb):
+            bins = np.array([], dtype=np.int64)
+            binner = labels = PeriodIndex(data=[], freq=self.freq, name=ax.name)
+            if len(ax) > 0:
+                (binner, bins, labels) = _insert_nat_bin(binner, bins, labels, len(ax))
+            return (binner, bins, labels)
+        freq_mult = self.freq.n
+        start = ax.min().asfreq(self.freq, how=self.convention)
+        end = ax.max().asfreq(self.freq, how='end')
+        bin_shift = 0
+        if isinstance(self.freq, Tick):
+            (p_start, end) = _get_period_range_edges(start, end, self.freq, closed=self.closed, origin=self.origin, offset=self.offset)
+            start_offset = Period(start, self.freq) - Period(p_start, self.freq)
+            bin_shift = start_offset.n % freq_mult
+            start = p_start
+        labels = binner = period_range(start=start, end=end, freq=self.freq, name=ax.name)
+        i8 = memb.asi8
+        expected_bins_count = len(binner) * freq_mult
+        i8_extend = expected_bins_count - (i8[-1] - i8[0])
+        rng = np.arange(i8[0], i8[-1] + i8_extend, freq_mult)
+        rng += freq_mult
+        rng -= bin_shift
+        prng = type(memb._data)(rng, dtype=memb.dtype)
+        bins = memb.searchsorted(prng, side='left')
+        if nat_count > 0:
+            (binner, bins, labels) = _insert_nat_bin(binner, bins, labels, nat_count)
+        return (binner, bins, labels)
+
+    def _set_grouper(self, obj: NDFrameT, sort: bool=False, *, gpr_index: Index | None=None) -> tuple[NDFrameT, Index, npt.NDArray[np.intp] | None]:
+        (obj, ax, indexer) = super()._set_grouper(obj, sort, gpr_index=gpr_index)
+        if isinstance(ax.dtype, ArrowDtype) and ax.dtype.kind in 'Mm':
+            self._arrow_dtype = ax.dtype
+            ax = Index(cast(ArrowExtensionArray, ax.array)._maybe_convert_datelike_array())
+        return (obj, ax, indexer)
+
+@overload
+def _take_new_index(obj: DataFrame, indexer: npt.NDArray[np.intp], new_index: Index) -> DataFrame:
+    ...
+
+@overload
+def _take_new_index(obj: Series, indexer: npt.NDArray[np.intp], new_index: Index) -> Series:
+    ...
+
+def _take_new_index(obj: DataFrame | Series, indexer: npt.NDArray[np.intp], new_index: Index) -> DataFrame | Series:
+    if isinstance(obj, ABCSeries):
+        new_values = algos.take_nd(obj._values, indexer)
+        return obj._constructor(new_values, index=new_index, name=obj.name)
+    elif isinstance(obj, ABCDataFrame):
+        new_mgr = obj._mgr.reindex_indexer(new_axis=new_index, indexer=indexer, axis=1)
+        return obj._constructor_from_mgr(new_mgr, axes=new_mgr.axes)
+    else:
+        raise ValueError("'obj' should be either a Series or a DataFrame")
+
+def _get_timestamp_range_edges(first: Timestamp, last: Timestamp, freq: BaseOffset, unit: str, closed: Literal['right', 'left']='left', origin: TimeGrouperOrigin='start_day', offset: Timedelta | None=None) -> tuple[Timestamp, Timestamp]:
+    if isinstance(freq, Tick):
+        index_tz = first.tz
+        if isinstance(origin, Timestamp) and (origin.tz is None) != (index_tz is None):
+            raise ValueError('The origin must have the same timezone as the index.')
+        if origin == 'epoch':
+            origin = Timestamp('1970-01-01', tz=index_tz)
+        if isinstance(freq, Day):
+            first = first.tz_localize(None)
+            last = last.tz_localize(None)
+            if isinstance(origin, Timestamp):
+                origin = origin.tz_localize(None)
+        (first, last) = _adjust_dates_anchored(first, last, freq, closed=closed, origin=origin, offset=offset, unit=unit)
+        if isinstance(freq, Day):
+            first = first.tz_localize(index_tz)
+            last = last.tz_localize(index_tz, nonexistent='shift_forward')
+    else:
+        first = first.normalize()
+        last = last.normalize()
+        if closed == 'left':
+            first = Timestamp(freq.rollback(first))
+        else:
+            first = Timestamp(first - freq)
+        last = Timestamp(last + freq)
+    return (first, last)
+
+def _get_period_range_edges(first: Period, last: Period, freq: BaseOffset, closed: Literal['right', 'left']='left', origin: TimeGrouperOrigin='start_day', offset: Timedelta | None=None) -> tuple[Period, Period]:
+    if not all((isinstance(obj, Period) for obj in [first, last])):
+        raise TypeError("'first' and 'last' must be instances of type Period")
+    first_ts = first.to_timestamp()
+    last_ts = last.to_timestamp()
+    adjust_first = not freq.is_on_offset(first_ts)
+    adjust_last = freq.is_on_offset(last_ts)
+    (first_ts, last_ts) = _get_timestamp_range_edges(first_ts, last_ts, freq, unit='ns', closed=closed, origin=origin, offset=offset)
+    first = (first_ts + int(adjust_first) * freq).to_period(freq)
+    last = (last_ts - int(adjust_last) * freq).to_period(freq)
+    return (first, last)
+
+def _insert_nat_bin(binner: PeriodIndex, bins: np.ndarray, labels: PeriodIndex, nat_count: int) -> tuple[PeriodIndex, np.ndarray, PeriodIndex]:
+    assert nat_count > 0
+    bins += nat_count
+    bins = np.insert(bins, 0, nat_count)
+    binner = binner.insert(0, NaT)
+    labels = labels.insert(0, NaT)
+    return (binner, bins, labels)
+
+def _adjust_dates_anchored(first: Timestamp, last: Timestamp, freq: Tick, closed: Literal['right', 'left']='right', origin: TimeGrouperOrigin='start_day', offset: Timedelta | None=None, unit: str='ns') -> tuple[Timestamp, Timestamp]:
+    first = first.as_unit(unit)
+    last = last.as_unit(unit)
+    if offset is not None:
+        offset = offset.as_unit(unit)
+    freq_value = Timedelta(freq).as_unit(unit)._value
+    origin_timestamp = 0
+    if origin == 'start_day':
+        origin_timestamp = first.normalize()._value
+    elif origin == 'start':
+        origin_timestamp = first._value
+    elif isinstance(origin, Timestamp):
+        origin_timestamp = origin.as_unit(unit)._value
+    elif origin in ['end', 'end_day']:
+        origin_last = last if origin == 'end' else last.ceil('D')
+        sub_freq_times = (origin_last._value - first._value) // freq_value
+        if closed == 'left':
+            sub_freq_times += 1
+        first = origin_last - sub_freq_times * freq
+        origin_timestamp = first._value
+    origin_timestamp += offset._value if offset else 0
+    first_tzinfo = first.tzinfo
+    last_tzinfo = last.tzinfo
+    if first_tzinfo is not None:
+        first = first.tz_convert('UTC')
+    if last_tzinfo is not None:
+        last = last.tz_convert('UTC')
+    foffset = (first._value - origin_timestamp) % freq_value
+    loffset = (last._value - origin_timestamp) % freq_value
+    if closed == 'right':
+        if foffset > 0:
+            fresult_int = first._value - foffset
+        else:
+            fresult_int = first._value - freq_value
+        if loffset > 0:
+            lresult_int = last._value + (freq_value - loffset)
+        else:
+            lresult_int = last._value
+    else:
+        if foffset > 0:
+            fresult_int = first._value - foffset
+        else:
+            fresult_int = first._value
+        if loffset > 0:
+            lresult_int = last._value + (freq_value - loffset)
+        else:
+            lresult_int = last._value + freq_value
+    fresult = Timestamp(fresult_int, unit=unit)
+    lresult = Timestamp(lresult_int, unit=unit)
+    if first_tzinfo is not None:
+        fresult = fresult.tz_localize('UTC').tz_convert(first_tzinfo)
+    if last_tzinfo is not None:
+        lresult = lresult.tz_localize('UTC').tz_convert(last_tzinfo)
+    return (fresult, lresult)
+
+def asfreq(obj: NDFrameT, freq, method=None, how=None, normalize: bool=False, fill_value=None) -> NDFrameT:
+    if isinstance(obj.index, PeriodIndex):
+        if method is not None:
+            raise NotImplementedError("'method' argument is not supported")
+        if how is None:
+            how = 'E'
+        if isinstance(freq, BaseOffset):
+            if hasattr(freq, '_period_dtype_code'):
+                freq = PeriodDtype(freq)._freqstr
+        new_obj = obj.copy()
+        new_obj.index = obj.index.asfreq(freq, how=how)
+    elif len(obj.index) == 0:
+        new_obj = obj.copy()
+        new_obj.index = _asfreq_compat(obj.index, freq)
+    else:
+        unit = None
+        if isinstance(obj.index, DatetimeIndex):
+            unit = obj.index.unit
+        dti = date_range(obj.index.min(), obj.index.max(), freq=freq, unit=unit)
+        dti.name = obj.index.name
+        new_obj = obj.reindex(dti, method=method, fill_value=fill_value)
+        if normalize:
+            new_obj.index = new_obj.index.normalize()
+    return new_obj
+
+def _asfreq_compat(index: FreqIndexT, freq) -> FreqIndexT:
+    if len(index) != 0:
+        raise ValueError('Can only set arbitrary freq for empty DatetimeIndex or TimedeltaIndex')
+    if isinstance(index, PeriodIndex):
+        new_index = index.asfreq(freq=freq)
+    elif isinstance(index, DatetimeIndex):
+        new_index = DatetimeIndex([], dtype=index.dtype, freq=freq, name=index.name)
+    elif isinstance(index, TimedeltaIndex):
+        new_index = TimedeltaIndex([], dtype=index.dtype, freq=freq, name=index.name)
+    else:
+        raise TypeError(type(index))
+    return new_index
+
+def _apply(grouped: GroupBy, how: Callable, *args, include_groups: bool, **kwargs) -> DataFrame:
+    target_message = 'DataFrameGroupBy.apply operated on the grouping columns'
+    new_message = _apply_groupings_depr.format('DataFrameGroupBy', 'resample')
+    with rewrite_warning(target_message=target_message, target_category=DeprecationWarning, new_message=new_message):
+        result = grouped.apply(how, *args, include_groups=include_groups, **kwargs)
+    return result
+
+# File: pandas-main/pandas/core/reshape/api.py
+from pandas.core.reshape.concat import concat
+from pandas.core.reshape.encoding import from_dummies, get_dummies
+from pandas.core.reshape.melt import lreshape, melt, wide_to_long
+from pandas.core.reshape.merge import merge, merge_asof, merge_ordered
+from pandas.core.reshape.pivot import crosstab, pivot, pivot_table
+from pandas.core.reshape.tile import cut, qcut
+__all__ = ['concat', 'crosstab', 'cut', 'from_dummies', 'get_dummies', 'lreshape', 'melt', 'merge', 'merge_asof', 'merge_ordered', 'pivot', 'pivot_table', 'qcut', 'wide_to_long']
+
+# File: pandas-main/pandas/core/reshape/concat.py
+""""""
+from __future__ import annotations
+from collections import abc
+import types
+from typing import TYPE_CHECKING, Literal, cast, overload
+import warnings
+import numpy as np
+from pandas._libs import lib
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import is_bool, is_scalar
+from pandas.core.dtypes.concat import concat_compat
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.dtypes.missing import isna
+from pandas.core.arrays.categorical import factorize_from_iterable, factorize_from_iterables
+import pandas.core.common as com
+from pandas.core.indexes.api import Index, MultiIndex, all_indexes_same, default_index, ensure_index, get_objs_combined_axis, get_unanimous_names
+from pandas.core.internals import concatenate_managers
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Iterable, Mapping
+    from pandas._typing import Axis, AxisInt, HashableT
+    from pandas import DataFrame, Series
+
+@overload
+def concat(objs: Iterable[DataFrame] | Mapping[HashableT, DataFrame], *, axis: Literal[0, 'index']=..., join: str=..., ignore_index: bool=..., keys: Iterable[Hashable] | None=..., levels=..., names: list[HashableT] | None=..., verify_integrity: bool=..., sort: bool=..., copy: bool | lib.NoDefault=...) -> DataFrame:
+    ...
+
+@overload
+def concat(objs: Iterable[Series] | Mapping[HashableT, Series], *, axis: Literal[0, 'index']=..., join: str=..., ignore_index: bool=..., keys: Iterable[Hashable] | None=..., levels=..., names: list[HashableT] | None=..., verify_integrity: bool=..., sort: bool=..., copy: bool | lib.NoDefault=...) -> Series:
+    ...
+
+@overload
+def concat(objs: Iterable[Series | DataFrame] | Mapping[HashableT, Series | DataFrame], *, axis: Literal[0, 'index']=..., join: str=..., ignore_index: bool=..., keys: Iterable[Hashable] | None=..., levels=..., names: list[HashableT] | None=..., verify_integrity: bool=..., sort: bool=..., copy: bool | lib.NoDefault=...) -> DataFrame | Series:
+    ...
+
+@overload
+def concat(objs: Iterable[Series | DataFrame] | Mapping[HashableT, Series | DataFrame], *, axis: Literal[1, 'columns'], join: str=..., ignore_index: bool=..., keys: Iterable[Hashable] | None=..., levels=..., names: list[HashableT] | None=..., verify_integrity: bool=..., sort: bool=..., copy: bool | lib.NoDefault=...) -> DataFrame:
+    ...
+
+@overload
+def concat(objs: Iterable[Series | DataFrame] | Mapping[HashableT, Series | DataFrame], *, axis: Axis=..., join: str=..., ignore_index: bool=..., keys: Iterable[Hashable] | None=..., levels=..., names: list[HashableT] | None=..., verify_integrity: bool=..., sort: bool=..., copy: bool | lib.NoDefault=...) -> DataFrame | Series:
+    ...
+
+def concat(objs: Iterable[Series | DataFrame] | Mapping[HashableT, Series | DataFrame], *, axis: Axis=0, join: str='outer', ignore_index: bool=False, keys: Iterable[Hashable] | None=None, levels=None, names: list[HashableT] | None=None, verify_integrity: bool=False, sort: bool=False, copy: bool | lib.NoDefault=lib.no_default) -> DataFrame | Series:
+    if ignore_index and keys is not None:
+        raise ValueError(f'Cannot set ignore_index={ignore_index!r} and specify keys. Either should be used.')
+    if copy is not lib.no_default:
+        warnings.warn('The copy keyword is deprecated and will be removed in a future version. Copy-on-Write is active in pandas since 3.0 which utilizes a lazy copy mechanism that defers copies until necessary. Use .copy() to make an eager copy if necessary.', DeprecationWarning, stacklevel=find_stack_level())
+    if join == 'outer':
+        intersect = False
+    elif join == 'inner':
+        intersect = True
+    else:
+        raise ValueError('Only can inner (intersect) or outer (union) join the other axis')
+    if not is_bool(sort):
+        raise ValueError(f"The 'sort' keyword only accepts boolean values; {sort} was passed.")
+    sort = bool(sort)
+    (objs, keys, ndims) = _clean_keys_and_objs(objs, keys)
+    (sample, objs) = _get_sample_object(objs, ndims, keys, names, levels, intersect)
+    if sample.ndim == 1:
+        from pandas import DataFrame
+        bm_axis = DataFrame._get_axis_number(axis)
+        is_frame = False
+        is_series = True
+    else:
+        bm_axis = sample._get_axis_number(axis)
+        is_frame = True
+        is_series = False
+        bm_axis = sample._get_block_manager_axis(bm_axis)
+    if len(ndims) > 1:
+        objs = _sanitize_mixed_ndim(objs, sample, ignore_index, bm_axis)
+    axis = 1 - bm_axis if is_frame else 0
+    names = names or getattr(keys, 'names', None)
+    return _get_result(objs, is_series, bm_axis, ignore_index, intersect, sort, keys, levels, verify_integrity, names, axis)
+
+def _sanitize_mixed_ndim(objs: list[Series | DataFrame], sample: Series | DataFrame, ignore_index: bool, axis: AxisInt) -> list[Series | DataFrame]:
+    new_objs = []
+    current_column = 0
+    max_ndim = sample.ndim
+    for obj in objs:
+        ndim = obj.ndim
+        if ndim == max_ndim:
+            pass
+        elif ndim != max_ndim - 1:
+            raise ValueError('cannot concatenate unaligned mixed dimensional NDFrame objects')
+        else:
+            name = getattr(obj, 'name', None)
+            if ignore_index or name is None:
+                if axis == 1:
+                    name = 0
+                else:
+                    name = current_column
+                    current_column += 1
+                obj = sample._constructor(obj, copy=False)
+                if isinstance(obj, ABCDataFrame):
+                    obj.columns = range(name, name + 1, 1)
+            else:
+                obj = sample._constructor({name: obj}, copy=False)
+        new_objs.append(obj)
+    return new_objs
+
+def _get_result(objs: list[Series | DataFrame], is_series: bool, bm_axis: AxisInt, ignore_index: bool, intersect: bool, sort: bool, keys: Iterable[Hashable] | None, levels, verify_integrity: bool, names: list[HashableT] | None, axis: AxisInt):
+    cons: Callable[..., DataFrame | Series]
+    sample: DataFrame | Series
+    if is_series:
+        sample = cast('Series', objs[0])
+        if bm_axis == 0:
+            name = com.consensus_name_attr(objs)
+            cons = sample._constructor
+            arrs = [ser._values for ser in objs]
+            res = concat_compat(arrs, axis=0)
+            if ignore_index:
+                new_index: Index = default_index(len(res))
+            else:
+                new_index = _get_concat_axis_series(objs, ignore_index, bm_axis, keys, levels, verify_integrity, names)
+            mgr = type(sample._mgr).from_array(res, index=new_index)
+            result = sample._constructor_from_mgr(mgr, axes=mgr.axes)
+            result._name = name
+            return result.__finalize__(types.SimpleNamespace(objs=objs), method='concat')
+        else:
+            data = dict(enumerate(objs))
+            cons = sample._constructor_expanddim
+            index = get_objs_combined_axis(objs, axis=objs[0]._get_block_manager_axis(0), intersect=intersect, sort=sort)
+            columns = _get_concat_axis_series(objs, ignore_index, bm_axis, keys, levels, verify_integrity, names)
+            df = cons(data, index=index, copy=False)
+            df.columns = columns
+            return df.__finalize__(types.SimpleNamespace(objs=objs), method='concat')
+    else:
+        sample = cast('DataFrame', objs[0])
+        mgrs_indexers = []
+        result_axes = new_axes(objs, bm_axis, intersect, sort, keys, names, axis, levels, verify_integrity, ignore_index)
+        for obj in objs:
+            indexers = {}
+            for (ax, new_labels) in enumerate(result_axes):
+                if ax == bm_axis:
+                    continue
+                obj_labels = obj.axes[1 - ax]
+                if not new_labels.equals(obj_labels):
+                    indexers[ax] = obj_labels.get_indexer(new_labels)
+            mgrs_indexers.append((obj._mgr, indexers))
+        new_data = concatenate_managers(mgrs_indexers, result_axes, concat_axis=bm_axis, copy=False)
+        out = sample._constructor_from_mgr(new_data, axes=new_data.axes)
+        return out.__finalize__(types.SimpleNamespace(objs=objs), method='concat')
+
+def new_axes(objs: list[Series | DataFrame], bm_axis: AxisInt, intersect: bool, sort: bool, keys: Iterable[Hashable] | None, names: list[HashableT] | None, axis: AxisInt, levels, verify_integrity: bool, ignore_index: bool) -> list[Index]:
+    return [_get_concat_axis_dataframe(objs, axis, ignore_index, keys, names, levels, verify_integrity) if i == bm_axis else get_objs_combined_axis(objs, axis=objs[0]._get_block_manager_axis(i), intersect=intersect, sort=sort) for i in range(2)]
+
+def _get_concat_axis_series(objs: list[Series | DataFrame], ignore_index: bool, bm_axis: AxisInt, keys: Iterable[Hashable] | None, levels, verify_integrity: bool, names: list[HashableT] | None) -> Index:
+    if ignore_index:
+        return default_index(len(objs))
+    elif bm_axis == 0:
+        indexes = [x.index for x in objs]
+        if keys is None:
+            if levels is not None:
+                raise ValueError('levels supported only when keys is not None')
+            concat_axis = _concat_indexes(indexes)
+        else:
+            concat_axis = _make_concat_multiindex(indexes, keys, levels, names)
+        if verify_integrity and (not concat_axis.is_unique):
+            overlap = concat_axis[concat_axis.duplicated()].unique()
+            raise ValueError(f'Indexes have overlapping values: {overlap}')
+        return concat_axis
+    elif keys is None:
+        result_names: list[Hashable] = [None] * len(objs)
+        num = 0
+        has_names = False
+        for (i, x) in enumerate(objs):
+            if x.ndim != 1:
+                raise TypeError(f"Cannot concatenate type 'Series' with object of type '{type(x).__name__}'")
+            if x.name is not None:
+                result_names[i] = x.name
+                has_names = True
+            else:
+                result_names[i] = num
+                num += 1
+        if has_names:
+            return Index(result_names)
+        else:
+            return default_index(len(objs))
+    else:
+        return ensure_index(keys).set_names(names)
+
+def _get_concat_axis_dataframe(objs: list[Series | DataFrame], axis: AxisInt, ignore_index: bool, keys: Iterable[Hashable] | None, names: list[HashableT] | None, levels, verify_integrity: bool) -> Index:
+    indexes_gen = (x.axes[axis] for x in objs)
+    if ignore_index:
+        return default_index(sum((len(i) for i in indexes_gen)))
+    else:
+        indexes = list(indexes_gen)
+    if keys is None:
+        if levels is not None:
+            raise ValueError('levels supported only when keys is not None')
+        concat_axis = _concat_indexes(indexes)
+    else:
+        concat_axis = _make_concat_multiindex(indexes, keys, levels, names)
+    if verify_integrity and (not concat_axis.is_unique):
+        overlap = concat_axis[concat_axis.duplicated()].unique()
+        raise ValueError(f'Indexes have overlapping values: {overlap}')
+    return concat_axis
+
+def _clean_keys_and_objs(objs: Iterable[Series | DataFrame] | Mapping[HashableT, Series | DataFrame], keys) -> tuple[list[Series | DataFrame], Index | None, set[int]]:
+    if isinstance(objs, abc.Mapping):
+        if keys is None:
+            keys = objs.keys()
+        objs = [objs[k] for k in keys]
+    elif isinstance(objs, (ABCSeries, ABCDataFrame)) or is_scalar(objs):
+        raise TypeError(f'first argument must be an iterable of pandas objects, you passed an object of type "{type(objs).__name__}"')
+    elif not isinstance(objs, abc.Sized):
+        objs = list(objs)
+    if len(objs) == 0:
+        raise ValueError('No objects to concatenate')
+    if keys is not None:
+        if not isinstance(keys, Index):
+            keys = Index(keys)
+        if len(keys) != len(objs):
+            raise ValueError(f'The length of the keys ({len(keys)}) must match the length of the objects to concatenate ({len(objs)})')
+    key_indices = []
+    clean_objs = []
+    ndims = set()
+    for (i, obj) in enumerate(objs):
+        if obj is None:
+            continue
+        elif isinstance(obj, (ABCSeries, ABCDataFrame)):
+            key_indices.append(i)
+            clean_objs.append(obj)
+            ndims.add(obj.ndim)
+        else:
+            msg = f"cannot concatenate object of type '{type(obj)}'; only Series and DataFrame objs are valid"
+            raise TypeError(msg)
+    if keys is not None and len(key_indices) < len(keys):
+        keys = keys.take(key_indices)
+    if len(clean_objs) == 0:
+        raise ValueError('All objects passed were None')
+    return (clean_objs, keys, ndims)
+
+def _get_sample_object(objs: list[Series | DataFrame], ndims: set[int], keys, names, levels, intersect: bool) -> tuple[Series | DataFrame, list[Series | DataFrame]]:
+    if len(ndims) > 1:
+        max_ndim = max(ndims)
+        for obj in objs:
+            if obj.ndim == max_ndim and sum(obj.shape):
+                return (obj, objs)
+    elif keys is None and names is None and (levels is None) and (not intersect):
+        if ndims.pop() == 2:
+            non_empties = [obj for obj in objs if sum(obj.shape)]
+        else:
+            non_empties = objs
+        if len(non_empties):
+            return (non_empties[0], non_empties)
+    return (objs[0], objs)
+
+def _concat_indexes(indexes) -> Index:
+    return indexes[0].append(indexes[1:])
+
+def validate_unique_levels(levels: list[Index]) -> None:
+    for level in levels:
+        if not level.is_unique:
+            raise ValueError(f'Level values not unique: {level.tolist()}')
+
+def _make_concat_multiindex(indexes, keys, levels=None, names=None) -> MultiIndex:
+    if levels is None and isinstance(keys[0], tuple) or (levels is not None and len(levels) > 1):
+        zipped = list(zip(*keys))
+        if names is None:
+            names = [None] * len(zipped)
+        if levels is None:
+            (_, levels) = factorize_from_iterables(zipped)
+        else:
+            levels = [ensure_index(x) for x in levels]
+            validate_unique_levels(levels)
+    else:
+        zipped = [keys]
+        if names is None:
+            names = [None]
+        if levels is None:
+            levels = [ensure_index(keys).unique()]
+        else:
+            levels = [ensure_index(x) for x in levels]
+            validate_unique_levels(levels)
+    if not all_indexes_same(indexes):
+        codes_list = []
+        for (hlevel, level) in zip(zipped, levels):
+            to_concat = []
+            if isinstance(hlevel, Index) and hlevel.equals(level):
+                lens = [len(idx) for idx in indexes]
+                codes_list.append(np.repeat(np.arange(len(hlevel)), lens))
+            else:
+                for (key, index) in zip(hlevel, indexes):
+                    mask = isna(level) & isna(key) | (level == key)
+                    if not mask.any():
+                        raise ValueError(f'Key {key} not in level {level}')
+                    i = np.nonzero(mask)[0][0]
+                    to_concat.append(np.repeat(i, len(index)))
+                codes_list.append(np.concatenate(to_concat))
+        concat_index = _concat_indexes(indexes)
+        if isinstance(concat_index, MultiIndex):
+            levels.extend(concat_index.levels)
+            codes_list.extend(concat_index.codes)
+        else:
+            (codes, categories) = factorize_from_iterable(concat_index)
+            levels.append(categories)
+            codes_list.append(codes)
+        if len(names) == len(levels):
+            names = list(names)
+        else:
+            if not len({idx.nlevels for idx in indexes}) == 1:
+                raise AssertionError('Cannot concat indices that do not have the same number of levels')
+            names = list(names) + list(get_unanimous_names(*indexes))
+        return MultiIndex(levels=levels, codes=codes_list, names=names, verify_integrity=False)
+    new_index = indexes[0]
+    n = len(new_index)
+    kpieces = len(indexes)
+    new_names = list(names)
+    new_levels = list(levels)
+    new_codes = []
+    for (hlevel, level) in zip(zipped, levels):
+        hlevel_index = ensure_index(hlevel)
+        mapped = level.get_indexer(hlevel_index)
+        mask = mapped == -1
+        if mask.any():
+            raise ValueError(f'Values not found in passed level: {hlevel_index[mask]!s}')
+        new_codes.append(np.repeat(mapped, n))
+    if isinstance(new_index, MultiIndex):
+        new_levels.extend(new_index.levels)
+        new_codes.extend((np.tile(lab, kpieces) for lab in new_index.codes))
+    else:
+        new_levels.append(new_index.unique())
+        single_codes = new_index.unique().get_indexer(new_index)
+        new_codes.append(np.tile(single_codes, kpieces))
+    if len(new_names) < len(new_levels):
+        new_names.extend(new_index.names)
+    return MultiIndex(levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False)
+
+# File: pandas-main/pandas/core/reshape/encoding.py
+from __future__ import annotations
+from collections import defaultdict
+from collections.abc import Hashable, Iterable
+import itertools
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs import missing as libmissing
+from pandas._libs.sparse import IntIndex
+from pandas.core.dtypes.common import is_integer_dtype, is_list_like, is_object_dtype, pandas_dtype
+from pandas.core.dtypes.dtypes import ArrowDtype, CategoricalDtype
+from pandas.core.arrays import SparseArray
+from pandas.core.arrays.categorical import factorize_from_iterable
+from pandas.core.arrays.string_ import StringDtype
+from pandas.core.frame import DataFrame
+from pandas.core.indexes.api import Index, default_index
+from pandas.core.series import Series
+if TYPE_CHECKING:
+    from pandas._typing import NpDtype
+
+def get_dummies(data, prefix=None, prefix_sep: str | Iterable[str] | dict[str, str]='_', dummy_na: bool=False, columns=None, sparse: bool=False, drop_first: bool=False, dtype: NpDtype | None=None) -> DataFrame:
+    from pandas.core.reshape.concat import concat
+    dtypes_to_encode = ['object', 'string', 'category']
+    if isinstance(data, DataFrame):
+        if columns is None:
+            data_to_encode = data.select_dtypes(include=dtypes_to_encode)
+        elif not is_list_like(columns):
+            raise TypeError('Input must be a list-like for parameter `columns`')
+        else:
+            data_to_encode = data[columns]
+
+        def check_len(item, name: str) -> None:
+            if is_list_like(item):
+                if not len(item) == data_to_encode.shape[1]:
+                    len_msg = f"Length of '{name}' ({len(item)}) did not match the length of the columns being encoded ({data_to_encode.shape[1]})."
+                    raise ValueError(len_msg)
+        check_len(prefix, 'prefix')
+        check_len(prefix_sep, 'prefix_sep')
+        if isinstance(prefix, str):
+            prefix = itertools.cycle([prefix])
+        if isinstance(prefix, dict):
+            prefix = [prefix[col] for col in data_to_encode.columns]
+        if prefix is None:
+            prefix = data_to_encode.columns
+        if isinstance(prefix_sep, str):
+            prefix_sep = itertools.cycle([prefix_sep])
+        elif isinstance(prefix_sep, dict):
+            prefix_sep = [prefix_sep[col] for col in data_to_encode.columns]
+        with_dummies: list[DataFrame]
+        if data_to_encode.shape == data.shape:
+            with_dummies = []
+        elif columns is not None:
+            with_dummies = [data.drop(columns, axis=1)]
+        else:
+            with_dummies = [data.select_dtypes(exclude=dtypes_to_encode)]
+        for (col, pre, sep) in zip(data_to_encode.items(), prefix, prefix_sep):
+            dummy = _get_dummies_1d(col[1], prefix=pre, prefix_sep=sep, dummy_na=dummy_na, sparse=sparse, drop_first=drop_first, dtype=dtype)
+            with_dummies.append(dummy)
+        result = concat(with_dummies, axis=1)
+    else:
+        result = _get_dummies_1d(data, prefix, prefix_sep, dummy_na, sparse=sparse, drop_first=drop_first, dtype=dtype)
+    return result
+
+def _get_dummies_1d(data, prefix, prefix_sep: str | Iterable[str] | dict[str, str]='_', dummy_na: bool=False, sparse: bool=False, drop_first: bool=False, dtype: NpDtype | None=None) -> DataFrame:
+    from pandas.core.reshape.concat import concat
+    (codes, levels) = factorize_from_iterable(Series(data, copy=False))
+    if dtype is None and hasattr(data, 'dtype'):
+        input_dtype = data.dtype
+        if isinstance(input_dtype, CategoricalDtype):
+            input_dtype = input_dtype.categories.dtype
+        if isinstance(input_dtype, ArrowDtype):
+            import pyarrow as pa
+            dtype = ArrowDtype(pa.bool_())
+        elif isinstance(input_dtype, StringDtype) and input_dtype.na_value is libmissing.NA:
+            dtype = pandas_dtype('boolean')
+        else:
+            dtype = np.dtype(bool)
+    elif dtype is None:
+        dtype = np.dtype(bool)
+    _dtype = pandas_dtype(dtype)
+    if is_object_dtype(_dtype):
+        raise ValueError('dtype=object is not a valid dtype for get_dummies')
+
+    def get_empty_frame(data) -> DataFrame:
+        index: Index | np.ndarray
+        if isinstance(data, Series):
+            index = data.index
+        else:
+            index = default_index(len(data))
+        return DataFrame(index=index)
+    if not dummy_na and len(levels) == 0:
+        return get_empty_frame(data)
+    codes = codes.copy()
+    if dummy_na:
+        codes[codes == -1] = len(levels)
+        levels = levels.insert(len(levels), np.nan)
+    if drop_first and len(levels) == 1:
+        return get_empty_frame(data)
+    number_of_cols = len(levels)
+    if prefix is None:
+        dummy_cols = levels
+    else:
+        dummy_cols = Index([f'{prefix}{prefix_sep}{level}' for level in levels])
+    index: Index | None
+    if isinstance(data, Series):
+        index = data.index
+    else:
+        index = None
+    if sparse:
+        fill_value: bool | float
+        if is_integer_dtype(dtype):
+            fill_value = 0
+        elif dtype == np.dtype(bool):
+            fill_value = False
+        else:
+            fill_value = 0.0
+        sparse_series = []
+        N = len(data)
+        sp_indices: list[list] = [[] for _ in range(len(dummy_cols))]
+        mask = codes != -1
+        codes = codes[mask]
+        n_idx = np.arange(N)[mask]
+        for (ndx, code) in zip(n_idx, codes):
+            sp_indices[code].append(ndx)
+        if drop_first:
+            sp_indices = sp_indices[1:]
+            dummy_cols = dummy_cols[1:]
+        for (col, ixs) in zip(dummy_cols, sp_indices):
+            sarr = SparseArray(np.ones(len(ixs), dtype=dtype), sparse_index=IntIndex(N, ixs), fill_value=fill_value, dtype=dtype)
+            sparse_series.append(Series(data=sarr, index=index, name=col, copy=False))
+        return concat(sparse_series, axis=1)
+    else:
+        shape = (len(codes), number_of_cols)
+        dummy_dtype: NpDtype
+        if isinstance(_dtype, np.dtype):
+            dummy_dtype = _dtype
+        else:
+            dummy_dtype = np.bool_
+        dummy_mat = np.zeros(shape=shape, dtype=dummy_dtype, order='F')
+        dummy_mat[np.arange(len(codes)), codes] = 1
+        if not dummy_na:
+            dummy_mat[codes == -1] = 0
+        if drop_first:
+            dummy_mat = dummy_mat[:, 1:]
+            dummy_cols = dummy_cols[1:]
+        return DataFrame(dummy_mat, index=index, columns=dummy_cols, dtype=_dtype)
+
+def from_dummies(data: DataFrame, sep: None | str=None, default_category: None | Hashable | dict[str, Hashable]=None) -> DataFrame:
+    from pandas.core.reshape.concat import concat
+    if not isinstance(data, DataFrame):
+        raise TypeError(f"Expected 'data' to be a 'DataFrame'; Received 'data' of type: {type(data).__name__}")
+    col_isna_mask = data.isna().any()
+    if col_isna_mask.any():
+        raise ValueError(f"Dummy DataFrame contains NA value in column: '{col_isna_mask.idxmax()}'")
+    try:
+        data_to_decode = data.astype('boolean')
+    except TypeError as err:
+        raise TypeError('Passed DataFrame contains non-dummy data') from err
+    variables_slice = defaultdict(list)
+    if sep is None:
+        variables_slice[''] = list(data.columns)
+    elif isinstance(sep, str):
+        for col in data_to_decode.columns:
+            prefix = col.split(sep)[0]
+            if len(prefix) == len(col):
+                raise ValueError(f'Separator not specified for column: {col}')
+            variables_slice[prefix].append(col)
+    else:
+        raise TypeError(f"Expected 'sep' to be of type 'str' or 'None'; Received 'sep' of type: {type(sep).__name__}")
+    if default_category is not None:
+        if isinstance(default_category, dict):
+            if not len(default_category) == len(variables_slice):
+                len_msg = f"Length of 'default_category' ({len(default_category)}) did not match the length of the columns being encoded ({len(variables_slice)})"
+                raise ValueError(len_msg)
+        elif isinstance(default_category, Hashable):
+            default_category = dict(zip(variables_slice, [default_category] * len(variables_slice)))
+        else:
+            raise TypeError(f"Expected 'default_category' to be of type 'None', 'Hashable', or 'dict'; Received 'default_category' of type: {type(default_category).__name__}")
+    cat_data = {}
+    for (prefix, prefix_slice) in variables_slice.items():
+        if sep is None:
+            cats = prefix_slice.copy()
+        else:
+            cats = [col[len(prefix + sep):] for col in prefix_slice]
+        assigned = data_to_decode.loc[:, prefix_slice].sum(axis=1)
+        if any(assigned > 1):
+            raise ValueError(f'Dummy DataFrame contains multi-assignment(s); First instance in row: {assigned.idxmax()}')
+        if any(assigned == 0):
+            if isinstance(default_category, dict):
+                cats.append(default_category[prefix])
+            else:
+                raise ValueError(f'Dummy DataFrame contains unassigned value(s); First instance in row: {assigned.idxmin()}')
+            data_slice = concat((data_to_decode.loc[:, prefix_slice], assigned == 0), axis=1)
+        else:
+            data_slice = data_to_decode.loc[:, prefix_slice]
+        cats_array = data._constructor_sliced(cats, dtype=data.columns.dtype)
+        true_values = data_slice.idxmax(axis=1)
+        indexer = data_slice.columns.get_indexer_for(true_values)
+        cat_data[prefix] = cats_array.take(indexer).set_axis(data.index)
+    result = DataFrame(cat_data)
+    if sep is not None:
+        result.columns = result.columns.astype(data.columns.dtype)
+    return result
+
+# File: pandas-main/pandas/core/reshape/melt.py
+from __future__ import annotations
+import re
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas.core.dtypes.common import is_iterator, is_list_like
+from pandas.core.dtypes.concat import concat_compat
+from pandas.core.dtypes.missing import notna
+import pandas.core.algorithms as algos
+from pandas.core.indexes.api import MultiIndex
+from pandas.core.reshape.concat import concat
+from pandas.core.tools.numeric import to_numeric
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+    from pandas._typing import AnyArrayLike
+    from pandas import DataFrame
+
+def ensure_list_vars(arg_vars, variable: str, columns) -> list:
+    if arg_vars is not None:
+        if not is_list_like(arg_vars):
+            return [arg_vars]
+        elif isinstance(columns, MultiIndex) and (not isinstance(arg_vars, list)):
+            raise ValueError(f'{variable} must be a list of tuples when columns are a MultiIndex')
+        else:
+            return list(arg_vars)
+    else:
+        return []
+
+def melt(frame: DataFrame, id_vars=None, value_vars=None, var_name=None, value_name: Hashable='value', col_level=None, ignore_index: bool=True) -> DataFrame:
+    if value_name in frame.columns:
+        raise ValueError(f'value_name ({value_name}) cannot match an element in the DataFrame columns.')
+    id_vars = ensure_list_vars(id_vars, 'id_vars', frame.columns)
+    value_vars_was_not_none = value_vars is not None
+    value_vars = ensure_list_vars(value_vars, 'value_vars', frame.columns)
+    if id_vars or value_vars:
+        if col_level is not None:
+            level = frame.columns.get_level_values(col_level)
+        else:
+            level = frame.columns
+        labels = id_vars + value_vars
+        idx = level.get_indexer_for(labels)
+        missing = idx == -1
+        if missing.any():
+            missing_labels = [lab for (lab, not_found) in zip(labels, missing) if not_found]
+            raise KeyError(f'The following id_vars or value_vars are not present in the DataFrame: {missing_labels}')
+        if value_vars_was_not_none:
+            frame = frame.iloc[:, algos.unique(idx)]
+        else:
+            frame = frame.copy(deep=False)
+    else:
+        frame = frame.copy(deep=False)
+    if col_level is not None:
+        frame.columns = frame.columns.get_level_values(col_level)
+    if var_name is None:
+        if isinstance(frame.columns, MultiIndex):
+            if len(frame.columns.names) == len(set(frame.columns.names)):
+                var_name = frame.columns.names
+            else:
+                var_name = [f'variable_{i}' for i in range(len(frame.columns.names))]
+        else:
+            var_name = [frame.columns.name if frame.columns.name is not None else 'variable']
+    elif is_list_like(var_name):
+        if isinstance(frame.columns, MultiIndex):
+            if is_iterator(var_name):
+                var_name = list(var_name)
+            if len(var_name) > len(frame.columns):
+                raise ValueError(f'var_name={var_name!r} has {len(var_name)} items, but the dataframe columns only have {len(frame.columns)} levels.')
+        else:
+            raise ValueError(f'var_name={var_name!r} must be a scalar.')
+    else:
+        var_name = [var_name]
+    (num_rows, K) = frame.shape
+    num_cols_adjusted = K - len(id_vars)
+    mdata: dict[Hashable, AnyArrayLike] = {}
+    for col in id_vars:
+        id_data = frame.pop(col)
+        if not isinstance(id_data.dtype, np.dtype):
+            if num_cols_adjusted > 0:
+                mdata[col] = concat([id_data] * num_cols_adjusted, ignore_index=True)
+            else:
+                mdata[col] = type(id_data)([], name=id_data.name, dtype=id_data.dtype)
+        else:
+            mdata[col] = np.tile(id_data._values, num_cols_adjusted)
+    mcolumns = id_vars + var_name + [value_name]
+    if frame.shape[1] > 0 and (not any((not isinstance(dt, np.dtype) and dt._supports_2d for dt in frame.dtypes))):
+        mdata[value_name] = concat([frame.iloc[:, i] for i in range(frame.shape[1])], ignore_index=True).values
+    else:
+        mdata[value_name] = frame._values.ravel('F')
+    for (i, col) in enumerate(var_name):
+        mdata[col] = frame.columns._get_level_values(i).repeat(num_rows)
+    result = frame._constructor(mdata, columns=mcolumns)
+    if not ignore_index:
+        taker = np.tile(np.arange(len(frame)), num_cols_adjusted)
+        result.index = frame.index.take(taker)
+    return result
+
+def lreshape(data: DataFrame, groups: dict, dropna: bool=True) -> DataFrame:
+    mdata = {}
+    pivot_cols = []
+    all_cols: set[Hashable] = set()
+    K = len(next(iter(groups.values())))
+    for (target, names) in groups.items():
+        if len(names) != K:
+            raise ValueError('All column lists must be same length')
+        to_concat = [data[col]._values for col in names]
+        mdata[target] = concat_compat(to_concat)
+        pivot_cols.append(target)
+        all_cols = all_cols.union(names)
+    id_cols = list(data.columns.difference(all_cols))
+    for col in id_cols:
+        mdata[col] = np.tile(data[col]._values, K)
+    if dropna:
+        mask = np.ones(len(mdata[pivot_cols[0]]), dtype=bool)
+        for c in pivot_cols:
+            mask &= notna(mdata[c])
+        if not mask.all():
+            mdata = {k: v[mask] for (k, v) in mdata.items()}
+    return data._constructor(mdata, columns=id_cols + pivot_cols)
+
+def wide_to_long(df: DataFrame, stubnames, i, j, sep: str='', suffix: str='\\d+') -> DataFrame:
+
+    def get_var_names(df, stub: str, sep: str, suffix: str):
+        regex = f'^{re.escape(stub)}{re.escape(sep)}{suffix}$'
+        return df.columns[df.columns.str.match(regex)]
+
+    def melt_stub(df, stub: str, i, j, value_vars, sep: str):
+        newdf = melt(df, id_vars=i, value_vars=value_vars, value_name=stub.rstrip(sep), var_name=j)
+        newdf[j] = newdf[j].str.replace(re.escape(stub + sep), '', regex=True)
+        try:
+            newdf[j] = to_numeric(newdf[j])
+        except (TypeError, ValueError, OverflowError):
+            pass
+        return newdf.set_index(i + [j])
+    if not is_list_like(stubnames):
+        stubnames = [stubnames]
+    else:
+        stubnames = list(stubnames)
+    if df.columns.isin(stubnames).any():
+        raise ValueError("stubname can't be identical to a column name")
+    if not is_list_like(i):
+        i = [i]
+    else:
+        i = list(i)
+    if df[i].duplicated().any():
+        raise ValueError('the id variables need to uniquely identify each row')
+    _melted = []
+    value_vars_flattened = []
+    for stub in stubnames:
+        value_var = get_var_names(df, stub, sep, suffix)
+        value_vars_flattened.extend(value_var)
+        _melted.append(melt_stub(df, stub, i, j, value_var, sep))
+    melted = concat(_melted, axis=1)
+    id_vars = df.columns.difference(value_vars_flattened)
+    new = df[id_vars]
+    if len(i) == 1:
+        return new.set_index(i).join(melted)
+    else:
+        return new.merge(melted.reset_index(), on=i).set_index(i + [j])
+
+# File: pandas-main/pandas/core/reshape/merge.py
+""""""
+from __future__ import annotations
+from collections.abc import Hashable, Sequence
+import datetime
+from functools import partial
+from typing import TYPE_CHECKING, Literal, cast, final
+import uuid
+import warnings
+import numpy as np
+from pandas._libs import Timedelta, hashtable as libhashtable, join as libjoin, lib
+from pandas._libs.lib import is_range_indexer
+from pandas._typing import AnyArrayLike, ArrayLike, IndexLabel, JoinHow, MergeHow, Shape, Suffixes, npt
+from pandas.errors import MergeError
+from pandas.util._decorators import cache_readonly
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.base import ExtensionDtype
+from pandas.core.dtypes.cast import find_common_type
+from pandas.core.dtypes.common import ensure_int64, ensure_object, is_bool, is_bool_dtype, is_float_dtype, is_integer, is_integer_dtype, is_list_like, is_number, is_numeric_dtype, is_object_dtype, is_string_dtype, needs_i8_conversion
+from pandas.core.dtypes.dtypes import CategoricalDtype, DatetimeTZDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.dtypes.missing import isna, na_value_for_dtype
+from pandas import ArrowDtype, Categorical, Index, MultiIndex, Series
+import pandas.core.algorithms as algos
+from pandas.core.arrays import ArrowExtensionArray, BaseMaskedArray, ExtensionArray
+from pandas.core.arrays.string_ import StringDtype
+import pandas.core.common as com
+from pandas.core.construction import ensure_wrapped_if_datetimelike, extract_array
+from pandas.core.indexes.api import default_index
+from pandas.core.sorting import get_group_index, is_int64_overflow_possible
+if TYPE_CHECKING:
+    from pandas import DataFrame
+    from pandas.core import groupby
+    from pandas.core.arrays import DatetimeArray
+    from pandas.core.indexes.frozen import FrozenList
+_factorizers = {np.int64: libhashtable.Int64Factorizer, np.longlong: libhashtable.Int64Factorizer, np.int32: libhashtable.Int32Factorizer, np.int16: libhashtable.Int16Factorizer, np.int8: libhashtable.Int8Factorizer, np.uint64: libhashtable.UInt64Factorizer, np.uint32: libhashtable.UInt32Factorizer, np.uint16: libhashtable.UInt16Factorizer, np.uint8: libhashtable.UInt8Factorizer, np.bool_: libhashtable.UInt8Factorizer, np.float64: libhashtable.Float64Factorizer, np.float32: libhashtable.Float32Factorizer, np.complex64: libhashtable.Complex64Factorizer, np.complex128: libhashtable.Complex128Factorizer, np.object_: libhashtable.ObjectFactorizer}
+if np.intc is not np.int32:
+    _factorizers[np.intc] = libhashtable.Int64Factorizer
+_known = (np.ndarray, ExtensionArray, Index, ABCSeries)
+
+def merge(left: DataFrame | Series, right: DataFrame | Series, how: MergeHow='inner', on: IndexLabel | AnyArrayLike | None=None, left_on: IndexLabel | AnyArrayLike | None=None, right_on: IndexLabel | AnyArrayLike | None=None, left_index: bool=False, right_index: bool=False, sort: bool=False, suffixes: Suffixes=('_x', '_y'), copy: bool | lib.NoDefault=lib.no_default, indicator: str | bool=False, validate: str | None=None) -> DataFrame:
+    left_df = _validate_operand(left)
+    left._check_copy_deprecation(copy)
+    right_df = _validate_operand(right)
+    if how == 'cross':
+        return _cross_merge(left_df, right_df, on=on, left_on=left_on, right_on=right_on, left_index=left_index, right_index=right_index, sort=sort, suffixes=suffixes, indicator=indicator, validate=validate)
+    else:
+        op = _MergeOperation(left_df, right_df, how=how, on=on, left_on=left_on, right_on=right_on, left_index=left_index, right_index=right_index, sort=sort, suffixes=suffixes, indicator=indicator, validate=validate)
+        return op.get_result()
+
+def _cross_merge(left: DataFrame, right: DataFrame, on: IndexLabel | AnyArrayLike | None=None, left_on: IndexLabel | AnyArrayLike | None=None, right_on: IndexLabel | AnyArrayLike | None=None, left_index: bool=False, right_index: bool=False, sort: bool=False, suffixes: Suffixes=('_x', '_y'), indicator: str | bool=False, validate: str | None=None) -> DataFrame:
+    if left_index or right_index or right_on is not None or (left_on is not None) or (on is not None):
+        raise MergeError('Can not pass on, right_on, left_on or set right_index=True or left_index=True')
+    cross_col = f'_cross_{uuid.uuid4()}'
+    left = left.assign(**{cross_col: 1})
+    right = right.assign(**{cross_col: 1})
+    left_on = right_on = [cross_col]
+    res = merge(left, right, how='inner', on=on, left_on=left_on, right_on=right_on, left_index=left_index, right_index=right_index, sort=sort, suffixes=suffixes, indicator=indicator, validate=validate)
+    del res[cross_col]
+    return res
+
+def _groupby_and_merge(by, left: DataFrame | Series, right: DataFrame | Series, merge_pieces):
+    pieces = []
+    if not isinstance(by, (list, tuple)):
+        by = [by]
+    lby = left.groupby(by, sort=False)
+    rby: groupby.DataFrameGroupBy | groupby.SeriesGroupBy | None = None
+    if all((item in right.columns for item in by)):
+        rby = right.groupby(by, sort=False)
+    for (key, lhs) in lby._grouper.get_iterator(lby._selected_obj):
+        if rby is None:
+            rhs = right
+        else:
+            try:
+                rhs = right.take(rby.indices[key])
+            except KeyError:
+                lcols = lhs.columns.tolist()
+                cols = lcols + [r for r in right.columns if r not in set(lcols)]
+                merged = lhs.reindex(columns=cols)
+                merged.index = range(len(merged))
+                pieces.append(merged)
+                continue
+        merged = merge_pieces(lhs, rhs)
+        merged[by] = key
+        pieces.append(merged)
+    from pandas.core.reshape.concat import concat
+    result = concat(pieces, ignore_index=True)
+    result = result.reindex(columns=pieces[0].columns)
+    return (result, lby)
+
+def merge_ordered(left: DataFrame | Series, right: DataFrame | Series, on: IndexLabel | None=None, left_on: IndexLabel | None=None, right_on: IndexLabel | None=None, left_by=None, right_by=None, fill_method: str | None=None, suffixes: Suffixes=('_x', '_y'), how: JoinHow='outer') -> DataFrame:
+
+    def _merger(x, y) -> DataFrame:
+        op = _OrderedMerge(x, y, on=on, left_on=left_on, right_on=right_on, suffixes=suffixes, fill_method=fill_method, how=how)
+        return op.get_result()
+    if left_by is not None and right_by is not None:
+        raise ValueError('Can only group either left or right frames')
+    if left_by is not None:
+        if isinstance(left_by, str):
+            left_by = [left_by]
+        check = set(left_by).difference(left.columns)
+        if len(check) != 0:
+            raise KeyError(f'{check} not found in left columns')
+        (result, _) = _groupby_and_merge(left_by, left, right, lambda x, y: _merger(x, y))
+    elif right_by is not None:
+        if isinstance(right_by, str):
+            right_by = [right_by]
+        check = set(right_by).difference(right.columns)
+        if len(check) != 0:
+            raise KeyError(f'{check} not found in right columns')
+        (result, _) = _groupby_and_merge(right_by, right, left, lambda x, y: _merger(y, x))
+    else:
+        result = _merger(left, right)
+    return result
+
+def merge_asof(left: DataFrame | Series, right: DataFrame | Series, on: IndexLabel | None=None, left_on: IndexLabel | None=None, right_on: IndexLabel | None=None, left_index: bool=False, right_index: bool=False, by=None, left_by=None, right_by=None, suffixes: Suffixes=('_x', '_y'), tolerance: int | datetime.timedelta | None=None, allow_exact_matches: bool=True, direction: str='backward') -> DataFrame:
+    op = _AsOfMerge(left, right, on=on, left_on=left_on, right_on=right_on, left_index=left_index, right_index=right_index, by=by, left_by=left_by, right_by=right_by, suffixes=suffixes, how='asof', tolerance=tolerance, allow_exact_matches=allow_exact_matches, direction=direction)
+    return op.get_result()
+
+class _MergeOperation:
+    _merge_type = 'merge'
+    how: JoinHow | Literal['asof']
+    on: IndexLabel | None
+    left_on: Sequence[Hashable | AnyArrayLike]
+    right_on: Sequence[Hashable | AnyArrayLike]
+    left_index: bool
+    right_index: bool
+    sort: bool
+    suffixes: Suffixes
+    indicator: str | bool
+    validate: str | None
+    join_names: list[Hashable]
+    right_join_keys: list[ArrayLike]
+    left_join_keys: list[ArrayLike]
+
+    def __init__(self, left: DataFrame | Series, right: DataFrame | Series, how: JoinHow | Literal['asof']='inner', on: IndexLabel | AnyArrayLike | None=None, left_on: IndexLabel | AnyArrayLike | None=None, right_on: IndexLabel | AnyArrayLike | None=None, left_index: bool=False, right_index: bool=False, sort: bool=True, suffixes: Suffixes=('_x', '_y'), indicator: str | bool=False, validate: str | None=None) -> None:
+        _left = _validate_operand(left)
+        _right = _validate_operand(right)
+        self.left = self.orig_left = _left
+        self.right = self.orig_right = _right
+        self.how = how
+        self.on = com.maybe_make_list(on)
+        self.suffixes = suffixes
+        self.sort = sort or how == 'outer'
+        self.left_index = left_index
+        self.right_index = right_index
+        self.indicator = indicator
+        if not is_bool(left_index):
+            raise ValueError(f'left_index parameter must be of type bool, not {type(left_index)}')
+        if not is_bool(right_index):
+            raise ValueError(f'right_index parameter must be of type bool, not {type(right_index)}')
+        if _left.columns.nlevels != _right.columns.nlevels:
+            msg = f'Not allowed to merge between different levels. ({_left.columns.nlevels} levels on the left, {_right.columns.nlevels} on the right)'
+            raise MergeError(msg)
+        merge_type = {'left', 'right', 'inner', 'outer', 'cross', 'asof'}
+        if how not in merge_type:
+            raise ValueError(f"'{how}' is not a valid Merge type: left, right, inner, outer, cross, asof")
+        (self.left_on, self.right_on) = self._validate_left_right_on(left_on, right_on)
+        (self.left_join_keys, self.right_join_keys, self.join_names, left_drop, right_drop) = self._get_merge_keys()
+        if left_drop:
+            self.left = self.left._drop_labels_or_levels(left_drop)
+        if right_drop:
+            self.right = self.right._drop_labels_or_levels(right_drop)
+        self._maybe_require_matching_dtypes(self.left_join_keys, self.right_join_keys)
+        self._validate_tolerance(self.left_join_keys)
+        self._maybe_coerce_merge_keys()
+        if validate is not None:
+            self._validate_validate_kwd(validate)
+
+    def _maybe_require_matching_dtypes(self, left_join_keys: list[ArrayLike], right_join_keys: list[ArrayLike]) -> None:
+        pass
+
+    def _validate_tolerance(self, left_join_keys: list[ArrayLike]) -> None:
+        pass
+
+    @final
+    def _reindex_and_concat(self, join_index: Index, left_indexer: npt.NDArray[np.intp] | None, right_indexer: npt.NDArray[np.intp] | None) -> DataFrame:
+        left = self.left[:]
+        right = self.right[:]
+        (llabels, rlabels) = _items_overlap_with_suffix(self.left._info_axis, self.right._info_axis, self.suffixes)
+        if left_indexer is not None and (not is_range_indexer(left_indexer, len(left))):
+            lmgr = left._mgr.reindex_indexer(join_index, left_indexer, axis=1, only_slice=True, allow_dups=True, use_na_proxy=True)
+            left = left._constructor_from_mgr(lmgr, axes=lmgr.axes)
+        left.index = join_index
+        if right_indexer is not None and (not is_range_indexer(right_indexer, len(right))):
+            rmgr = right._mgr.reindex_indexer(join_index, right_indexer, axis=1, only_slice=True, allow_dups=True, use_na_proxy=True)
+            right = right._constructor_from_mgr(rmgr, axes=rmgr.axes)
+        right.index = join_index
+        from pandas import concat
+        left.columns = llabels
+        right.columns = rlabels
+        result = concat([left, right], axis=1)
+        return result
+
+    def get_result(self) -> DataFrame:
+        if self.indicator:
+            (self.left, self.right) = self._indicator_pre_merge(self.left, self.right)
+        (join_index, left_indexer, right_indexer) = self._get_join_info()
+        result = self._reindex_and_concat(join_index, left_indexer, right_indexer)
+        result = result.__finalize__(self, method=self._merge_type)
+        if self.indicator:
+            result = self._indicator_post_merge(result)
+        self._maybe_add_join_keys(result, left_indexer, right_indexer)
+        self._maybe_restore_index_levels(result)
+        return result.__finalize__(self, method='merge')
+
+    @final
+    @cache_readonly
+    def _indicator_name(self) -> str | None:
+        if isinstance(self.indicator, str):
+            return self.indicator
+        elif isinstance(self.indicator, bool):
+            return '_merge' if self.indicator else None
+        else:
+            raise ValueError('indicator option can only accept boolean or string arguments')
+
+    @final
+    def _indicator_pre_merge(self, left: DataFrame, right: DataFrame) -> tuple[DataFrame, DataFrame]:
+        columns = left.columns.union(right.columns)
+        for i in ['_left_indicator', '_right_indicator']:
+            if i in columns:
+                raise ValueError(f'Cannot use `indicator=True` option when data contains a column named {i}')
+        if self._indicator_name in columns:
+            raise ValueError('Cannot use name of an existing column for indicator column')
+        left = left.copy()
+        right = right.copy()
+        left['_left_indicator'] = 1
+        left['_left_indicator'] = left['_left_indicator'].astype('int8')
+        right['_right_indicator'] = 2
+        right['_right_indicator'] = right['_right_indicator'].astype('int8')
+        return (left, right)
+
+    @final
+    def _indicator_post_merge(self, result: DataFrame) -> DataFrame:
+        result['_left_indicator'] = result['_left_indicator'].fillna(0)
+        result['_right_indicator'] = result['_right_indicator'].fillna(0)
+        result[self._indicator_name] = Categorical(result['_left_indicator'] + result['_right_indicator'], categories=[1, 2, 3])
+        result[self._indicator_name] = result[self._indicator_name].cat.rename_categories(['left_only', 'right_only', 'both'])
+        result = result.drop(labels=['_left_indicator', '_right_indicator'], axis=1)
+        return result
+
+    @final
+    def _maybe_restore_index_levels(self, result: DataFrame) -> None:
+        names_to_restore = []
+        for (name, left_key, right_key) in zip(self.join_names, self.left_on, self.right_on):
+            if self.orig_left._is_level_reference(left_key) and self.orig_right._is_level_reference(right_key) and (left_key == right_key) and (name not in result.index.names):
+                names_to_restore.append(name)
+        if names_to_restore:
+            result.set_index(names_to_restore, inplace=True)
+
+    @final
+    def _maybe_add_join_keys(self, result: DataFrame, left_indexer: npt.NDArray[np.intp] | None, right_indexer: npt.NDArray[np.intp] | None) -> None:
+        left_has_missing = None
+        right_has_missing = None
+        assert all((isinstance(x, _known) for x in self.left_join_keys))
+        keys = zip(self.join_names, self.left_on, self.right_on)
+        for (i, (name, lname, rname)) in enumerate(keys):
+            if not _should_fill(lname, rname):
+                continue
+            (take_left, take_right) = (None, None)
+            if name in result:
+                if left_indexer is not None or right_indexer is not None:
+                    if name in self.left:
+                        if left_has_missing is None:
+                            left_has_missing = False if left_indexer is None else (left_indexer == -1).any()
+                        if left_has_missing:
+                            take_right = self.right_join_keys[i]
+                            if result[name].dtype != self.left[name].dtype:
+                                take_left = self.left[name]._values
+                    elif name in self.right:
+                        if right_has_missing is None:
+                            right_has_missing = False if right_indexer is None else (right_indexer == -1).any()
+                        if right_has_missing:
+                            take_left = self.left_join_keys[i]
+                            if result[name].dtype != self.right[name].dtype:
+                                take_right = self.right[name]._values
+            else:
+                take_left = self.left_join_keys[i]
+                take_right = self.right_join_keys[i]
+            if take_left is not None or take_right is not None:
+                if take_left is None:
+                    lvals = result[name]._values
+                elif left_indexer is None:
+                    lvals = take_left
+                else:
+                    take_left = extract_array(take_left, extract_numpy=True)
+                    lfill = na_value_for_dtype(take_left.dtype)
+                    lvals = algos.take_nd(take_left, left_indexer, fill_value=lfill)
+                if take_right is None:
+                    rvals = result[name]._values
+                elif right_indexer is None:
+                    rvals = take_right
+                else:
+                    taker = extract_array(take_right, extract_numpy=True)
+                    rfill = na_value_for_dtype(taker.dtype)
+                    rvals = algos.take_nd(taker, right_indexer, fill_value=rfill)
+                if left_indexer is not None and (left_indexer == -1).all():
+                    key_col = Index(rvals)
+                    result_dtype = rvals.dtype
+                elif right_indexer is not None and (right_indexer == -1).all():
+                    key_col = Index(lvals)
+                    result_dtype = lvals.dtype
+                else:
+                    key_col = Index(lvals)
+                    if left_indexer is not None:
+                        mask_left = left_indexer == -1
+                        key_col = key_col.where(~mask_left, rvals)
+                    result_dtype = find_common_type([lvals.dtype, rvals.dtype])
+                    if lvals.dtype.kind == 'M' and rvals.dtype.kind == 'M' and (result_dtype.kind == 'O'):
+                        result_dtype = key_col.dtype
+                if result._is_label_reference(name):
+                    result[name] = result._constructor_sliced(key_col, dtype=result_dtype, index=result.index)
+                elif result._is_level_reference(name):
+                    if isinstance(result.index, MultiIndex):
+                        key_col.name = name
+                        idx_list = [result.index.get_level_values(level_name) if level_name != name else key_col for level_name in result.index.names]
+                        result.set_index(idx_list, inplace=True)
+                    else:
+                        result.index = Index(key_col, name=name)
+                else:
+                    result.insert(i, name or f'key_{i}', key_col)
+
+    def _get_join_indexers(self) -> tuple[npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        assert self.how != 'asof'
+        return get_join_indexers(self.left_join_keys, self.right_join_keys, sort=self.sort, how=self.how)
+
+    @final
+    def _get_join_info(self) -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+        left_ax = self.left.index
+        right_ax = self.right.index
+        if self.left_index and self.right_index and (self.how != 'asof'):
+            (join_index, left_indexer, right_indexer) = left_ax.join(right_ax, how=self.how, return_indexers=True, sort=self.sort)
+        elif self.right_index and self.how == 'left':
+            (join_index, left_indexer, right_indexer) = _left_join_on_index(left_ax, right_ax, self.left_join_keys, sort=self.sort)
+        elif self.left_index and self.how == 'right':
+            (join_index, right_indexer, left_indexer) = _left_join_on_index(right_ax, left_ax, self.right_join_keys, sort=self.sort)
+        else:
+            (left_indexer, right_indexer) = self._get_join_indexers()
+            if self.right_index:
+                if len(self.left) > 0:
+                    join_index = self._create_join_index(left_ax, right_ax, left_indexer, how='right')
+                elif right_indexer is None:
+                    join_index = right_ax.copy()
+                else:
+                    join_index = right_ax.take(right_indexer)
+            elif self.left_index:
+                if self.how == 'asof':
+                    join_index = self._create_join_index(left_ax, right_ax, left_indexer, how='left')
+                elif len(self.right) > 0:
+                    join_index = self._create_join_index(right_ax, left_ax, right_indexer, how='left')
+                elif left_indexer is None:
+                    join_index = left_ax.copy()
+                else:
+                    join_index = left_ax.take(left_indexer)
+            else:
+                n = len(left_ax) if left_indexer is None else len(left_indexer)
+                join_index = default_index(n)
+        return (join_index, left_indexer, right_indexer)
+
+    @final
+    def _create_join_index(self, index: Index, other_index: Index, indexer: npt.NDArray[np.intp] | None, how: JoinHow='left') -> Index:
+        if self.how in (how, 'outer') and (not isinstance(other_index, MultiIndex)):
+            mask = indexer == -1
+            if np.any(mask):
+                fill_value = na_value_for_dtype(index.dtype, compat=False)
+                index = index.append(Index([fill_value]))
+        if indexer is None:
+            return index.copy()
+        return index.take(indexer)
+
+    @final
+    def _get_merge_keys(self) -> tuple[list[ArrayLike], list[ArrayLike], list[Hashable], list[Hashable], list[Hashable]]:
+        left_keys: list[ArrayLike] = []
+        right_keys: list[ArrayLike] = []
+        join_names: list[Hashable] = []
+        right_drop: list[Hashable] = []
+        left_drop: list[Hashable] = []
+        (left, right) = (self.left, self.right)
+        is_lkey = lambda x: isinstance(x, _known) and len(x) == len(left)
+        is_rkey = lambda x: isinstance(x, _known) and len(x) == len(right)
+        if _any(self.left_on) and _any(self.right_on):
+            for (lk, rk) in zip(self.left_on, self.right_on):
+                lk = extract_array(lk, extract_numpy=True)
+                rk = extract_array(rk, extract_numpy=True)
+                if is_lkey(lk):
+                    lk = cast(ArrayLike, lk)
+                    left_keys.append(lk)
+                    if is_rkey(rk):
+                        rk = cast(ArrayLike, rk)
+                        right_keys.append(rk)
+                        join_names.append(None)
+                    else:
+                        rk = cast(Hashable, rk)
+                        if rk is not None:
+                            right_keys.append(right._get_label_or_level_values(rk))
+                            join_names.append(rk)
+                        else:
+                            right_keys.append(right.index._values)
+                            join_names.append(right.index.name)
+                else:
+                    if not is_rkey(rk):
+                        rk = cast(Hashable, rk)
+                        if rk is not None:
+                            right_keys.append(right._get_label_or_level_values(rk))
+                        else:
+                            right_keys.append(right.index._values)
+                        if lk is not None and lk == rk:
+                            right_drop.append(rk)
+                    else:
+                        rk = cast(ArrayLike, rk)
+                        right_keys.append(rk)
+                    if lk is not None:
+                        lk = cast(Hashable, lk)
+                        left_keys.append(left._get_label_or_level_values(lk))
+                        join_names.append(lk)
+                    else:
+                        left_keys.append(left.index._values)
+                        join_names.append(left.index.name)
+        elif _any(self.left_on):
+            for k in self.left_on:
+                if is_lkey(k):
+                    k = extract_array(k, extract_numpy=True)
+                    k = cast(ArrayLike, k)
+                    left_keys.append(k)
+                    join_names.append(None)
+                else:
+                    k = cast(Hashable, k)
+                    left_keys.append(left._get_label_or_level_values(k))
+                    join_names.append(k)
+            if isinstance(self.right.index, MultiIndex):
+                right_keys = [lev._values.take(lev_codes) for (lev, lev_codes) in zip(self.right.index.levels, self.right.index.codes)]
+            else:
+                right_keys = [self.right.index._values]
+        elif _any(self.right_on):
+            for k in self.right_on:
+                k = extract_array(k, extract_numpy=True)
+                if is_rkey(k):
+                    k = cast(ArrayLike, k)
+                    right_keys.append(k)
+                    join_names.append(None)
+                else:
+                    k = cast(Hashable, k)
+                    right_keys.append(right._get_label_or_level_values(k))
+                    join_names.append(k)
+            if isinstance(self.left.index, MultiIndex):
+                left_keys = [lev._values.take(lev_codes) for (lev, lev_codes) in zip(self.left.index.levels, self.left.index.codes)]
+            else:
+                left_keys = [self.left.index._values]
+        return (left_keys, right_keys, join_names, left_drop, right_drop)
+
+    @final
+    def _maybe_coerce_merge_keys(self) -> None:
+        for (lk, rk, name) in zip(self.left_join_keys, self.right_join_keys, self.join_names):
+            if len(lk) and (not len(rk)) or (not len(lk) and len(rk)):
+                continue
+            lk = extract_array(lk, extract_numpy=True)
+            rk = extract_array(rk, extract_numpy=True)
+            lk_is_cat = isinstance(lk.dtype, CategoricalDtype)
+            rk_is_cat = isinstance(rk.dtype, CategoricalDtype)
+            lk_is_object_or_string = is_object_dtype(lk.dtype) or is_string_dtype(lk.dtype)
+            rk_is_object_or_string = is_object_dtype(rk.dtype) or is_string_dtype(rk.dtype)
+            if lk_is_cat and rk_is_cat:
+                lk = cast(Categorical, lk)
+                rk = cast(Categorical, rk)
+                if lk._categories_match_up_to_permutation(rk):
+                    continue
+            elif lk_is_cat or rk_is_cat:
+                pass
+            elif lk.dtype == rk.dtype:
+                continue
+            msg = f"You are trying to merge on {lk.dtype} and {rk.dtype} columns for key '{name}'. If you wish to proceed you should use pd.concat"
+            if is_numeric_dtype(lk.dtype) and is_numeric_dtype(rk.dtype):
+                if lk.dtype.kind == rk.dtype.kind:
+                    continue
+                if isinstance(lk.dtype, ExtensionDtype) and (not isinstance(rk.dtype, ExtensionDtype)):
+                    ct = find_common_type([lk.dtype, rk.dtype])
+                    if isinstance(ct, ExtensionDtype):
+                        com_cls = ct.construct_array_type()
+                        rk = com_cls._from_sequence(rk, dtype=ct, copy=False)
+                    else:
+                        rk = rk.astype(ct)
+                elif isinstance(rk.dtype, ExtensionDtype):
+                    ct = find_common_type([lk.dtype, rk.dtype])
+                    if isinstance(ct, ExtensionDtype):
+                        com_cls = ct.construct_array_type()
+                        lk = com_cls._from_sequence(lk, dtype=ct, copy=False)
+                    else:
+                        lk = lk.astype(ct)
+                if is_integer_dtype(rk.dtype) and is_float_dtype(lk.dtype):
+                    with np.errstate(invalid='ignore'):
+                        casted = lk.astype(rk.dtype)
+                    mask = ~np.isnan(lk)
+                    match = lk == casted
+                    if not match[mask].all():
+                        warnings.warn('You are merging on int and float columns where the float values are not equal to their int representation.', UserWarning, stacklevel=find_stack_level())
+                    continue
+                if is_float_dtype(rk.dtype) and is_integer_dtype(lk.dtype):
+                    with np.errstate(invalid='ignore'):
+                        casted = rk.astype(lk.dtype)
+                    mask = ~np.isnan(rk)
+                    match = rk == casted
+                    if not match[mask].all():
+                        warnings.warn('You are merging on int and float columns where the float values are not equal to their int representation.', UserWarning, stacklevel=find_stack_level())
+                    continue
+                if lib.infer_dtype(lk, skipna=False) == lib.infer_dtype(rk, skipna=False):
+                    continue
+            elif lk_is_object_or_string and is_bool_dtype(rk.dtype) or (is_bool_dtype(lk.dtype) and rk_is_object_or_string):
+                pass
+            elif lk_is_object_or_string and is_numeric_dtype(rk.dtype) or (is_numeric_dtype(lk.dtype) and rk_is_object_or_string):
+                inferred_left = lib.infer_dtype(lk, skipna=False)
+                inferred_right = lib.infer_dtype(rk, skipna=False)
+                bool_types = ['integer', 'mixed-integer', 'boolean', 'empty']
+                string_types = ['string', 'unicode', 'mixed', 'bytes', 'empty']
+                if inferred_left in bool_types and inferred_right in bool_types:
+                    pass
+                elif inferred_left in string_types and inferred_right not in string_types or (inferred_right in string_types and inferred_left not in string_types):
+                    raise ValueError(msg)
+            elif needs_i8_conversion(lk.dtype) and (not needs_i8_conversion(rk.dtype)):
+                raise ValueError(msg)
+            elif not needs_i8_conversion(lk.dtype) and needs_i8_conversion(rk.dtype):
+                raise ValueError(msg)
+            elif isinstance(lk.dtype, DatetimeTZDtype) and (not isinstance(rk.dtype, DatetimeTZDtype)):
+                raise ValueError(msg)
+            elif not isinstance(lk.dtype, DatetimeTZDtype) and isinstance(rk.dtype, DatetimeTZDtype):
+                raise ValueError(msg)
+            elif isinstance(lk.dtype, DatetimeTZDtype) and isinstance(rk.dtype, DatetimeTZDtype) or (lk.dtype.kind == 'M' and rk.dtype.kind == 'M'):
+                continue
+            elif lk.dtype.kind == 'M' and rk.dtype.kind == 'm':
+                raise ValueError(msg)
+            elif lk.dtype.kind == 'm' and rk.dtype.kind == 'M':
+                raise ValueError(msg)
+            elif is_object_dtype(lk.dtype) and is_object_dtype(rk.dtype):
+                continue
+            if name in self.left.columns:
+                typ = cast(Categorical, lk).categories.dtype if lk_is_cat else object
+                self.left = self.left.copy()
+                self.left[name] = self.left[name].astype(typ)
+            if name in self.right.columns:
+                typ = cast(Categorical, rk).categories.dtype if rk_is_cat else object
+                self.right = self.right.copy()
+                self.right[name] = self.right[name].astype(typ)
+
+    def _validate_left_right_on(self, left_on, right_on):
+        left_on = com.maybe_make_list(left_on)
+        right_on = com.maybe_make_list(right_on)
+        if self.on is None and left_on is None and (right_on is None):
+            if self.left_index and self.right_index:
+                (left_on, right_on) = ((), ())
+            elif self.left_index:
+                raise MergeError('Must pass right_on or right_index=True')
+            elif self.right_index:
+                raise MergeError('Must pass left_on or left_index=True')
+            else:
+                left_cols = self.left.columns
+                right_cols = self.right.columns
+                common_cols = left_cols.intersection(right_cols)
+                if len(common_cols) == 0:
+                    raise MergeError(f'No common columns to perform merge on. Merge options: left_on={left_on}, right_on={right_on}, left_index={self.left_index}, right_index={self.right_index}')
+                if not left_cols.join(common_cols, how='inner').is_unique or not right_cols.join(common_cols, how='inner').is_unique:
+                    raise MergeError(f'Data columns not unique: {common_cols!r}')
+                left_on = right_on = common_cols
+        elif self.on is not None:
+            if left_on is not None or right_on is not None:
+                raise MergeError('Can only pass argument "on" OR "left_on" and "right_on", not a combination of both.')
+            if self.left_index or self.right_index:
+                raise MergeError('Can only pass argument "on" OR "left_index" and "right_index", not a combination of both.')
+            left_on = right_on = self.on
+        elif left_on is not None:
+            if self.left_index:
+                raise MergeError('Can only pass argument "left_on" OR "left_index" not both.')
+            if not self.right_index and right_on is None:
+                raise MergeError('Must pass "right_on" OR "right_index".')
+            n = len(left_on)
+            if self.right_index:
+                if len(left_on) != self.right.index.nlevels:
+                    raise ValueError('len(left_on) must equal the number of levels in the index of "right"')
+                right_on = [None] * n
+        elif right_on is not None:
+            if self.right_index:
+                raise MergeError('Can only pass argument "right_on" OR "right_index" not both.')
+            if not self.left_index and left_on is None:
+                raise MergeError('Must pass "left_on" OR "left_index".')
+            n = len(right_on)
+            if self.left_index:
+                if len(right_on) != self.left.index.nlevels:
+                    raise ValueError('len(right_on) must equal the number of levels in the index of "left"')
+                left_on = [None] * n
+        if len(right_on) != len(left_on):
+            raise ValueError('len(right_on) must equal len(left_on)')
+        return (left_on, right_on)
+
+    @final
+    def _validate_validate_kwd(self, validate: str) -> None:
+        if self.left_index:
+            left_unique = self.orig_left.index.is_unique
+        else:
+            left_unique = MultiIndex.from_arrays(self.left_join_keys).is_unique
+        if self.right_index:
+            right_unique = self.orig_right.index.is_unique
+        else:
+            right_unique = MultiIndex.from_arrays(self.right_join_keys).is_unique
+        if validate in ['one_to_one', '1:1']:
+            if not left_unique and (not right_unique):
+                raise MergeError('Merge keys are not unique in either left or right dataset; not a one-to-one merge')
+            if not left_unique:
+                raise MergeError('Merge keys are not unique in left dataset; not a one-to-one merge')
+            if not right_unique:
+                raise MergeError('Merge keys are not unique in right dataset; not a one-to-one merge')
+        elif validate in ['one_to_many', '1:m']:
+            if not left_unique:
+                raise MergeError('Merge keys are not unique in left dataset; not a one-to-many merge')
+        elif validate in ['many_to_one', 'm:1']:
+            if not right_unique:
+                raise MergeError('Merge keys are not unique in right dataset; not a many-to-one merge')
+        elif validate in ['many_to_many', 'm:m']:
+            pass
+        else:
+            raise ValueError(f'"{validate}" is not a valid argument. Valid arguments are:\n- "1:1"\n- "1:m"\n- "m:1"\n- "m:m"\n- "one_to_one"\n- "one_to_many"\n- "many_to_one"\n- "many_to_many"')
+
+def get_join_indexers(left_keys: list[ArrayLike], right_keys: list[ArrayLike], sort: bool=False, how: JoinHow='inner') -> tuple[npt.NDArray[np.intp] | None, npt.NDArray[np.intp] | None]:
+    assert len(left_keys) == len(right_keys), 'left_keys and right_keys must be the same length'
+    left_n = len(left_keys[0])
+    right_n = len(right_keys[0])
+    if left_n == 0:
+        if how in ['left', 'inner']:
+            return _get_empty_indexer()
+        elif not sort and how in ['right', 'outer']:
+            return _get_no_sort_one_missing_indexer(right_n, True)
+    elif right_n == 0:
+        if how in ['right', 'inner']:
+            return _get_empty_indexer()
+        elif not sort and how in ['left', 'outer']:
+            return _get_no_sort_one_missing_indexer(left_n, False)
+    lkey: ArrayLike
+    rkey: ArrayLike
+    if len(left_keys) > 1:
+        mapped = (_factorize_keys(left_keys[n], right_keys[n], sort=sort) for n in range(len(left_keys)))
+        zipped = zip(*mapped)
+        (llab, rlab, shape) = (list(x) for x in zipped)
+        (lkey, rkey) = _get_join_keys(llab, rlab, tuple(shape), sort)
+    else:
+        lkey = left_keys[0]
+        rkey = right_keys[0]
+    left = Index(lkey)
+    right = Index(rkey)
+    if left.is_monotonic_increasing and right.is_monotonic_increasing and (left.is_unique or right.is_unique):
+        (_, lidx, ridx) = left.join(right, how=how, return_indexers=True, sort=sort)
+    else:
+        (lidx, ridx) = get_join_indexers_non_unique(left._values, right._values, sort, how)
+    if lidx is not None and is_range_indexer(lidx, len(left)):
+        lidx = None
+    if ridx is not None and is_range_indexer(ridx, len(right)):
+        ridx = None
+    return (lidx, ridx)
+
+def get_join_indexers_non_unique(left: ArrayLike, right: ArrayLike, sort: bool=False, how: JoinHow='inner') -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+    (lkey, rkey, count) = _factorize_keys(left, right, sort=sort, how=how)
+    if count == -1:
+        return (lkey, rkey)
+    if how == 'left':
+        (lidx, ridx) = libjoin.left_outer_join(lkey, rkey, count, sort=sort)
+    elif how == 'right':
+        (ridx, lidx) = libjoin.left_outer_join(rkey, lkey, count, sort=sort)
+    elif how == 'inner':
+        (lidx, ridx) = libjoin.inner_join(lkey, rkey, count, sort=sort)
+    elif how == 'outer':
+        (lidx, ridx) = libjoin.full_outer_join(lkey, rkey, count)
+    return (lidx, ridx)
+
+def restore_dropped_levels_multijoin(left: MultiIndex, right: MultiIndex, dropped_level_names, join_index: Index, lindexer: npt.NDArray[np.intp], rindexer: npt.NDArray[np.intp]) -> tuple[FrozenList, FrozenList, FrozenList]:
+
+    def _convert_to_multiindex(index: Index) -> MultiIndex:
+        if isinstance(index, MultiIndex):
+            return index
+        else:
+            return MultiIndex.from_arrays([index._values], names=[index.name])
+    join_index = _convert_to_multiindex(join_index)
+    join_levels = join_index.levels
+    join_codes = join_index.codes
+    join_names = join_index.names
+    for dropped_level_name in dropped_level_names:
+        if dropped_level_name in left.names:
+            idx = left
+            indexer = lindexer
+        else:
+            idx = right
+            indexer = rindexer
+        name_idx = idx.names.index(dropped_level_name)
+        restore_levels = idx.levels[name_idx]
+        codes = idx.codes[name_idx]
+        if indexer is None:
+            restore_codes = codes
+        else:
+            restore_codes = algos.take_nd(codes, indexer, fill_value=-1)
+        join_levels = join_levels + [restore_levels]
+        join_codes = join_codes + [restore_codes]
+        join_names = join_names + [dropped_level_name]
+    return (join_levels, join_codes, join_names)
+
+class _OrderedMerge(_MergeOperation):
+    _merge_type = 'ordered_merge'
+
+    def __init__(self, left: DataFrame | Series, right: DataFrame | Series, on: IndexLabel | None=None, left_on: IndexLabel | None=None, right_on: IndexLabel | None=None, left_index: bool=False, right_index: bool=False, suffixes: Suffixes=('_x', '_y'), fill_method: str | None=None, how: JoinHow | Literal['asof']='outer') -> None:
+        self.fill_method = fill_method
+        _MergeOperation.__init__(self, left, right, on=on, left_on=left_on, left_index=left_index, right_index=right_index, right_on=right_on, how=how, suffixes=suffixes, sort=True)
+
+    def get_result(self) -> DataFrame:
+        (join_index, left_indexer, right_indexer) = self._get_join_info()
+        left_join_indexer: npt.NDArray[np.intp] | None
+        right_join_indexer: npt.NDArray[np.intp] | None
+        if self.fill_method == 'ffill':
+            if left_indexer is None:
+                left_join_indexer = None
+            else:
+                left_join_indexer = libjoin.ffill_indexer(left_indexer)
+            if right_indexer is None:
+                right_join_indexer = None
+            else:
+                right_join_indexer = libjoin.ffill_indexer(right_indexer)
+        elif self.fill_method is None:
+            left_join_indexer = left_indexer
+            right_join_indexer = right_indexer
+        else:
+            raise ValueError("fill_method must be 'ffill' or None")
+        result = self._reindex_and_concat(join_index, left_join_indexer, right_join_indexer)
+        self._maybe_add_join_keys(result, left_indexer, right_indexer)
+        return result
+
+def _asof_by_function(direction: str):
+    name = f'asof_join_{direction}_on_X_by_Y'
+    return getattr(libjoin, name, None)
+
+class _AsOfMerge(_OrderedMerge):
+    _merge_type = 'asof_merge'
+
+    def __init__(self, left: DataFrame | Series, right: DataFrame | Series, on: IndexLabel | None=None, left_on: IndexLabel | None=None, right_on: IndexLabel | None=None, left_index: bool=False, right_index: bool=False, by=None, left_by=None, right_by=None, suffixes: Suffixes=('_x', '_y'), how: Literal['asof']='asof', tolerance=None, allow_exact_matches: bool=True, direction: str='backward') -> None:
+        self.by = by
+        self.left_by = left_by
+        self.right_by = right_by
+        self.tolerance = tolerance
+        self.allow_exact_matches = allow_exact_matches
+        self.direction = direction
+        if self.direction not in ['backward', 'forward', 'nearest']:
+            raise MergeError(f'direction invalid: {self.direction}')
+        if not is_bool(self.allow_exact_matches):
+            msg = f'allow_exact_matches must be boolean, passed {self.allow_exact_matches}'
+            raise MergeError(msg)
+        _OrderedMerge.__init__(self, left, right, on=on, left_on=left_on, right_on=right_on, left_index=left_index, right_index=right_index, how=how, suffixes=suffixes, fill_method=None)
+
+    def _validate_left_right_on(self, left_on, right_on):
+        (left_on, right_on) = super()._validate_left_right_on(left_on, right_on)
+        if len(left_on) != 1 and (not self.left_index):
+            raise MergeError('can only asof on a key for left')
+        if len(right_on) != 1 and (not self.right_index):
+            raise MergeError('can only asof on a key for right')
+        if self.left_index and isinstance(self.left.index, MultiIndex):
+            raise MergeError('left can only have one index')
+        if self.right_index and isinstance(self.right.index, MultiIndex):
+            raise MergeError('right can only have one index')
+        if self.by is not None:
+            if self.left_by is not None or self.right_by is not None:
+                raise MergeError('Can only pass by OR left_by and right_by')
+            self.left_by = self.right_by = self.by
+        if self.left_by is None and self.right_by is not None:
+            raise MergeError('missing left_by')
+        if self.left_by is not None and self.right_by is None:
+            raise MergeError('missing right_by')
+        if not self.left_index:
+            left_on_0 = left_on[0]
+            if isinstance(left_on_0, _known):
+                lo_dtype = left_on_0.dtype
+            else:
+                lo_dtype = self.left._get_label_or_level_values(left_on_0).dtype if left_on_0 in self.left.columns else self.left.index.get_level_values(left_on_0)
+        else:
+            lo_dtype = self.left.index.dtype
+        if not self.right_index:
+            right_on_0 = right_on[0]
+            if isinstance(right_on_0, _known):
+                ro_dtype = right_on_0.dtype
+            else:
+                ro_dtype = self.right._get_label_or_level_values(right_on_0).dtype if right_on_0 in self.right.columns else self.right.index.get_level_values(right_on_0)
+        else:
+            ro_dtype = self.right.index.dtype
+        if is_object_dtype(lo_dtype) or is_object_dtype(ro_dtype) or is_string_dtype(lo_dtype) or is_string_dtype(ro_dtype):
+            raise MergeError(f'Incompatible merge dtype, {lo_dtype!r} and {ro_dtype!r}, both sides must have numeric dtype')
+        if self.left_by is not None:
+            if not is_list_like(self.left_by):
+                self.left_by = [self.left_by]
+            if not is_list_like(self.right_by):
+                self.right_by = [self.right_by]
+            if len(self.left_by) != len(self.right_by):
+                raise MergeError('left_by and right_by must be the same length')
+            left_on = self.left_by + list(left_on)
+            right_on = self.right_by + list(right_on)
+        return (left_on, right_on)
+
+    def _maybe_require_matching_dtypes(self, left_join_keys: list[ArrayLike], right_join_keys: list[ArrayLike]) -> None:
+
+        def _check_dtype_match(left: ArrayLike, right: ArrayLike, i: int) -> None:
+            if left.dtype != right.dtype:
+                if isinstance(left.dtype, CategoricalDtype) and isinstance(right.dtype, CategoricalDtype):
+                    msg = f'incompatible merge keys [{i}] {left.dtype!r} and {right.dtype!r}, both sides category, but not equal ones'
+                else:
+                    msg = f'incompatible merge keys [{i}] {left.dtype!r} and {right.dtype!r}, must be the same type'
+                raise MergeError(msg)
+        for (i, (lk, rk)) in enumerate(zip(left_join_keys, right_join_keys)):
+            _check_dtype_match(lk, rk, i)
+        if self.left_index:
+            lt = self.left.index._values
+        else:
+            lt = left_join_keys[-1]
+        if self.right_index:
+            rt = self.right.index._values
+        else:
+            rt = right_join_keys[-1]
+        _check_dtype_match(lt, rt, 0)
+
+    def _validate_tolerance(self, left_join_keys: list[ArrayLike]) -> None:
+        if self.tolerance is not None:
+            if self.left_index:
+                lt = self.left.index._values
+            else:
+                lt = left_join_keys[-1]
+            msg = f'incompatible tolerance {self.tolerance}, must be compat with type {lt.dtype!r}'
+            if needs_i8_conversion(lt.dtype) or (isinstance(lt, ArrowExtensionArray) and lt.dtype.kind in 'mM'):
+                if not isinstance(self.tolerance, datetime.timedelta):
+                    raise MergeError(msg)
+                if self.tolerance < Timedelta(0):
+                    raise MergeError('tolerance must be positive')
+            elif is_integer_dtype(lt.dtype):
+                if not is_integer(self.tolerance):
+                    raise MergeError(msg)
+                if self.tolerance < 0:
+                    raise MergeError('tolerance must be positive')
+            elif is_float_dtype(lt.dtype):
+                if not is_number(self.tolerance):
+                    raise MergeError(msg)
+                if self.tolerance < 0:
+                    raise MergeError('tolerance must be positive')
+            else:
+                raise MergeError('key must be integer, timestamp or float')
+
+    def _convert_values_for_libjoin(self, values: AnyArrayLike, side: str) -> np.ndarray:
+        if not Index(values).is_monotonic_increasing:
+            if isna(values).any():
+                raise ValueError(f'Merge keys contain null values on {side} side')
+            raise ValueError(f'{side} keys must be sorted')
+        if isinstance(values, ArrowExtensionArray):
+            values = values._maybe_convert_datelike_array()
+        if needs_i8_conversion(values.dtype):
+            values = values.view('i8')
+        elif isinstance(values, BaseMaskedArray):
+            values = values._data
+        elif isinstance(values, ExtensionArray):
+            values = values.to_numpy()
+        return values
+
+    def _get_join_indexers(self) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+        left_values = self.left.index._values if self.left_index else self.left_join_keys[-1]
+        right_values = self.right.index._values if self.right_index else self.right_join_keys[-1]
+        assert left_values.dtype == right_values.dtype
+        tolerance = self.tolerance
+        if tolerance is not None:
+            if needs_i8_conversion(left_values.dtype) or (isinstance(left_values, ArrowExtensionArray) and left_values.dtype.kind in 'mM'):
+                tolerance = Timedelta(tolerance)
+                if left_values.dtype.kind in 'mM':
+                    if isinstance(left_values, ArrowExtensionArray):
+                        unit = left_values.dtype.pyarrow_dtype.unit
+                    else:
+                        unit = ensure_wrapped_if_datetimelike(left_values).unit
+                    tolerance = tolerance.as_unit(unit)
+                tolerance = tolerance._value
+        left_values = self._convert_values_for_libjoin(left_values, 'left')
+        right_values = self._convert_values_for_libjoin(right_values, 'right')
+        if self.left_by is not None:
+            if self.left_index and self.right_index:
+                left_join_keys = self.left_join_keys
+                right_join_keys = self.right_join_keys
+            else:
+                left_join_keys = self.left_join_keys[0:-1]
+                right_join_keys = self.right_join_keys[0:-1]
+            mapped = [_factorize_keys(left_join_keys[n], right_join_keys[n], sort=False) for n in range(len(left_join_keys))]
+            if len(left_join_keys) == 1:
+                left_by_values = mapped[0][0]
+                right_by_values = mapped[0][1]
+            else:
+                arrs = [np.concatenate(m[:2]) for m in mapped]
+                shape = tuple((m[2] for m in mapped))
+                group_index = get_group_index(arrs, shape=shape, sort=False, xnull=False)
+                left_len = len(left_join_keys[0])
+                left_by_values = group_index[:left_len]
+                right_by_values = group_index[left_len:]
+            left_by_values = ensure_int64(left_by_values)
+            right_by_values = ensure_int64(right_by_values)
+            func = _asof_by_function(self.direction)
+            return func(left_values, right_values, left_by_values, right_by_values, self.allow_exact_matches, tolerance)
+        else:
+            func = _asof_by_function(self.direction)
+            return func(left_values, right_values, None, None, self.allow_exact_matches, tolerance, False)
+
+def _get_multiindex_indexer(join_keys: list[ArrayLike], index: MultiIndex, sort: bool) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+    mapped = (_factorize_keys(index.levels[n]._values, join_keys[n], sort=sort) for n in range(index.nlevels))
+    zipped = zip(*mapped)
+    (rcodes, lcodes, shape) = (list(x) for x in zipped)
+    if sort:
+        rcodes = list(map(np.take, rcodes, index.codes))
+    else:
+        i8copy = lambda a: a.astype('i8', subok=False)
+        rcodes = list(map(i8copy, index.codes))
+    for (i, join_key) in enumerate(join_keys):
+        mask = index.codes[i] == -1
+        if mask.any():
+            a = join_key[lcodes[i] == shape[i] - 1]
+            if a.size == 0 or not a[0] != a[0]:
+                shape[i] += 1
+            rcodes[i][mask] = shape[i] - 1
+    (lkey, rkey) = _get_join_keys(lcodes, rcodes, tuple(shape), sort)
+    return (lkey, rkey)
+
+def _get_empty_indexer() -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+    return (np.array([], dtype=np.intp), np.array([], dtype=np.intp))
+
+def _get_no_sort_one_missing_indexer(n: int, left_missing: bool) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+    idx = np.arange(n, dtype=np.intp)
+    idx_missing = np.full(shape=n, fill_value=-1, dtype=np.intp)
+    if left_missing:
+        return (idx_missing, idx)
+    return (idx, idx_missing)
+
+def _left_join_on_index(left_ax: Index, right_ax: Index, join_keys: list[ArrayLike], sort: bool=False) -> tuple[Index, npt.NDArray[np.intp] | None, npt.NDArray[np.intp]]:
+    if isinstance(right_ax, MultiIndex):
+        (lkey, rkey) = _get_multiindex_indexer(join_keys, right_ax, sort=sort)
+    else:
+        lkey = join_keys[0]
+        rkey = right_ax._values
+    (left_key, right_key, count) = _factorize_keys(lkey, rkey, sort=sort)
+    (left_indexer, right_indexer) = libjoin.left_outer_join(left_key, right_key, count, sort=sort)
+    if sort or len(left_ax) != len(left_indexer):
+        join_index = left_ax.take(left_indexer)
+        return (join_index, left_indexer, right_indexer)
+    return (left_ax, None, right_indexer)
+
+def _factorize_keys(lk: ArrayLike, rk: ArrayLike, sort: bool=True, how: str | None=None) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp], int]:
+    if isinstance(lk.dtype, DatetimeTZDtype) and isinstance(rk.dtype, DatetimeTZDtype) or (lib.is_np_dtype(lk.dtype, 'M') and lib.is_np_dtype(rk.dtype, 'M')):
+        (lk, rk) = cast('DatetimeArray', lk)._ensure_matching_resos(rk)
+        lk = cast('DatetimeArray', lk)._ndarray
+        rk = cast('DatetimeArray', rk)._ndarray
+    elif isinstance(lk.dtype, CategoricalDtype) and isinstance(rk.dtype, CategoricalDtype) and (lk.dtype == rk.dtype):
+        assert isinstance(lk, Categorical)
+        assert isinstance(rk, Categorical)
+        rk = lk._encode_with_my_categories(rk)
+        lk = ensure_int64(lk.codes)
+        rk = ensure_int64(rk.codes)
+    elif isinstance(lk, ExtensionArray) and lk.dtype == rk.dtype:
+        if isinstance(lk.dtype, ArrowDtype) and is_string_dtype(lk.dtype) or (isinstance(lk.dtype, StringDtype) and lk.dtype.storage == 'pyarrow'):
+            import pyarrow as pa
+            import pyarrow.compute as pc
+            len_lk = len(lk)
+            lk = lk._pa_array
+            rk = rk._pa_array
+            dc = pa.chunked_array(lk.chunks + rk.chunks).combine_chunks().dictionary_encode()
+            (llab, rlab, count) = (pc.fill_null(dc.indices[slice(len_lk)], -1).to_numpy().astype(np.intp, copy=False), pc.fill_null(dc.indices[slice(len_lk, None)], -1).to_numpy().astype(np.intp, copy=False), len(dc.dictionary))
+            if sort:
+                uniques = dc.dictionary.to_numpy(zero_copy_only=False)
+                (llab, rlab) = _sort_labels(uniques, llab, rlab)
+            if dc.null_count > 0:
+                lmask = llab == -1
+                lany = lmask.any()
+                rmask = rlab == -1
+                rany = rmask.any()
+                if lany:
+                    np.putmask(llab, lmask, count)
+                if rany:
+                    np.putmask(rlab, rmask, count)
+                count += 1
+            return (llab, rlab, count)
+        if not isinstance(lk, BaseMaskedArray) and (not (isinstance(lk.dtype, ArrowDtype) and (is_numeric_dtype(lk.dtype.numpy_dtype) or (is_string_dtype(lk.dtype) and (not sort))))):
+            (lk, _) = lk._values_for_factorize()
+            (rk, _) = rk._values_for_factorize()
+    if needs_i8_conversion(lk.dtype) and lk.dtype == rk.dtype:
+        lk = np.asarray(lk, dtype=np.int64)
+        rk = np.asarray(rk, dtype=np.int64)
+    (klass, lk, rk) = _convert_arrays_and_get_rizer_klass(lk, rk)
+    rizer = klass(max(len(lk), len(rk)), uses_mask=isinstance(rk, (BaseMaskedArray, ArrowExtensionArray)))
+    if isinstance(lk, BaseMaskedArray):
+        assert isinstance(rk, BaseMaskedArray)
+        (lk_data, lk_mask) = (lk._data, lk._mask)
+        (rk_data, rk_mask) = (rk._data, rk._mask)
+    elif isinstance(lk, ArrowExtensionArray):
+        assert isinstance(rk, ArrowExtensionArray)
+        lk_data = lk.to_numpy(na_value=1, dtype=lk.dtype.numpy_dtype)
+        rk_data = rk.to_numpy(na_value=1, dtype=lk.dtype.numpy_dtype)
+        (lk_mask, rk_mask) = (lk.isna(), rk.isna())
+    else:
+        (lk_data, rk_data) = (lk, rk)
+        (lk_mask, rk_mask) = (None, None)
+    hash_join_available = how == 'inner' and (not sort) and (lk.dtype.kind in 'iufb')
+    if hash_join_available:
+        rlab = rizer.factorize(rk_data, mask=rk_mask)
+        if rizer.get_count() == len(rlab):
+            (ridx, lidx) = rizer.hash_inner_join(lk_data, lk_mask)
+            return (lidx, ridx, -1)
+        else:
+            llab = rizer.factorize(lk_data, mask=lk_mask)
+    else:
+        llab = rizer.factorize(lk_data, mask=lk_mask)
+        rlab = rizer.factorize(rk_data, mask=rk_mask)
+    assert llab.dtype == np.dtype(np.intp), llab.dtype
+    assert rlab.dtype == np.dtype(np.intp), rlab.dtype
+    count = rizer.get_count()
+    if sort:
+        uniques = rizer.uniques.to_array()
+        (llab, rlab) = _sort_labels(uniques, llab, rlab)
+    lmask = llab == -1
+    lany = lmask.any()
+    rmask = rlab == -1
+    rany = rmask.any()
+    if lany or rany:
+        if lany:
+            np.putmask(llab, lmask, count)
+        if rany:
+            np.putmask(rlab, rmask, count)
+        count += 1
+    return (llab, rlab, count)
+
+def _convert_arrays_and_get_rizer_klass(lk: ArrayLike, rk: ArrayLike) -> tuple[type[libhashtable.Factorizer], ArrayLike, ArrayLike]:
+    klass: type[libhashtable.Factorizer]
+    if is_numeric_dtype(lk.dtype):
+        if lk.dtype != rk.dtype:
+            dtype = find_common_type([lk.dtype, rk.dtype])
+            if isinstance(dtype, ExtensionDtype):
+                cls = dtype.construct_array_type()
+                if not isinstance(lk, ExtensionArray):
+                    lk = cls._from_sequence(lk, dtype=dtype, copy=False)
+                else:
+                    lk = lk.astype(dtype, copy=False)
+                if not isinstance(rk, ExtensionArray):
+                    rk = cls._from_sequence(rk, dtype=dtype, copy=False)
+                else:
+                    rk = rk.astype(dtype, copy=False)
+            else:
+                lk = lk.astype(dtype, copy=False)
+                rk = rk.astype(dtype, copy=False)
+        if isinstance(lk, BaseMaskedArray):
+            klass = _factorizers[lk.dtype.type]
+        elif isinstance(lk.dtype, ArrowDtype):
+            klass = _factorizers[lk.dtype.numpy_dtype.type]
+        else:
+            klass = _factorizers[lk.dtype.type]
+    else:
+        klass = libhashtable.ObjectFactorizer
+        lk = ensure_object(lk)
+        rk = ensure_object(rk)
+    return (klass, lk, rk)
+
+def _sort_labels(uniques: np.ndarray, left: npt.NDArray[np.intp], right: npt.NDArray[np.intp]) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+    llength = len(left)
+    labels = np.concatenate([left, right])
+    (_, new_labels) = algos.safe_sort(uniques, labels, use_na_sentinel=True)
+    (new_left, new_right) = (new_labels[:llength], new_labels[llength:])
+    return (new_left, new_right)
+
+def _get_join_keys(llab: list[npt.NDArray[np.int64 | np.intp]], rlab: list[npt.NDArray[np.int64 | np.intp]], shape: Shape, sort: bool) -> tuple[npt.NDArray[np.int64], npt.NDArray[np.int64]]:
+    nlev = next((lev for lev in range(len(shape), 0, -1) if not is_int64_overflow_possible(shape[:lev])))
+    stride = np.prod(shape[1:nlev], dtype='i8')
+    lkey = stride * llab[0].astype('i8', subok=False, copy=False)
+    rkey = stride * rlab[0].astype('i8', subok=False, copy=False)
+    for i in range(1, nlev):
+        with np.errstate(divide='ignore'):
+            stride //= shape[i]
+        lkey += llab[i] * stride
+        rkey += rlab[i] * stride
+    if nlev == len(shape):
+        return (lkey, rkey)
+    (lkey, rkey, count) = _factorize_keys(lkey, rkey, sort=sort)
+    llab = [lkey] + llab[nlev:]
+    rlab = [rkey] + rlab[nlev:]
+    shape = (count,) + shape[nlev:]
+    return _get_join_keys(llab, rlab, shape, sort)
+
+def _should_fill(lname, rname) -> bool:
+    if not isinstance(lname, str) or not isinstance(rname, str):
+        return True
+    return lname == rname
+
+def _any(x) -> bool:
+    return x is not None and com.any_not_none(*x)
+
+def _validate_operand(obj: DataFrame | Series) -> DataFrame:
+    if isinstance(obj, ABCDataFrame):
+        return obj
+    elif isinstance(obj, ABCSeries):
+        if obj.name is None:
+            raise ValueError('Cannot merge a Series without a name')
+        return obj.to_frame()
+    else:
+        raise TypeError(f'Can only merge Series or DataFrame objects, a {type(obj)} was passed')
+
+def _items_overlap_with_suffix(left: Index, right: Index, suffixes: Suffixes) -> tuple[Index, Index]:
+    if not is_list_like(suffixes, allow_sets=False) or isinstance(suffixes, dict):
+        raise TypeError(f"Passing 'suffixes' as a {type(suffixes)}, is not supported. Provide 'suffixes' as a tuple instead.")
+    to_rename = left.intersection(right)
+    if len(to_rename) == 0:
+        return (left, right)
+    (lsuffix, rsuffix) = suffixes
+    if not lsuffix and (not rsuffix):
+        raise ValueError(f'columns overlap but no suffix specified: {to_rename}')
+
+    def renamer(x, suffix: str | None):
+        if x in to_rename and suffix is not None:
+            return f'{x}{suffix}'
+        return x
+    lrenamer = partial(renamer, suffix=lsuffix)
+    rrenamer = partial(renamer, suffix=rsuffix)
+    llabels = left._transform_index(lrenamer)
+    rlabels = right._transform_index(rrenamer)
+    dups = []
+    if not llabels.is_unique:
+        dups = llabels[llabels.duplicated() & ~left.duplicated()].tolist()
+    if not rlabels.is_unique:
+        dups.extend(rlabels[rlabels.duplicated() & ~right.duplicated()].tolist())
+    if dups:
+        raise MergeError(f"Passing 'suffixes' which cause duplicate columns {set(dups)} is not allowed.")
+    return (llabels, rlabels)
+
+# File: pandas-main/pandas/core/reshape/pivot.py
+from __future__ import annotations
+import itertools
+from typing import TYPE_CHECKING, Literal, cast
+import numpy as np
+from pandas._libs import lib
+from pandas.core.dtypes.cast import maybe_downcast_to_dtype
+from pandas.core.dtypes.common import is_list_like, is_nested_list_like, is_scalar
+from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+import pandas.core.common as com
+from pandas.core.groupby import Grouper
+from pandas.core.indexes.api import Index, MultiIndex, get_objs_combined_axis
+from pandas.core.reshape.concat import concat
+from pandas.core.series import Series
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable
+    from pandas._typing import AggFuncType, AggFuncTypeBase, AggFuncTypeDict, IndexLabel, SequenceNotStr
+    from pandas import DataFrame
+
+def pivot_table(data: DataFrame, values=None, index=None, columns=None, aggfunc: AggFuncType='mean', fill_value=None, margins: bool=False, dropna: bool=True, margins_name: Hashable='All', observed: bool=True, sort: bool=True, **kwargs) -> DataFrame:
+    index = _convert_by(index)
+    columns = _convert_by(columns)
+    if isinstance(aggfunc, list):
+        pieces: list[DataFrame] = []
+        keys = []
+        for func in aggfunc:
+            _table = __internal_pivot_table(data, values=values, index=index, columns=columns, fill_value=fill_value, aggfunc=func, margins=margins, dropna=dropna, margins_name=margins_name, observed=observed, sort=sort, kwargs=kwargs)
+            pieces.append(_table)
+            keys.append(getattr(func, '__name__', func))
+        table = concat(pieces, keys=keys, axis=1)
+        return table.__finalize__(data, method='pivot_table')
+    table = __internal_pivot_table(data, values, index, columns, aggfunc, fill_value, margins, dropna, margins_name, observed, sort, kwargs)
+    return table.__finalize__(data, method='pivot_table')
+
+def __internal_pivot_table(data: DataFrame, values, index, columns, aggfunc: AggFuncTypeBase | AggFuncTypeDict, fill_value, margins: bool, dropna: bool, margins_name: Hashable, observed: bool, sort: bool, kwargs) -> DataFrame:
+    keys = index + columns
+    values_passed = values is not None
+    if values_passed:
+        if is_list_like(values):
+            values_multi = True
+            values = list(values)
+        else:
+            values_multi = False
+            values = [values]
+        for i in values:
+            if i not in data:
+                raise KeyError(i)
+        to_filter = []
+        for x in keys + values:
+            if isinstance(x, Grouper):
+                x = x.key
+            try:
+                if x in data:
+                    to_filter.append(x)
+            except TypeError:
+                pass
+        if len(to_filter) < len(data.columns):
+            data = data[to_filter]
+    else:
+        values = data.columns
+        for key in keys:
+            try:
+                values = values.drop(key)
+            except (TypeError, ValueError, KeyError):
+                pass
+        values = list(values)
+    grouped = data.groupby(keys, observed=observed, sort=sort, dropna=dropna)
+    agged = grouped.agg(aggfunc, **kwargs)
+    if dropna and isinstance(agged, ABCDataFrame) and len(agged.columns):
+        agged = agged.dropna(how='all')
+    table = agged
+    if table.index.nlevels > 1 and index:
+        index_names = agged.index.names[:len(index)]
+        to_unstack = []
+        for i in range(len(index), len(keys)):
+            name = agged.index.names[i]
+            if name is None or name in index_names:
+                to_unstack.append(i)
+            else:
+                to_unstack.append(name)
+        table = agged.unstack(to_unstack, fill_value=fill_value)
+    if not dropna:
+        if isinstance(table.index, MultiIndex):
+            m = MultiIndex.from_product(table.index.levels, names=table.index.names)
+            table = table.reindex(m, axis=0, fill_value=fill_value)
+        if isinstance(table.columns, MultiIndex):
+            m = MultiIndex.from_product(table.columns.levels, names=table.columns.names)
+            table = table.reindex(m, axis=1, fill_value=fill_value)
+    if sort is True and isinstance(table, ABCDataFrame):
+        table = table.sort_index(axis=1)
+    if fill_value is not None:
+        table = table.fillna(fill_value)
+        if aggfunc is len and (not observed) and lib.is_integer(fill_value):
+            table = table.astype(np.int64)
+    if margins:
+        if dropna:
+            data = data[data.notna().all(axis=1)]
+        table = _add_margins(table, data, values, rows=index, cols=columns, aggfunc=aggfunc, kwargs=kwargs, observed=dropna, margins_name=margins_name, fill_value=fill_value)
+    if values_passed and (not values_multi) and (table.columns.nlevels > 1):
+        table.columns = table.columns.droplevel(0)
+    if len(index) == 0 and len(columns) > 0:
+        table = table.T
+    if isinstance(table, ABCDataFrame) and dropna:
+        table = table.dropna(how='all', axis=1)
+    return table
+
+def _add_margins(table: DataFrame | Series, data: DataFrame, values, rows, cols, aggfunc, kwargs, observed: bool, margins_name: Hashable='All', fill_value=None):
+    if not isinstance(margins_name, str):
+        raise ValueError('margins_name argument must be a string')
+    msg = f'Conflicting name "{margins_name}" in margins'
+    for level in table.index.names:
+        if margins_name in table.index.get_level_values(level):
+            raise ValueError(msg)
+    grand_margin = _compute_grand_margin(data, values, aggfunc, kwargs, margins_name)
+    if table.ndim == 2:
+        for level in table.columns.names[1:]:
+            if margins_name in table.columns.get_level_values(level):
+                raise ValueError(msg)
+    key: str | tuple[str, ...]
+    if len(rows) > 1:
+        key = (margins_name,) + ('',) * (len(rows) - 1)
+    else:
+        key = margins_name
+    if not values and isinstance(table, ABCSeries):
+        return table._append(table._constructor({key: grand_margin[margins_name]}))
+    elif values:
+        marginal_result_set = _generate_marginal_results(table, data, values, rows, cols, aggfunc, kwargs, observed, margins_name)
+        if not isinstance(marginal_result_set, tuple):
+            return marginal_result_set
+        (result, margin_keys, row_margin) = marginal_result_set
+    else:
+        assert isinstance(table, ABCDataFrame)
+        marginal_result_set = _generate_marginal_results_without_values(table, data, rows, cols, aggfunc, kwargs, observed, margins_name)
+        if not isinstance(marginal_result_set, tuple):
+            return marginal_result_set
+        (result, margin_keys, row_margin) = marginal_result_set
+    row_margin = row_margin.reindex(result.columns, fill_value=fill_value)
+    for k in margin_keys:
+        if isinstance(k, str):
+            row_margin[k] = grand_margin[k]
+        else:
+            row_margin[k] = grand_margin[k[0]]
+    from pandas import DataFrame
+    margin_dummy = DataFrame(row_margin, columns=Index([key])).T
+    row_names = result.index.names
+    for dtype in set(result.dtypes):
+        if isinstance(dtype, ExtensionDtype):
+            continue
+        cols = result.select_dtypes([dtype]).columns
+        margin_dummy[cols] = margin_dummy[cols].apply(maybe_downcast_to_dtype, args=(dtype,))
+    result = result._append(margin_dummy)
+    result.index.names = row_names
+    return result
+
+def _compute_grand_margin(data: DataFrame, values, aggfunc, kwargs, margins_name: Hashable='All'):
+    if values:
+        grand_margin = {}
+        for (k, v) in data[values].items():
+            try:
+                if isinstance(aggfunc, str):
+                    grand_margin[k] = getattr(v, aggfunc)(**kwargs)
+                elif isinstance(aggfunc, dict):
+                    if isinstance(aggfunc[k], str):
+                        grand_margin[k] = getattr(v, aggfunc[k])(**kwargs)
+                    else:
+                        grand_margin[k] = aggfunc[k](v, **kwargs)
+                else:
+                    grand_margin[k] = aggfunc(v, **kwargs)
+            except TypeError:
+                pass
+        return grand_margin
+    else:
+        return {margins_name: aggfunc(data.index, **kwargs)}
+
+def _generate_marginal_results(table, data: DataFrame, values, rows, cols, aggfunc, kwargs, observed: bool, margins_name: Hashable='All'):
+    margin_keys: list | Index
+    if len(cols) > 0:
+        table_pieces = []
+        margin_keys = []
+
+        def _all_key(key):
+            return (key, margins_name) + ('',) * (len(cols) - 1)
+        if len(rows) > 0:
+            margin = data[rows + values].groupby(rows, observed=observed).agg(aggfunc, **kwargs)
+            cat_axis = 1
+            for (key, piece) in table.T.groupby(level=0, observed=observed):
+                piece = piece.T
+                all_key = _all_key(key)
+                piece[all_key] = margin[key]
+                table_pieces.append(piece)
+                margin_keys.append(all_key)
+        else:
+            margin = data[cols[:1] + values].groupby(cols[:1], observed=observed).agg(aggfunc, **kwargs).T
+            cat_axis = 0
+            for (key, piece) in table.groupby(level=0, observed=observed):
+                if len(cols) > 1:
+                    all_key = _all_key(key)
+                else:
+                    all_key = margins_name
+                table_pieces.append(piece)
+                transformed_piece = margin[key].to_frame().T
+                if isinstance(piece.index, MultiIndex):
+                    transformed_piece.index = MultiIndex.from_tuples([all_key], names=piece.index.names + [None])
+                else:
+                    transformed_piece.index = Index([all_key], name=piece.index.name)
+                table_pieces.append(transformed_piece)
+                margin_keys.append(all_key)
+        if not table_pieces:
+            return table
+        else:
+            result = concat(table_pieces, axis=cat_axis)
+        if len(rows) == 0:
+            return result
+    else:
+        result = table
+        margin_keys = table.columns
+    if len(cols) > 0:
+        row_margin = data[cols + values].groupby(cols, observed=observed).agg(aggfunc, **kwargs)
+        row_margin = row_margin.stack()
+        new_order_indices = itertools.chain([len(cols)], range(len(cols)))
+        new_order_names = [row_margin.index.names[i] for i in new_order_indices]
+        row_margin.index = row_margin.index.reorder_levels(new_order_names)
+    else:
+        row_margin = data._constructor_sliced(np.nan, index=result.columns)
+    return (result, margin_keys, row_margin)
+
+def _generate_marginal_results_without_values(table: DataFrame, data: DataFrame, rows, cols, aggfunc, kwargs, observed: bool, margins_name: Hashable='All'):
+    margin_keys: list | Index
+    if len(cols) > 0:
+        margin_keys = []
+
+        def _all_key():
+            if len(cols) == 1:
+                return margins_name
+            return (margins_name,) + ('',) * (len(cols) - 1)
+        if len(rows) > 0:
+            margin = data.groupby(rows, observed=observed)[rows].apply(aggfunc, **kwargs)
+            all_key = _all_key()
+            table[all_key] = margin
+            result = table
+            margin_keys.append(all_key)
+        else:
+            margin = data.groupby(level=0, observed=observed).apply(aggfunc, **kwargs)
+            all_key = _all_key()
+            table[all_key] = margin
+            result = table
+            margin_keys.append(all_key)
+            return result
+    else:
+        result = table
+        margin_keys = table.columns
+    if len(cols):
+        row_margin = data.groupby(cols, observed=observed)[cols].apply(aggfunc, **kwargs)
+    else:
+        row_margin = Series(np.nan, index=result.columns)
+    return (result, margin_keys, row_margin)
+
+def _convert_by(by):
+    if by is None:
+        by = []
+    elif is_scalar(by) or isinstance(by, (np.ndarray, Index, ABCSeries, Grouper)) or callable(by):
+        by = [by]
+    else:
+        by = list(by)
+    return by
+
+def pivot(data: DataFrame, *, columns: IndexLabel, index: IndexLabel | lib.NoDefault=lib.no_default, values: IndexLabel | lib.NoDefault=lib.no_default) -> DataFrame:
+    columns_listlike = com.convert_to_list_like(columns)
+    if any((name is None for name in data.index.names)):
+        data = data.copy(deep=False)
+        data.index.names = [name if name is not None else lib.no_default for name in data.index.names]
+    indexed: DataFrame | Series
+    if values is lib.no_default:
+        if index is not lib.no_default:
+            cols = com.convert_to_list_like(index)
+        else:
+            cols = []
+        append = index is lib.no_default
+        indexed = data.set_index(cols + columns_listlike, append=append)
+    else:
+        index_list: list[Index] | list[Series]
+        if index is lib.no_default:
+            if isinstance(data.index, MultiIndex):
+                index_list = [data.index.get_level_values(i) for i in range(data.index.nlevels)]
+            else:
+                index_list = [data._constructor_sliced(data.index, name=data.index.name)]
+        else:
+            index_list = [data[idx] for idx in com.convert_to_list_like(index)]
+        data_columns = [data[col] for col in columns_listlike]
+        index_list.extend(data_columns)
+        multiindex = MultiIndex.from_arrays(index_list)
+        if is_list_like(values) and (not isinstance(values, tuple)):
+            indexed = data._constructor(data[values]._values, index=multiindex, columns=cast('SequenceNotStr', values))
+        else:
+            indexed = data._constructor_sliced(data[values]._values, index=multiindex)
+    result = cast('DataFrame', indexed.unstack(columns_listlike))
+    result.index.names = [name if name is not lib.no_default else None for name in result.index.names]
+    return result
+
+def crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None, margins: bool=False, margins_name: Hashable='All', dropna: bool=True, normalize: bool | Literal[0, 1, 'all', 'index', 'columns']=False) -> DataFrame:
+    if values is None and aggfunc is not None:
+        raise ValueError('aggfunc cannot be used without values.')
+    if values is not None and aggfunc is None:
+        raise ValueError('values cannot be used without an aggfunc.')
+    if not is_nested_list_like(index):
+        index = [index]
+    if not is_nested_list_like(columns):
+        columns = [columns]
+    common_idx = None
+    pass_objs = [x for x in index + columns if isinstance(x, (ABCSeries, ABCDataFrame))]
+    if pass_objs:
+        common_idx = get_objs_combined_axis(pass_objs, intersect=True, sort=False)
+    rownames = _get_names(index, rownames, prefix='row')
+    colnames = _get_names(columns, colnames, prefix='col')
+    (rownames_mapper, unique_rownames, colnames_mapper, unique_colnames) = _build_names_mapper(rownames, colnames)
+    from pandas import DataFrame
+    data = {**dict(zip(unique_rownames, index)), **dict(zip(unique_colnames, columns))}
+    df = DataFrame(data, index=common_idx)
+    if values is None:
+        df['__dummy__'] = 0
+        kwargs = {'aggfunc': len, 'fill_value': 0}
+    else:
+        df['__dummy__'] = values
+        kwargs = {'aggfunc': aggfunc}
+    table = df.pivot_table('__dummy__', index=unique_rownames, columns=unique_colnames, margins=margins, margins_name=margins_name, dropna=dropna, observed=dropna, **kwargs)
+    if normalize is not False:
+        table = _normalize(table, normalize=normalize, margins=margins, margins_name=margins_name)
+    table = table.rename_axis(index=rownames_mapper, axis=0)
+    table = table.rename_axis(columns=colnames_mapper, axis=1)
+    return table
+
+def _normalize(table: DataFrame, normalize, margins: bool, margins_name: Hashable='All') -> DataFrame:
+    if not isinstance(normalize, (bool, str)):
+        axis_subs = {0: 'index', 1: 'columns'}
+        try:
+            normalize = axis_subs[normalize]
+        except KeyError as err:
+            raise ValueError('Not a valid normalize argument') from err
+    if margins is False:
+        normalizers: dict[bool | str, Callable] = {'all': lambda x: x / x.sum(axis=1).sum(axis=0), 'columns': lambda x: x / x.sum(), 'index': lambda x: x.div(x.sum(axis=1), axis=0)}
+        normalizers[True] = normalizers['all']
+        try:
+            f = normalizers[normalize]
+        except KeyError as err:
+            raise ValueError('Not a valid normalize argument') from err
+        table = f(table)
+        table = table.fillna(0)
+    elif margins is True:
+        table_index = table.index
+        table_columns = table.columns
+        last_ind_or_col = table.iloc[-1, :].name
+        if (margins_name not in last_ind_or_col) & (margins_name != last_ind_or_col):
+            raise ValueError(f'{margins_name} not in pivoted DataFrame')
+        column_margin = table.iloc[:-1, -1]
+        index_margin = table.iloc[-1, :-1]
+        table = table.iloc[:-1, :-1]
+        table = _normalize(table, normalize=normalize, margins=False)
+        if normalize == 'columns':
+            column_margin = column_margin / column_margin.sum()
+            table = concat([table, column_margin], axis=1)
+            table = table.fillna(0)
+            table.columns = table_columns
+        elif normalize == 'index':
+            index_margin = index_margin / index_margin.sum()
+            table = table._append(index_margin, ignore_index=True)
+            table = table.fillna(0)
+            table.index = table_index
+        elif normalize == 'all' or normalize is True:
+            column_margin = column_margin / column_margin.sum()
+            index_margin = index_margin / index_margin.sum()
+            index_margin.loc[margins_name] = 1
+            table = concat([table, column_margin], axis=1)
+            table = table._append(index_margin, ignore_index=True)
+            table = table.fillna(0)
+            table.index = table_index
+            table.columns = table_columns
+        else:
+            raise ValueError('Not a valid normalize argument')
+    else:
+        raise ValueError('Not a valid margins argument')
+    return table
+
+def _get_names(arrs, names, prefix: str='row') -> list:
+    if names is None:
+        names = []
+        for (i, arr) in enumerate(arrs):
+            if isinstance(arr, ABCSeries) and arr.name is not None:
+                names.append(arr.name)
+            else:
+                names.append(f'{prefix}_{i}')
+    else:
+        if len(names) != len(arrs):
+            raise AssertionError('arrays and names must have the same length')
+        if not isinstance(names, list):
+            names = list(names)
+    return names
+
+def _build_names_mapper(rownames: list[str], colnames: list[str]) -> tuple[dict[str, str], list[str], dict[str, str], list[str]]:
+    dup_names = set(rownames) | set(colnames)
+    rownames_mapper = {f'row_{i}': name for (i, name) in enumerate(rownames) if name in dup_names}
+    unique_rownames = [f'row_{i}' if name in dup_names else name for (i, name) in enumerate(rownames)]
+    colnames_mapper = {f'col_{i}': name for (i, name) in enumerate(colnames) if name in dup_names}
+    unique_colnames = [f'col_{i}' if name in dup_names else name for (i, name) in enumerate(colnames)]
+    return (rownames_mapper, unique_rownames, colnames_mapper, unique_colnames)
+
+# File: pandas-main/pandas/core/reshape/reshape.py
+from __future__ import annotations
+import itertools
+from typing import TYPE_CHECKING, cast, overload
+import warnings
+import numpy as np
+from pandas._config.config import get_option
+import pandas._libs.reshape as libreshape
+from pandas.errors import PerformanceWarning
+from pandas.util._decorators import cache_readonly
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.cast import find_common_type, maybe_promote
+from pandas.core.dtypes.common import ensure_platform_int, is_1d_only_ea_dtype, is_integer, needs_i8_conversion
+from pandas.core.dtypes.dtypes import ExtensionDtype
+from pandas.core.dtypes.missing import notna
+import pandas.core.algorithms as algos
+from pandas.core.algorithms import factorize, unique
+from pandas.core.arrays._mixins import NDArrayBackedExtensionArray
+from pandas.core.arrays.categorical import factorize_from_iterable
+from pandas.core.construction import ensure_wrapped_if_datetimelike
+from pandas.core.frame import DataFrame
+from pandas.core.indexes.api import Index, MultiIndex, default_index
+from pandas.core.reshape.concat import concat
+from pandas.core.series import Series
+from pandas.core.sorting import compress_group_index, decons_obs_group_ids, get_compressed_ids, get_group_index, get_group_index_sorter
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike, Level, npt
+    from pandas.core.arrays import ExtensionArray
+    from pandas.core.indexes.frozen import FrozenList
+
+class _Unstacker:
+
+    def __init__(self, index: MultiIndex, level: Level, constructor, sort: bool=True) -> None:
+        self.constructor = constructor
+        self.sort = sort
+        self.index = index.remove_unused_levels()
+        self.level = self.index._get_level_number(level)
+        self.lift = 1 if -1 in self.index.codes[self.level] else 0
+        self.new_index_levels = list(self.index.levels)
+        self.new_index_names = list(self.index.names)
+        self.removed_name = self.new_index_names.pop(self.level)
+        self.removed_level = self.new_index_levels.pop(self.level)
+        self.removed_level_full = index.levels[self.level]
+        if not self.sort:
+            unique_codes = unique(self.index.codes[self.level])
+            self.removed_level = self.removed_level.take(unique_codes)
+            self.removed_level_full = self.removed_level_full.take(unique_codes)
+        if get_option('performance_warnings'):
+            num_rows = max((index_level.size for index_level in self.new_index_levels))
+            num_columns = self.removed_level.size
+            num_cells = num_rows * num_columns
+            if num_cells > np.iinfo(np.int32).max:
+                warnings.warn(f'The following operation may generate {num_cells} cells in the resulting pandas object.', PerformanceWarning, stacklevel=find_stack_level())
+        self._make_selectors()
+
+    @cache_readonly
+    def _indexer_and_to_sort(self) -> tuple[npt.NDArray[np.intp], list[np.ndarray]]:
+        v = self.level
+        codes = list(self.index.codes)
+        if not self.sort:
+            codes = [factorize(code)[0] for code in codes]
+        levs = list(self.index.levels)
+        to_sort = codes[:v] + codes[v + 1:] + [codes[v]]
+        sizes = tuple((len(x) for x in levs[:v] + levs[v + 1:] + [levs[v]]))
+        (comp_index, obs_ids) = get_compressed_ids(to_sort, sizes)
+        ngroups = len(obs_ids)
+        indexer = get_group_index_sorter(comp_index, ngroups)
+        return (indexer, to_sort)
+
+    @cache_readonly
+    def sorted_labels(self) -> list[np.ndarray]:
+        (indexer, to_sort) = self._indexer_and_to_sort
+        if self.sort:
+            return [line.take(indexer) for line in to_sort]
+        return to_sort
+
+    def _make_sorted_values(self, values: np.ndarray) -> np.ndarray:
+        (indexer, _) = self._indexer_and_to_sort
+        sorted_values = algos.take_nd(values, indexer, axis=0)
+        return sorted_values
+
+    def _make_selectors(self) -> None:
+        new_levels = self.new_index_levels
+        remaining_labels = self.sorted_labels[:-1]
+        level_sizes = tuple((len(x) for x in new_levels))
+        (comp_index, obs_ids) = get_compressed_ids(remaining_labels, level_sizes)
+        ngroups = len(obs_ids)
+        comp_index = ensure_platform_int(comp_index)
+        stride = self.index.levshape[self.level] + self.lift
+        self.full_shape = (ngroups, stride)
+        selector = self.sorted_labels[-1] + stride * comp_index + self.lift
+        mask = np.zeros(np.prod(self.full_shape), dtype=bool)
+        mask.put(selector, True)
+        if mask.sum() < len(self.index):
+            raise ValueError('Index contains duplicate entries, cannot reshape')
+        self.group_index = comp_index
+        self.mask = mask
+        if self.sort:
+            self.compressor = comp_index.searchsorted(np.arange(ngroups))
+        else:
+            self.compressor = np.sort(np.unique(comp_index, return_index=True)[1])
+
+    @cache_readonly
+    def mask_all(self) -> bool:
+        return bool(self.mask.all())
+
+    @cache_readonly
+    def arange_result(self) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.bool_]]:
+        dummy_arr = np.arange(len(self.index), dtype=np.intp)
+        (new_values, mask) = self.get_new_values(dummy_arr, fill_value=-1)
+        return (new_values, mask.any(0))
+
+    def get_result(self, obj, value_columns, fill_value) -> DataFrame:
+        values = obj._values
+        if values.ndim == 1:
+            values = values[:, np.newaxis]
+        if value_columns is None and values.shape[1] != 1:
+            raise ValueError('must pass column labels for multi-column data')
+        (new_values, _) = self.get_new_values(values, fill_value)
+        columns = self.get_new_columns(value_columns)
+        index = self.new_index
+        result = self.constructor(new_values, index=index, columns=columns, dtype=new_values.dtype, copy=False)
+        if isinstance(values, np.ndarray):
+            (base, new_base) = (values.base, new_values.base)
+        elif isinstance(values, NDArrayBackedExtensionArray):
+            (base, new_base) = (values._ndarray.base, new_values._ndarray.base)
+        else:
+            (base, new_base) = (1, 2)
+        if base is new_base:
+            result._mgr.add_references(obj._mgr)
+        return result
+
+    def get_new_values(self, values, fill_value=None):
+        if values.ndim == 1:
+            values = values[:, np.newaxis]
+        sorted_values = self._make_sorted_values(values)
+        (length, width) = self.full_shape
+        stride = values.shape[1]
+        result_width = width * stride
+        result_shape = (length, result_width)
+        mask = self.mask
+        mask_all = self.mask_all
+        if mask_all and len(values):
+            new_values = sorted_values.reshape(length, width, stride).swapaxes(1, 2).reshape(result_shape)
+            new_mask = np.ones(result_shape, dtype=bool)
+            return (new_values, new_mask)
+        dtype = values.dtype
+        if isinstance(dtype, ExtensionDtype):
+            cls = dtype.construct_array_type()
+            new_values = cls._empty(result_shape, dtype=dtype)
+            if not mask_all:
+                new_values[:] = fill_value
+        else:
+            if not mask_all:
+                (dtype, fill_value) = maybe_promote(dtype, fill_value)
+            new_values = np.empty(result_shape, dtype=dtype)
+            if not mask_all:
+                new_values.fill(fill_value)
+        name = dtype.name
+        new_mask = np.zeros(result_shape, dtype=bool)
+        if needs_i8_conversion(values.dtype):
+            sorted_values = sorted_values.view('i8')
+            new_values = new_values.view('i8')
+        else:
+            sorted_values = sorted_values.astype(name, copy=False)
+        libreshape.unstack(sorted_values, mask.view('u1'), stride, length, width, new_values, new_mask.view('u1'))
+        if needs_i8_conversion(values.dtype):
+            new_values = new_values.view('M8[ns]')
+            new_values = ensure_wrapped_if_datetimelike(new_values)
+            new_values = new_values.view(values.dtype)
+        return (new_values, new_mask)
+
+    def get_new_columns(self, value_columns: Index | None):
+        if value_columns is None:
+            if self.lift == 0:
+                return self.removed_level._rename(name=self.removed_name)
+            lev = self.removed_level.insert(0, item=self.removed_level._na_value)
+            return lev.rename(self.removed_name)
+        stride = len(self.removed_level) + self.lift
+        width = len(value_columns)
+        propagator = np.repeat(np.arange(width), stride)
+        new_levels: FrozenList | list[Index]
+        if isinstance(value_columns, MultiIndex):
+            new_levels = value_columns.levels + (self.removed_level_full,)
+            new_names = value_columns.names + (self.removed_name,)
+            new_codes = [lab.take(propagator) for lab in value_columns.codes]
+        else:
+            new_levels = [value_columns, self.removed_level_full]
+            new_names = [value_columns.name, self.removed_name]
+            new_codes = [propagator]
+        repeater = self._repeater
+        new_codes.append(np.tile(repeater, width))
+        return MultiIndex(levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False)
+
+    @cache_readonly
+    def _repeater(self) -> np.ndarray:
+        if len(self.removed_level_full) != len(self.removed_level):
+            repeater = self.removed_level_full.get_indexer(self.removed_level)
+            if self.lift:
+                repeater = np.insert(repeater, 0, -1)
+        else:
+            stride = len(self.removed_level) + self.lift
+            repeater = np.arange(stride) - self.lift
+        return repeater
+
+    @cache_readonly
+    def new_index(self) -> MultiIndex | Index:
+        if self.sort:
+            labels = self.sorted_labels[:-1]
+        else:
+            v = self.level
+            codes = list(self.index.codes)
+            labels = codes[:v] + codes[v + 1:]
+        result_codes = [lab.take(self.compressor) for lab in labels]
+        if len(self.new_index_levels) == 1:
+            (level, level_codes) = (self.new_index_levels[0], result_codes[0])
+            if (level_codes == -1).any():
+                level = level.insert(len(level), level._na_value)
+            return level.take(level_codes).rename(self.new_index_names[0])
+        return MultiIndex(levels=self.new_index_levels, codes=result_codes, names=self.new_index_names, verify_integrity=False)
+
+def _unstack_multiple(data: Series | DataFrame, clocs, fill_value=None, sort: bool=True):
+    if len(clocs) == 0:
+        return data
+    index = data.index
+    index = cast(MultiIndex, index)
+    if clocs in index.names:
+        clocs = [clocs]
+    clocs = [index._get_level_number(i) for i in clocs]
+    rlocs = [i for i in range(index.nlevels) if i not in clocs]
+    clevels = [index.levels[i] for i in clocs]
+    ccodes = [index.codes[i] for i in clocs]
+    cnames = [index.names[i] for i in clocs]
+    rlevels = [index.levels[i] for i in rlocs]
+    rcodes = [index.codes[i] for i in rlocs]
+    rnames = [index.names[i] for i in rlocs]
+    shape = tuple((len(x) for x in clevels))
+    group_index = get_group_index(ccodes, shape, sort=False, xnull=False)
+    (comp_ids, obs_ids) = compress_group_index(group_index, sort=False)
+    recons_codes = decons_obs_group_ids(comp_ids, obs_ids, shape, ccodes, xnull=False)
+    if not rlocs:
+        dummy_index = Index(obs_ids, name='__placeholder__')
+    else:
+        dummy_index = MultiIndex(levels=rlevels + [obs_ids], codes=rcodes + [comp_ids], names=rnames + ['__placeholder__'], verify_integrity=False)
+    if isinstance(data, Series):
+        dummy = data.copy(deep=False)
+        dummy.index = dummy_index
+        unstacked = dummy.unstack('__placeholder__', fill_value=fill_value, sort=sort)
+        new_levels = clevels
+        new_names = cnames
+        new_codes = recons_codes
+    else:
+        if isinstance(data.columns, MultiIndex):
+            result = data
+            while clocs:
+                val = clocs.pop(0)
+                result = result.unstack(val, fill_value=fill_value, sort=sort)
+                clocs = [v if v < val else v - 1 for v in clocs]
+            return result
+        dummy_df = data.copy(deep=False)
+        dummy_df.index = dummy_index
+        unstacked = dummy_df.unstack('__placeholder__', fill_value=fill_value, sort=sort)
+        if isinstance(unstacked, Series):
+            unstcols = unstacked.index
+        else:
+            unstcols = unstacked.columns
+        assert isinstance(unstcols, MultiIndex)
+        new_levels = [unstcols.levels[0]] + clevels
+        new_names = [data.columns.name] + cnames
+        new_codes = [unstcols.codes[0]]
+        new_codes.extend((rec.take(unstcols.codes[-1]) for rec in recons_codes))
+    new_columns = MultiIndex(levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False)
+    if isinstance(unstacked, Series):
+        unstacked.index = new_columns
+    else:
+        unstacked.columns = new_columns
+    return unstacked
+
+@overload
+def unstack(obj: Series, level, fill_value=..., sort: bool=...) -> DataFrame:
+    ...
+
+@overload
+def unstack(obj: Series | DataFrame, level, fill_value=..., sort: bool=...) -> Series | DataFrame:
+    ...
+
+def unstack(obj: Series | DataFrame, level, fill_value=None, sort: bool=True) -> Series | DataFrame:
+    if isinstance(level, (tuple, list)):
+        if len(level) != 1:
+            return _unstack_multiple(obj, level, fill_value=fill_value, sort=sort)
+        else:
+            level = level[0]
+    if not is_integer(level) and (not level == '__placeholder__'):
+        obj.index._get_level_number(level)
+    if isinstance(obj, DataFrame):
+        if isinstance(obj.index, MultiIndex):
+            return _unstack_frame(obj, level, fill_value=fill_value, sort=sort)
+        else:
+            return obj.T.stack()
+    elif not isinstance(obj.index, MultiIndex):
+        raise ValueError(f'index must be a MultiIndex to unstack, {type(obj.index)} was passed')
+    else:
+        if is_1d_only_ea_dtype(obj.dtype):
+            return _unstack_extension_series(obj, level, fill_value, sort=sort)
+        unstacker = _Unstacker(obj.index, level=level, constructor=obj._constructor_expanddim, sort=sort)
+        return unstacker.get_result(obj, value_columns=None, fill_value=fill_value)
+
+def _unstack_frame(obj: DataFrame, level, fill_value=None, sort: bool=True) -> DataFrame:
+    assert isinstance(obj.index, MultiIndex)
+    unstacker = _Unstacker(obj.index, level=level, constructor=obj._constructor, sort=sort)
+    if not obj._can_fast_transpose:
+        mgr = obj._mgr.unstack(unstacker, fill_value=fill_value)
+        return obj._constructor_from_mgr(mgr, axes=mgr.axes)
+    else:
+        return unstacker.get_result(obj, value_columns=obj.columns, fill_value=fill_value)
+
+def _unstack_extension_series(series: Series, level, fill_value, sort: bool) -> DataFrame:
+    df = series.to_frame()
+    result = df.unstack(level=level, fill_value=fill_value, sort=sort)
+    result.columns = result.columns._drop_level_numbers([0])
+    return result
+
+def stack(frame: DataFrame, level=-1, dropna: bool=True, sort: bool=True) -> Series | DataFrame:
+
+    def stack_factorize(index):
+        if index.is_unique:
+            return (index, np.arange(len(index)))
+        (codes, categories) = factorize_from_iterable(index)
+        return (categories, codes)
+    (N, K) = frame.shape
+    level_num = frame.columns._get_level_number(level)
+    if isinstance(frame.columns, MultiIndex):
+        return _stack_multi_columns(frame, level_num=level_num, dropna=dropna, sort=sort)
+    elif isinstance(frame.index, MultiIndex):
+        new_levels = list(frame.index.levels)
+        new_codes = [lab.repeat(K) for lab in frame.index.codes]
+        (clev, clab) = stack_factorize(frame.columns)
+        new_levels.append(clev)
+        new_codes.append(np.tile(clab, N).ravel())
+        new_names = list(frame.index.names)
+        new_names.append(frame.columns.name)
+        new_index = MultiIndex(levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False)
+    else:
+        (levels, (ilab, clab)) = zip(*map(stack_factorize, (frame.index, frame.columns)))
+        codes = (ilab.repeat(K), np.tile(clab, N).ravel())
+        new_index = MultiIndex(levels=levels, codes=codes, names=[frame.index.name, frame.columns.name], verify_integrity=False)
+    new_values: ArrayLike
+    if not frame.empty and frame._is_homogeneous_type:
+        dtypes = list(frame.dtypes._values)
+        dtype = dtypes[0]
+        if isinstance(dtype, ExtensionDtype):
+            arr = dtype.construct_array_type()
+            new_values = arr._concat_same_type([col._values for (_, col) in frame.items()])
+            new_values = _reorder_for_extension_array_stack(new_values, N, K)
+        else:
+            new_values = frame._values.ravel()
+    else:
+        new_values = frame._values.ravel()
+    if dropna:
+        mask = notna(new_values)
+        new_values = new_values[mask]
+        new_index = new_index[mask]
+    return frame._constructor_sliced(new_values, index=new_index)
+
+def stack_multiple(frame: DataFrame, level, dropna: bool=True, sort: bool=True):
+    if all((lev in frame.columns.names for lev in level)):
+        result = frame
+        for lev in level:
+            result = stack(result, lev, dropna=dropna, sort=sort)
+    elif all((isinstance(lev, int) for lev in level)):
+        result = frame
+        level = [frame.columns._get_level_number(lev) for lev in level]
+        while level:
+            lev = level.pop(0)
+            result = stack(result, lev, dropna=dropna, sort=sort)
+            level = [v if v <= lev else v - 1 for v in level]
+    else:
+        raise ValueError('level should contain all level names or all level numbers, not a mixture of the two.')
+    return result
+
+def _stack_multi_column_index(columns: MultiIndex) -> MultiIndex | Index:
+    if len(columns.levels) <= 2:
+        return columns.levels[0]._rename(name=columns.names[0])
+    levs = ([lev[c] if c >= 0 else None for c in codes] for (lev, codes) in zip(columns.levels[:-1], columns.codes[:-1]))
+    tuples = zip(*levs)
+    unique_tuples = (key for (key, _) in itertools.groupby(tuples))
+    new_levs = zip(*unique_tuples)
+    return MultiIndex.from_arrays([Index(new_lev, dtype=lev.dtype) if None not in new_lev else new_lev for (new_lev, lev) in zip(new_levs, columns.levels)], names=columns.names[:-1])
+
+def _stack_multi_columns(frame: DataFrame, level_num: int=-1, dropna: bool=True, sort: bool=True) -> DataFrame:
+
+    def _convert_level_number(level_num: int, columns: Index):
+        if level_num in columns.names:
+            return columns.names[level_num]
+        return level_num
+    this = frame.copy(deep=False)
+    mi_cols = this.columns
+    assert isinstance(mi_cols, MultiIndex)
+    if level_num != mi_cols.nlevels - 1:
+        roll_columns = mi_cols
+        for i in range(level_num, mi_cols.nlevels - 1):
+            lev1 = _convert_level_number(i, roll_columns)
+            lev2 = _convert_level_number(i + 1, roll_columns)
+            roll_columns = roll_columns.swaplevel(lev1, lev2)
+        this.columns = mi_cols = roll_columns
+    if not mi_cols._is_lexsorted() and sort:
+        level_to_sort = _convert_level_number(0, mi_cols)
+        this = this.sort_index(level=level_to_sort, axis=1)
+        mi_cols = this.columns
+    mi_cols = cast(MultiIndex, mi_cols)
+    new_columns = _stack_multi_column_index(mi_cols)
+    new_data = {}
+    level_vals = mi_cols.levels[-1]
+    level_codes = unique(mi_cols.codes[-1])
+    if sort:
+        level_codes = np.sort(level_codes)
+    level_vals_nan = level_vals.insert(len(level_vals), None)
+    level_vals_used = np.take(level_vals_nan, level_codes)
+    levsize = len(level_codes)
+    drop_cols = []
+    for key in new_columns:
+        try:
+            loc = this.columns.get_loc(key)
+        except KeyError:
+            drop_cols.append(key)
+            continue
+        if not isinstance(loc, slice):
+            slice_len = len(loc)
+        else:
+            slice_len = loc.stop - loc.start
+        if slice_len != levsize:
+            chunk = this.loc[:, this.columns[loc]]
+            chunk.columns = level_vals_nan.take(chunk.columns.codes[-1])
+            value_slice = chunk.reindex(columns=level_vals_used).values
+        else:
+            subset = this.iloc[:, loc]
+            dtype = find_common_type(subset.dtypes.tolist())
+            if isinstance(dtype, ExtensionDtype):
+                value_slice = dtype.construct_array_type()._concat_same_type([x._values.astype(dtype, copy=False) for (_, x) in subset.items()])
+                (N, K) = subset.shape
+                idx = np.arange(N * K).reshape(K, N).T.reshape(-1)
+                value_slice = value_slice.take(idx)
+            else:
+                value_slice = subset.values
+        if value_slice.ndim > 1:
+            value_slice = value_slice.ravel()
+        new_data[key] = value_slice
+    if len(drop_cols) > 0:
+        new_columns = new_columns.difference(drop_cols)
+    N = len(this)
+    if isinstance(this.index, MultiIndex):
+        new_levels = list(this.index.levels)
+        new_names = list(this.index.names)
+        new_codes = [lab.repeat(levsize) for lab in this.index.codes]
+    else:
+        (old_codes, old_levels) = factorize_from_iterable(this.index)
+        new_levels = [old_levels]
+        new_codes = [old_codes.repeat(levsize)]
+        new_names = [this.index.name]
+    new_levels.append(level_vals)
+    new_codes.append(np.tile(level_codes, N))
+    new_names.append(frame.columns.names[level_num])
+    new_index = MultiIndex(levels=new_levels, codes=new_codes, names=new_names, verify_integrity=False)
+    result = frame._constructor(new_data, index=new_index, columns=new_columns)
+    if frame.columns.nlevels > 1:
+        desired_columns = frame.columns._drop_level_numbers([level_num]).unique()
+        if not result.columns.equals(desired_columns):
+            result = result[desired_columns]
+    if dropna:
+        result = result.dropna(axis=0, how='all')
+    return result
+
+def _reorder_for_extension_array_stack(arr: ExtensionArray, n_rows: int, n_columns: int) -> ExtensionArray:
+    idx = np.arange(n_rows * n_columns).reshape(n_columns, n_rows).T.reshape(-1)
+    return arr.take(idx)
+
+def stack_v3(frame: DataFrame, level: list[int]) -> Series | DataFrame:
+    if frame.columns.nunique() != len(frame.columns):
+        raise ValueError('Columns with duplicate values are not supported in stack')
+    set_levels = set(level)
+    stack_cols = frame.columns._drop_level_numbers([k for k in range(frame.columns.nlevels - 1, -1, -1) if k not in set_levels])
+    result = stack_reshape(frame, level, set_levels, stack_cols)
+    ratio = 0 if frame.empty else len(result) // len(frame)
+    index_levels: list | FrozenList
+    if isinstance(frame.index, MultiIndex):
+        index_levels = frame.index.levels
+        index_codes = list(np.tile(frame.index.codes, (1, ratio)))
+    else:
+        (codes, uniques) = factorize(frame.index, use_na_sentinel=False)
+        index_levels = [uniques]
+        index_codes = list(np.tile(codes, (1, ratio)))
+    if len(level) > 1:
+        sorter = np.argsort(level)
+        assert isinstance(stack_cols, MultiIndex)
+        ordered_stack_cols = stack_cols._reorder_ilevels(sorter)
+    else:
+        ordered_stack_cols = stack_cols
+    ordered_stack_cols_unique = ordered_stack_cols.unique()
+    if isinstance(ordered_stack_cols, MultiIndex):
+        column_levels = ordered_stack_cols.levels
+        column_codes = ordered_stack_cols.drop_duplicates().codes
+    else:
+        column_levels = [ordered_stack_cols_unique]
+        column_codes = [factorize(ordered_stack_cols_unique, use_na_sentinel=False)[0]]
+    column_codes = [np.repeat(codes, len(frame)) for codes in column_codes]
+    result.index = MultiIndex(levels=index_levels + column_levels, codes=index_codes + column_codes, names=frame.index.names + list(ordered_stack_cols.names), verify_integrity=False)
+    len_df = len(frame)
+    n_uniques = len(ordered_stack_cols_unique)
+    indexer = np.arange(n_uniques)
+    idxs = np.tile(len_df * indexer, len_df) + np.repeat(np.arange(len_df), n_uniques)
+    result = result.take(idxs)
+    if result.ndim == 2 and frame.columns.nlevels == len(level):
+        if len(result.columns) == 0:
+            result = Series(index=result.index)
+        else:
+            result = result.iloc[:, 0]
+    if result.ndim == 1:
+        result.name = None
+    return result
+
+def stack_reshape(frame: DataFrame, level: list[int], set_levels: set[int], stack_cols: Index) -> Series | DataFrame:
+    drop_levnums = sorted(level, reverse=True)
+    buf = []
+    for idx in stack_cols.unique():
+        if len(frame.columns) == 1:
+            data = frame.copy(deep=False)
+        else:
+            if not isinstance(frame.columns, MultiIndex) and (not isinstance(idx, tuple)):
+                column_indexer = idx
+            else:
+                if len(level) == 1:
+                    idx = (idx,)
+                gen = iter(idx)
+                column_indexer = tuple((next(gen) if k in set_levels else slice(None) for k in range(frame.columns.nlevels)))
+            data = frame.loc[:, column_indexer]
+        if len(level) < frame.columns.nlevels:
+            data.columns = data.columns._drop_level_numbers(drop_levnums)
+        elif stack_cols.nlevels == 1:
+            if data.ndim == 1:
+                data.name = 0
+            else:
+                data.columns = default_index(len(data.columns))
+        buf.append(data)
+    if len(buf) > 0 and (not frame.empty):
+        result = concat(buf, ignore_index=True)
+    else:
+        if len(level) < frame.columns.nlevels:
+            new_columns = frame.columns._drop_level_numbers(drop_levnums).unique()
+        else:
+            new_columns = [0]
+        result = DataFrame(columns=new_columns, dtype=frame._values.dtype)
+    if len(level) < frame.columns.nlevels:
+        desired_columns = frame.columns._drop_level_numbers(drop_levnums).unique()
+        if not result.columns.equals(desired_columns):
+            result = result[desired_columns]
+    return result
+
+# File: pandas-main/pandas/core/reshape/tile.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Literal
+import numpy as np
+from pandas._libs import Timedelta, Timestamp, lib
+from pandas.core.dtypes.common import ensure_platform_int, is_bool_dtype, is_integer, is_list_like, is_numeric_dtype, is_scalar
+from pandas.core.dtypes.dtypes import CategoricalDtype, DatetimeTZDtype, ExtensionDtype
+from pandas.core.dtypes.generic import ABCSeries
+from pandas.core.dtypes.missing import isna
+from pandas import Categorical, Index, IntervalIndex
+import pandas.core.algorithms as algos
+from pandas.core.arrays.datetimelike import dtype_to_unit
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import DtypeObj, IntervalLeftRight
+
+def cut(x, bins, right: bool=True, labels=None, retbins: bool=False, precision: int=3, include_lowest: bool=False, duplicates: str='raise', ordered: bool=True):
+    original = x
+    x_idx = _preprocess_for_cut(x)
+    (x_idx, _) = _coerce_to_type(x_idx)
+    if not np.iterable(bins):
+        bins = _nbins_to_bins(x_idx, bins, right)
+    elif isinstance(bins, IntervalIndex):
+        if bins.is_overlapping:
+            raise ValueError('Overlapping IntervalIndex is not accepted.')
+    else:
+        bins = Index(bins)
+        if not bins.is_monotonic_increasing:
+            raise ValueError('bins must increase monotonically.')
+    (fac, bins) = _bins_to_cuts(x_idx, bins, right=right, labels=labels, precision=precision, include_lowest=include_lowest, duplicates=duplicates, ordered=ordered)
+    return _postprocess_for_cut(fac, bins, retbins, original)
+
+def qcut(x, q, labels=None, retbins: bool=False, precision: int=3, duplicates: str='raise'):
+    original = x
+    x_idx = _preprocess_for_cut(x)
+    (x_idx, _) = _coerce_to_type(x_idx)
+    if is_integer(q):
+        quantiles = np.linspace(0, 1, q + 1)
+        np.putmask(quantiles, q * quantiles != np.arange(q + 1), np.nextafter(quantiles, 1))
+    else:
+        quantiles = q
+    bins = x_idx.to_series().dropna().quantile(quantiles)
+    (fac, bins) = _bins_to_cuts(x_idx, Index(bins), labels=labels, precision=precision, include_lowest=True, duplicates=duplicates)
+    return _postprocess_for_cut(fac, bins, retbins, original)
+
+def _nbins_to_bins(x_idx: Index, nbins: int, right: bool) -> Index:
+    if is_scalar(nbins) and nbins < 1:
+        raise ValueError('`bins` should be a positive integer.')
+    if x_idx.size == 0:
+        raise ValueError('Cannot cut empty array')
+    rng = (x_idx.min(), x_idx.max())
+    (mn, mx) = rng
+    if is_numeric_dtype(x_idx.dtype) and (np.isinf(mn) or np.isinf(mx)):
+        raise ValueError('cannot specify integer `bins` when input data contains infinity')
+    if mn == mx:
+        if _is_dt_or_td(x_idx.dtype):
+            unit = dtype_to_unit(x_idx.dtype)
+            td = Timedelta(seconds=1).as_unit(unit)
+            bins = x_idx._values._generate_range(start=mn - td, end=mx + td, periods=nbins + 1, freq=None, unit=unit)
+        else:
+            mn -= 0.001 * abs(mn) if mn != 0 else 0.001
+            mx += 0.001 * abs(mx) if mx != 0 else 0.001
+            bins = np.linspace(mn, mx, nbins + 1, endpoint=True)
+    else:
+        if _is_dt_or_td(x_idx.dtype):
+            unit = dtype_to_unit(x_idx.dtype)
+            bins = x_idx._values._generate_range(start=mn, end=mx, periods=nbins + 1, freq=None, unit=unit)
+        else:
+            bins = np.linspace(mn, mx, nbins + 1, endpoint=True)
+        adj = (mx - mn) * 0.001
+        if right:
+            bins[0] -= adj
+        else:
+            bins[-1] += adj
+    return Index(bins)
+
+def _bins_to_cuts(x_idx: Index, bins: Index, right: bool=True, labels=None, precision: int=3, include_lowest: bool=False, duplicates: str='raise', ordered: bool=True):
+    if not ordered and labels is None:
+        raise ValueError("'labels' must be provided if 'ordered = False'")
+    if duplicates not in ['raise', 'drop']:
+        raise ValueError("invalid value for 'duplicates' parameter, valid options are: raise, drop")
+    result: Categorical | np.ndarray
+    if isinstance(bins, IntervalIndex):
+        ids = bins.get_indexer(x_idx)
+        cat_dtype = CategoricalDtype(bins, ordered=True)
+        result = Categorical.from_codes(ids, dtype=cat_dtype, validate=False)
+        return (result, bins)
+    unique_bins = algos.unique(bins)
+    if len(unique_bins) < len(bins) and len(bins) != 2:
+        if duplicates == 'raise':
+            raise ValueError(f"Bin edges must be unique: {bins!r}.\nYou can drop duplicate edges by setting the 'duplicates' kwarg")
+        bins = unique_bins
+    side: Literal['left', 'right'] = 'left' if right else 'right'
+    try:
+        ids = bins.searchsorted(x_idx, side=side)
+    except TypeError as err:
+        if x_idx.dtype.kind == 'm':
+            raise ValueError('bins must be of timedelta64 dtype') from err
+        elif x_idx.dtype.kind == bins.dtype.kind == 'M':
+            raise ValueError('Cannot use timezone-naive bins with timezone-aware values, or vice-versa') from err
+        elif x_idx.dtype.kind == 'M':
+            raise ValueError('bins must be of datetime64 dtype') from err
+        else:
+            raise
+    ids = ensure_platform_int(ids)
+    if include_lowest:
+        ids[x_idx == bins[0]] = 1
+    na_mask = isna(x_idx) | (ids == len(bins)) | (ids == 0)
+    has_nas = na_mask.any()
+    if labels is not False:
+        if not (labels is None or is_list_like(labels)):
+            raise ValueError('Bin labels must either be False, None or passed in as a list-like argument')
+        if labels is None:
+            labels = _format_labels(bins, precision, right=right, include_lowest=include_lowest)
+        elif ordered and len(set(labels)) != len(labels):
+            raise ValueError('labels must be unique if ordered=True; pass ordered=False for duplicate labels')
+        elif len(labels) != len(bins) - 1:
+            raise ValueError('Bin labels must be one fewer than the number of bin edges')
+        if not isinstance(getattr(labels, 'dtype', None), CategoricalDtype):
+            labels = Categorical(labels, categories=labels if len(set(labels)) == len(labels) else None, ordered=ordered)
+        np.putmask(ids, na_mask, 0)
+        result = algos.take_nd(labels, ids - 1)
+    else:
+        result = ids - 1
+        if has_nas:
+            result = result.astype(np.float64)
+            np.putmask(result, na_mask, np.nan)
+    return (result, bins)
+
+def _coerce_to_type(x: Index) -> tuple[Index, DtypeObj | None]:
+    dtype: DtypeObj | None = None
+    if _is_dt_or_td(x.dtype):
+        dtype = x.dtype
+    elif is_bool_dtype(x.dtype):
+        x = x.astype(np.int64)
+    elif isinstance(x.dtype, ExtensionDtype) and is_numeric_dtype(x.dtype):
+        x_arr = x.to_numpy(dtype=np.float64, na_value=np.nan)
+        x = Index(x_arr)
+    return (Index(x), dtype)
+
+def _is_dt_or_td(dtype: DtypeObj) -> bool:
+    return isinstance(dtype, DatetimeTZDtype) or lib.is_np_dtype(dtype, 'mM')
+
+def _format_labels(bins: Index, precision: int, right: bool=True, include_lowest: bool=False) -> IntervalIndex:
+    closed: IntervalLeftRight = 'right' if right else 'left'
+    formatter: Callable[[Any], Timestamp] | Callable[[Any], Timedelta]
+    if _is_dt_or_td(bins.dtype):
+        unit = dtype_to_unit(bins.dtype)
+        formatter = lambda x: x
+        adjust = lambda x: x - Timedelta(1, unit=unit).as_unit(unit)
+    else:
+        precision = _infer_precision(precision, bins)
+        formatter = lambda x: _round_frac(x, precision)
+        adjust = lambda x: x - 10 ** (-precision)
+    breaks = [formatter(b) for b in bins]
+    if right and include_lowest:
+        breaks[0] = adjust(breaks[0])
+    if _is_dt_or_td(bins.dtype):
+        breaks = type(bins)(breaks).as_unit(unit)
+    return IntervalIndex.from_breaks(breaks, closed=closed)
+
+def _preprocess_for_cut(x) -> Index:
+    ndim = getattr(x, 'ndim', None)
+    if ndim is None:
+        x = np.asarray(x)
+    if x.ndim != 1:
+        raise ValueError('Input array must be 1 dimensional')
+    return Index(x)
+
+def _postprocess_for_cut(fac, bins, retbins: bool, original):
+    if isinstance(original, ABCSeries):
+        fac = original._constructor(fac, index=original.index, name=original.name)
+    if not retbins:
+        return fac
+    if isinstance(bins, Index) and is_numeric_dtype(bins.dtype):
+        bins = bins._values
+    return (fac, bins)
+
+def _round_frac(x, precision: int):
+    if not np.isfinite(x) or x == 0:
+        return x
+    else:
+        (frac, whole) = np.modf(x)
+        if whole == 0:
+            digits = -int(np.floor(np.log10(abs(frac)))) - 1 + precision
+        else:
+            digits = precision
+        return np.around(x, digits)
+
+def _infer_precision(base_precision: int, bins: Index) -> int:
+    for precision in range(base_precision, 20):
+        levels = np.asarray([_round_frac(b, precision) for b in bins])
+        if algos.unique(levels).size == bins.size:
+            return precision
+    return base_precision
+
+# File: pandas-main/pandas/core/roperator.py
+""""""
+from __future__ import annotations
+import operator
+
+def radd(left, right):
+    return right + left
+
+def rsub(left, right):
+    return right - left
+
+def rmul(left, right):
+    return right * left
+
+def rdiv(left, right):
+    return right / left
+
+def rtruediv(left, right):
+    return right / left
+
+def rfloordiv(left, right):
+    return right // left
+
+def rmod(left, right):
+    if isinstance(right, str):
+        typ = type(left).__name__
+        raise TypeError(f'{typ} cannot perform the operation mod')
+    return right % left
+
+def rdivmod(left, right):
+    return divmod(right, left)
+
+def rpow(left, right):
+    return right ** left
+
+def rand_(left, right):
+    return operator.and_(right, left)
+
+def ror_(left, right):
+    return operator.or_(right, left)
+
+def rxor(left, right):
+    return operator.xor(right, left)
+
+# File: pandas-main/pandas/core/sample.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs import lib
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+if TYPE_CHECKING:
+    from pandas._typing import AxisInt
+    from pandas.core.generic import NDFrame
+
+def preprocess_weights(obj: NDFrame, weights, axis: AxisInt) -> np.ndarray:
+    if isinstance(weights, ABCSeries):
+        weights = weights.reindex(obj.axes[axis])
+    if isinstance(weights, str):
+        if isinstance(obj, ABCDataFrame):
+            if axis == 0:
+                try:
+                    weights = obj[weights]
+                except KeyError as err:
+                    raise KeyError('String passed to weights not a valid column') from err
+            else:
+                raise ValueError('Strings can only be passed to weights when sampling from rows on a DataFrame')
+        else:
+            raise ValueError('Strings cannot be passed as weights when sampling from a Series.')
+    if isinstance(obj, ABCSeries):
+        func = obj._constructor
+    else:
+        func = obj._constructor_sliced
+    weights = func(weights, dtype='float64')._values
+    if len(weights) != obj.shape[axis]:
+        raise ValueError('Weights and axis to be sampled must be of same length')
+    if lib.has_infs(weights):
+        raise ValueError('weight vector may not include `inf` values')
+    if (weights < 0).any():
+        raise ValueError('weight vector many not include negative values')
+    missing = np.isnan(weights)
+    if missing.any():
+        weights = weights.copy()
+        weights[missing] = 0
+    return weights
+
+def process_sampling_size(n: int | None, frac: float | None, replace: bool) -> int | None:
+    if n is None and frac is None:
+        n = 1
+    elif n is not None and frac is not None:
+        raise ValueError('Please enter a value for `frac` OR `n`, not both')
+    elif n is not None:
+        if n < 0:
+            raise ValueError('A negative number of rows requested. Please provide `n` >= 0.')
+        if n % 1 != 0:
+            raise ValueError('Only integers accepted as `n` values')
+    else:
+        assert frac is not None
+        if frac > 1 and (not replace):
+            raise ValueError('Replace has to be set to `True` when upsampling the population `frac` > 1.')
+        if frac < 0:
+            raise ValueError('A negative number of rows requested. Please provide `frac` >= 0.')
+    return n
+
+def sample(obj_len: int, size: int, replace: bool, weights: np.ndarray | None, random_state: np.random.RandomState | np.random.Generator) -> np.ndarray:
+    if weights is not None:
+        weight_sum = weights.sum()
+        if weight_sum != 0:
+            weights = weights / weight_sum
+        else:
+            raise ValueError('Invalid weights: weights sum to zero')
+    return random_state.choice(obj_len, size=size, replace=replace, p=weights).astype(np.intp, copy=False)
+
+# File: pandas-main/pandas/core/series.py
+""""""
+from __future__ import annotations
+from collections.abc import Callable, Hashable, Iterable, Mapping, Sequence
+import operator
+import sys
+from textwrap import dedent
+from typing import IO, TYPE_CHECKING, Any, Literal, cast, overload
+import warnings
+import numpy as np
+from pandas._libs import lib, properties, reshape
+from pandas._libs.lib import is_range_indexer
+from pandas.compat import PYPY
+from pandas.compat._constants import REF_COUNT
+from pandas.compat._optional import import_optional_dependency
+from pandas.compat.numpy import function as nv
+from pandas.errors import ChainedAssignmentError, InvalidIndexError
+from pandas.errors.cow import _chained_assignment_method_msg, _chained_assignment_msg
+from pandas.util._decorators import Appender, Substitution, deprecate_nonkeyword_arguments, doc
+from pandas.util._validators import validate_ascending, validate_bool_kwarg, validate_percentile
+from pandas.core.dtypes.astype import astype_is_view
+from pandas.core.dtypes.cast import LossySetitemError, construct_1d_arraylike_from_scalar, find_common_type, infer_dtype_from, maybe_box_native, maybe_cast_pointwise_result
+from pandas.core.dtypes.common import is_dict_like, is_float, is_integer, is_iterator, is_list_like, is_object_dtype, is_scalar, pandas_dtype, validate_all_hashable
+from pandas.core.dtypes.dtypes import CategoricalDtype, ExtensionDtype, SparseDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.dtypes.inference import is_hashable
+from pandas.core.dtypes.missing import isna, na_value_for_dtype, notna, remove_na_arraylike
+from pandas.core import algorithms, base, common as com, nanops, ops, roperator
+from pandas.core.accessor import Accessor
+from pandas.core.apply import SeriesApply
+from pandas.core.arrays import ExtensionArray
+from pandas.core.arrays.arrow import ListAccessor, StructAccessor
+from pandas.core.arrays.categorical import CategoricalAccessor
+from pandas.core.arrays.sparse import SparseAccessor
+from pandas.core.arrays.string_ import StringDtype
+from pandas.core.construction import array as pd_array, extract_array, sanitize_array
+from pandas.core.generic import NDFrame, make_doc
+from pandas.core.indexers import disallow_ndim_indexing, unpack_1tuple
+from pandas.core.indexes.accessors import CombinedDatetimelikeProperties
+from pandas.core.indexes.api import DatetimeIndex, Index, MultiIndex, PeriodIndex, default_index, ensure_index, maybe_sequence_to_range
+import pandas.core.indexes.base as ibase
+from pandas.core.indexes.multi import maybe_droplevels
+from pandas.core.indexing import check_bool_indexer, check_dict_or_set_indexers
+from pandas.core.internals import SingleBlockManager
+from pandas.core.methods import selectn
+from pandas.core.shared_docs import _shared_docs
+from pandas.core.sorting import ensure_key_mapped, nargsort
+from pandas.core.strings.accessor import StringMethods
+from pandas.core.tools.datetimes import to_datetime
+import pandas.io.formats.format as fmt
+from pandas.io.formats.info import INFO_DOCSTRING, SeriesInfo, series_sub_kwargs
+import pandas.plotting
+if TYPE_CHECKING:
+    from pandas._libs.internals import BlockValuesRefs
+    from pandas._typing import AggFuncType, AnyAll, AnyArrayLike, ArrayLike, Axis, AxisInt, CorrelationMethod, DropKeep, Dtype, DtypeObj, FilePath, Frequency, IgnoreRaise, IndexKeyFunc, IndexLabel, Level, ListLike, MutableMappingT, NaPosition, NumpySorter, NumpyValueArrayLike, QuantileInterpolation, ReindexMethod, Renamer, Scalar, Self, SortKind, StorageOptions, Suffixes, ValueKeyFunc, WriteBuffer, npt
+    from pandas.core.frame import DataFrame
+    from pandas.core.groupby.generic import SeriesGroupBy
+__all__ = ['Series']
+_shared_doc_kwargs = {'axes': 'index', 'klass': 'Series', 'axes_single_arg': "{0 or 'index'}", 'axis': "axis : {0 or 'index'}\n        Unused. Parameter needed for compatibility with DataFrame.", 'inplace': 'inplace : bool, default False\n        If True, performs operation inplace and returns None.', 'unique': 'np.ndarray', 'duplicated': 'Series', 'optional_by': '', 'optional_reindex': '\nindex : array-like, optional\n    New labels for the index. Preferably an Index object to avoid\n    duplicating data.\naxis : int or str, optional\n    Unused.'}
+
+class Series(base.IndexOpsMixin, NDFrame):
+    _typ = 'series'
+    _HANDLED_TYPES = (Index, ExtensionArray, np.ndarray)
+    _name: Hashable
+    _metadata: list[str] = ['_name']
+    _internal_names_set = {'index', 'name'} | NDFrame._internal_names_set
+    _accessors = {'dt', 'cat', 'str', 'sparse'}
+    _hidden_attrs = base.IndexOpsMixin._hidden_attrs | NDFrame._hidden_attrs | frozenset([])
+    __pandas_priority__ = 3000
+    hasnans = property(base.IndexOpsMixin.hasnans.fget, doc=base.IndexOpsMixin.hasnans.__doc__)
+    _mgr: SingleBlockManager
+
+    def __init__(self, data=None, index=None, dtype: Dtype | None=None, name=None, copy: bool | None=None) -> None:
+        allow_mgr = False
+        if isinstance(data, SingleBlockManager) and index is None and (dtype is None) and (copy is False or copy is None):
+            if not allow_mgr:
+                warnings.warn(f'Passing a {type(data).__name__} to {type(self).__name__} is deprecated and will raise in a future version. Use public APIs instead.', DeprecationWarning, stacklevel=2)
+            data = data.copy(deep=False)
+            NDFrame.__init__(self, data)
+            self.name = name
+            return
+        if isinstance(data, (ExtensionArray, np.ndarray)):
+            if copy is not False:
+                if dtype is None or astype_is_view(data.dtype, pandas_dtype(dtype)):
+                    data = data.copy()
+        if copy is None:
+            copy = False
+        if isinstance(data, SingleBlockManager) and (not copy):
+            data = data.copy(deep=False)
+            if not allow_mgr:
+                warnings.warn(f'Passing a {type(data).__name__} to {type(self).__name__} is deprecated and will raise in a future version. Use public APIs instead.', DeprecationWarning, stacklevel=2)
+        name = ibase.maybe_extract_name(name, data, type(self))
+        if index is not None:
+            index = ensure_index(index)
+        if dtype is not None:
+            dtype = self._validate_dtype(dtype)
+        if data is None:
+            index = index if index is not None else default_index(0)
+            if len(index) or dtype is not None:
+                data = na_value_for_dtype(pandas_dtype(dtype), compat=False)
+            else:
+                data = []
+        if isinstance(data, MultiIndex):
+            raise NotImplementedError('initializing a Series from a MultiIndex is not supported')
+        refs = None
+        if isinstance(data, Index):
+            if dtype is not None:
+                data = data.astype(dtype)
+            refs = data._references
+            copy = False
+        elif isinstance(data, np.ndarray):
+            if len(data.dtype):
+                raise ValueError('Cannot construct a Series from an ndarray with compound dtype.  Use DataFrame instead.')
+        elif isinstance(data, Series):
+            if index is None:
+                index = data.index
+                data = data._mgr.copy(deep=False)
+            else:
+                data = data.reindex(index)
+                copy = False
+                data = data._mgr
+        elif isinstance(data, Mapping):
+            (data, index) = self._init_dict(data, index, dtype)
+            dtype = None
+            copy = False
+        elif isinstance(data, SingleBlockManager):
+            if index is None:
+                index = data.index
+            elif not data.index.equals(index) or copy:
+                raise AssertionError('Cannot pass both SingleBlockManager `data` argument and a different `index` argument. `copy` must be False.')
+            if not allow_mgr:
+                warnings.warn(f'Passing a {type(data).__name__} to {type(self).__name__} is deprecated and will raise in a future version. Use public APIs instead.', DeprecationWarning, stacklevel=2)
+                allow_mgr = True
+        elif isinstance(data, ExtensionArray):
+            pass
+        else:
+            data = com.maybe_iterable_to_list(data)
+            if is_list_like(data) and (not len(data)) and (dtype is None):
+                dtype = np.dtype(object)
+        if index is None:
+            if not is_list_like(data):
+                data = [data]
+            index = default_index(len(data))
+        elif is_list_like(data):
+            com.require_length_match(data, index)
+        if isinstance(data, SingleBlockManager):
+            if dtype is not None:
+                data = data.astype(dtype=dtype, errors='ignore')
+            elif copy:
+                data = data.copy()
+        else:
+            data = sanitize_array(data, index, dtype, copy)
+            data = SingleBlockManager.from_array(data, index, refs=refs)
+        NDFrame.__init__(self, data)
+        self.name = name
+        self._set_axis(0, index)
+
+    def _init_dict(self, data: Mapping, index: Index | None=None, dtype: DtypeObj | None=None):
+        if data:
+            keys = maybe_sequence_to_range(tuple(data.keys()))
+            values = list(data.values())
+        elif index is not None:
+            if len(index) or dtype is not None:
+                values = na_value_for_dtype(pandas_dtype(dtype), compat=False)
+            else:
+                values = []
+            keys = index
+        else:
+            (keys, values) = (default_index(0), [])
+        s = Series(values, index=keys, dtype=dtype)
+        if data and index is not None:
+            s = s.reindex(index)
+        return (s._mgr, s.index)
+
+    def __arrow_c_stream__(self, requested_schema=None):
+        pa = import_optional_dependency('pyarrow', min_version='16.0.0')
+        type = pa.DataType._import_from_c_capsule(requested_schema) if requested_schema is not None else None
+        ca = pa.array(self, type=type)
+        if not isinstance(ca, pa.ChunkedArray):
+            ca = pa.chunked_array([ca])
+        return ca.__arrow_c_stream__()
+
+    @property
+    def _constructor(self) -> type[Series]:
+        return Series
+
+    def _constructor_from_mgr(self, mgr, axes):
+        ser = Series._from_mgr(mgr, axes=axes)
+        ser._name = None
+        if type(self) is Series:
+            return ser
+        return self._constructor(ser)
+
+    @property
+    def _constructor_expanddim(self) -> Callable[..., DataFrame]:
+        from pandas.core.frame import DataFrame
+        return DataFrame
+
+    def _constructor_expanddim_from_mgr(self, mgr, axes):
+        from pandas.core.frame import DataFrame
+        df = DataFrame._from_mgr(mgr, axes=mgr.axes)
+        if type(self) is Series:
+            return df
+        return self._constructor_expanddim(df)
+
+    @property
+    def _can_hold_na(self) -> bool:
+        return self._mgr._can_hold_na
+
+    @property
+    def dtype(self) -> DtypeObj:
+        return self._mgr.dtype
+
+    @property
+    def dtypes(self) -> DtypeObj:
+        return self.dtype
+
+    @property
+    def name(self) -> Hashable:
+        return self._name
+
+    @name.setter
+    def name(self, value: Hashable) -> None:
+        validate_all_hashable(value, error_name=f'{type(self).__name__}.name')
+        object.__setattr__(self, '_name', value)
+
+    @property
+    def values(self):
+        return self._mgr.external_values()
+
+    @property
+    def _values(self):
+        return self._mgr.internal_values()
+
+    @property
+    def _references(self) -> BlockValuesRefs:
+        return self._mgr._block.refs
+
+    @Appender(base.IndexOpsMixin.array.__doc__)
+    @property
+    def array(self) -> ExtensionArray:
+        return self._mgr.array_values()
+
+    def __len__(self) -> int:
+        return len(self._mgr)
+
+    def __array__(self, dtype: npt.DTypeLike | None=None, copy: bool | None=None) -> np.ndarray:
+        values = self._values
+        arr = np.asarray(values, dtype=dtype)
+        if astype_is_view(values.dtype, arr.dtype):
+            arr = arr.view()
+            arr.flags.writeable = False
+        return arr
+
+    @property
+    def axes(self) -> list[Index]:
+        return [self.index]
+
+    def _ixs(self, i: int, axis: AxisInt=0) -> Any:
+        return self._values[i]
+
+    def _slice(self, slobj: slice, axis: AxisInt=0) -> Series:
+        mgr = self._mgr.get_slice(slobj, axis=axis)
+        out = self._constructor_from_mgr(mgr, axes=mgr.axes)
+        out._name = self._name
+        return out.__finalize__(self)
+
+    def __getitem__(self, key):
+        check_dict_or_set_indexers(key)
+        key = com.apply_if_callable(key, self)
+        if key is Ellipsis:
+            return self.copy(deep=False)
+        key_is_scalar = is_scalar(key)
+        if isinstance(key, (list, tuple)):
+            key = unpack_1tuple(key)
+        elif key_is_scalar:
+            return self._get_value(key)
+        if is_iterator(key):
+            key = list(key)
+        if is_hashable(key) and (not isinstance(key, slice)):
+            try:
+                result = self._get_value(key)
+                return result
+            except (KeyError, TypeError, InvalidIndexError):
+                if isinstance(key, tuple) and isinstance(self.index, MultiIndex):
+                    return self._get_values_tuple(key)
+        if isinstance(key, slice):
+            return self._getitem_slice(key)
+        if com.is_bool_indexer(key):
+            key = check_bool_indexer(self.index, key)
+            key = np.asarray(key, dtype=bool)
+            return self._get_rows_with_mask(key)
+        return self._get_with(key)
+
+    def _get_with(self, key):
+        if isinstance(key, ABCDataFrame):
+            raise TypeError('Indexing a Series with DataFrame is not supported, use the appropriate DataFrame column')
+        elif isinstance(key, tuple):
+            return self._get_values_tuple(key)
+        return self.loc[key]
+
+    def _get_values_tuple(self, key: tuple):
+        if com.any_none(*key):
+            result = np.asarray(self._values[key])
+            disallow_ndim_indexing(result)
+            return result
+        if not isinstance(self.index, MultiIndex):
+            raise KeyError('key of type tuple not found and not a MultiIndex')
+        (indexer, new_index) = self.index.get_loc_level(key)
+        new_ser = self._constructor(self._values[indexer], index=new_index, copy=False)
+        if isinstance(indexer, slice):
+            new_ser._mgr.add_references(self._mgr)
+        return new_ser.__finalize__(self)
+
+    def _get_rows_with_mask(self, indexer: npt.NDArray[np.bool_]) -> Series:
+        new_mgr = self._mgr.get_rows_with_mask(indexer)
+        return self._constructor_from_mgr(new_mgr, axes=new_mgr.axes).__finalize__(self)
+
+    def _get_value(self, label, takeable: bool=False):
+        if takeable:
+            return self._values[label]
+        loc = self.index.get_loc(label)
+        if is_integer(loc):
+            return self._values[loc]
+        if isinstance(self.index, MultiIndex):
+            mi = self.index
+            new_values = self._values[loc]
+            if len(new_values) == 1 and mi.nlevels == 1:
+                return new_values[0]
+            new_index = mi[loc]
+            new_index = maybe_droplevels(new_index, label)
+            new_ser = self._constructor(new_values, index=new_index, name=self.name, copy=False)
+            if isinstance(loc, slice):
+                new_ser._mgr.add_references(self._mgr)
+            return new_ser.__finalize__(self)
+        else:
+            return self.iloc[loc]
+
+    def __setitem__(self, key, value) -> None:
+        if not PYPY:
+            if sys.getrefcount(self) <= 3:
+                warnings.warn(_chained_assignment_msg, ChainedAssignmentError, stacklevel=2)
+        check_dict_or_set_indexers(key)
+        key = com.apply_if_callable(key, self)
+        if key is Ellipsis:
+            key = slice(None)
+        if isinstance(key, slice):
+            indexer = self.index._convert_slice_indexer(key, kind='getitem')
+            return self._set_values(indexer, value)
+        try:
+            self._set_with_engine(key, value)
+        except KeyError:
+            self.loc[key] = value
+        except (TypeError, ValueError, LossySetitemError):
+            indexer = self.index.get_loc(key)
+            self._set_values(indexer, value)
+        except InvalidIndexError as err:
+            if isinstance(key, tuple) and (not isinstance(self.index, MultiIndex)):
+                raise KeyError('key of type tuple not found and not a MultiIndex') from err
+            if com.is_bool_indexer(key):
+                key = check_bool_indexer(self.index, key)
+                key = np.asarray(key, dtype=bool)
+                if is_list_like(value) and len(value) != len(self) and (not isinstance(value, Series)) and (not is_object_dtype(self.dtype)):
+                    indexer = key.nonzero()[0]
+                    self._set_values(indexer, value)
+                    return
+                try:
+                    self._where(~key, value, inplace=True)
+                except InvalidIndexError:
+                    self.iloc[key] = value
+                return
+            else:
+                self._set_with(key, value)
+
+    def _set_with_engine(self, key, value) -> None:
+        loc = self.index.get_loc(key)
+        self._mgr.setitem_inplace(loc, value)
+
+    def _set_with(self, key, value) -> None:
+        assert not isinstance(key, tuple)
+        if is_iterator(key):
+            key = list(key)
+        self._set_labels(key, value)
+
+    def _set_labels(self, key, value) -> None:
+        key = com.asarray_tuplesafe(key)
+        indexer: np.ndarray = self.index.get_indexer(key)
+        mask = indexer == -1
+        if mask.any():
+            raise KeyError(f'{key[mask]} not in index')
+        self._set_values(indexer, value)
+
+    def _set_values(self, key, value) -> None:
+        if isinstance(key, (Index, Series)):
+            key = key._values
+        self._mgr = self._mgr.setitem(indexer=key, value=value)
+
+    def _set_value(self, label, value, takeable: bool=False) -> None:
+        if not takeable:
+            try:
+                loc = self.index.get_loc(label)
+            except KeyError:
+                self.loc[label] = value
+                return
+        else:
+            loc = label
+        self._set_values(loc, value)
+
+    def repeat(self, repeats: int | Sequence[int], axis: None=None) -> Series:
+        nv.validate_repeat((), {'axis': axis})
+        new_index = self.index.repeat(repeats)
+        new_values = self._values.repeat(repeats)
+        return self._constructor(new_values, index=new_index, copy=False).__finalize__(self, method='repeat')
+
+    @overload
+    def reset_index(self, level: IndexLabel=..., *, drop: Literal[False]=..., name: Level=..., inplace: Literal[False]=..., allow_duplicates: bool=...) -> DataFrame:
+        ...
+
+    @overload
+    def reset_index(self, level: IndexLabel=..., *, drop: Literal[True], name: Level=..., inplace: Literal[False]=..., allow_duplicates: bool=...) -> Series:
+        ...
+
+    @overload
+    def reset_index(self, level: IndexLabel=..., *, drop: bool=..., name: Level=..., inplace: Literal[True], allow_duplicates: bool=...) -> None:
+        ...
+
+    def reset_index(self, level: IndexLabel | None=None, *, drop: bool=False, name: Level=lib.no_default, inplace: bool=False, allow_duplicates: bool=False) -> DataFrame | Series | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        if drop:
+            new_index = default_index(len(self))
+            if level is not None:
+                level_list: Sequence[Hashable]
+                if not isinstance(level, (tuple, list)):
+                    level_list = [level]
+                else:
+                    level_list = level
+                level_list = [self.index._get_level_number(lev) for lev in level_list]
+                if len(level_list) < self.index.nlevels:
+                    new_index = self.index.droplevel(level_list)
+            if inplace:
+                self.index = new_index
+            else:
+                new_ser = self.copy(deep=False)
+                new_ser.index = new_index
+                return new_ser.__finalize__(self, method='reset_index')
+        elif inplace:
+            raise TypeError('Cannot reset_index inplace on a Series to create a DataFrame')
+        else:
+            if name is lib.no_default:
+                if self.name is None:
+                    name = 0
+                else:
+                    name = self.name
+            df = self.to_frame(name)
+            return df.reset_index(level=level, drop=drop, allow_duplicates=allow_duplicates)
+        return None
+
+    def __repr__(self) -> str:
+        repr_params = fmt.get_series_repr_params()
+        return self.to_string(**repr_params)
+
+    @overload
+    def to_string(self, buf: None=..., *, na_rep: str=..., float_format: str | None=..., header: bool=..., index: bool=..., length: bool=..., dtype=..., name=..., max_rows: int | None=..., min_rows: int | None=...) -> str:
+        ...
+
+    @overload
+    def to_string(self, buf: FilePath | WriteBuffer[str], *, na_rep: str=..., float_format: str | None=..., header: bool=..., index: bool=..., length: bool=..., dtype=..., name=..., max_rows: int | None=..., min_rows: int | None=...) -> None:
+        ...
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self', 'buf'], name='to_string')
+    def to_string(self, buf: FilePath | WriteBuffer[str] | None=None, na_rep: str='NaN', float_format: str | None=None, header: bool=True, index: bool=True, length: bool=False, dtype: bool=False, name: bool=False, max_rows: int | None=None, min_rows: int | None=None) -> str | None:
+        formatter = fmt.SeriesFormatter(self, name=name, length=length, header=header, index=index, dtype=dtype, na_rep=na_rep, float_format=float_format, min_rows=min_rows, max_rows=max_rows)
+        result = formatter.to_string()
+        if not isinstance(result, str):
+            raise AssertionError(f'result must be of type str, type of result is {type(result).__name__!r}')
+        if buf is None:
+            return result
+        elif hasattr(buf, 'write'):
+            buf.write(result)
+        else:
+            with open(buf, 'w', encoding='utf-8') as f:
+                f.write(result)
+        return None
+
+    @overload
+    def to_markdown(self, buf: None=..., *, mode: str=..., index: bool=..., storage_options: StorageOptions | None=..., **kwargs) -> str:
+        ...
+
+    @overload
+    def to_markdown(self, buf: IO[str], *, mode: str=..., index: bool=..., storage_options: StorageOptions | None=..., **kwargs) -> None:
+        ...
+
+    @overload
+    def to_markdown(self, buf: IO[str] | None, *, mode: str=..., index: bool=..., storage_options: StorageOptions | None=..., **kwargs) -> str | None:
+        ...
+
+    @doc(klass=_shared_doc_kwargs['klass'], storage_options=_shared_docs['storage_options'], examples=dedent('Examples\n            --------\n            >>> s = pd.Series(["elk", "pig", "dog", "quetzal"], name="animal")\n            >>> print(s.to_markdown())\n            |    | animal   |\n            |---:|:---------|\n            |  0 | elk      |\n            |  1 | pig      |\n            |  2 | dog      |\n            |  3 | quetzal  |\n\n            Output markdown with a tabulate option.\n\n            >>> print(s.to_markdown(tablefmt="grid"))\n            +----+----------+\n            |    | animal   |\n            +====+==========+\n            |  0 | elk      |\n            +----+----------+\n            |  1 | pig      |\n            +----+----------+\n            |  2 | dog      |\n            +----+----------+\n            |  3 | quetzal  |\n            +----+----------+'))
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self', 'buf'], name='to_markdown')
+    def to_markdown(self, buf: IO[str] | None=None, mode: str='wt', index: bool=True, storage_options: StorageOptions | None=None, **kwargs) -> str | None:
+        return self.to_frame().to_markdown(buf, mode=mode, index=index, storage_options=storage_options, **kwargs)
+
+    def items(self) -> Iterable[tuple[Hashable, Any]]:
+        return zip(iter(self.index), iter(self))
+
+    def keys(self) -> Index:
+        return self.index
+
+    @overload
+    def to_dict(self, *, into: type[MutableMappingT] | MutableMappingT) -> MutableMappingT:
+        ...
+
+    @overload
+    def to_dict(self, *, into: type[dict]=...) -> dict:
+        ...
+
+    def to_dict(self, *, into: type[MutableMappingT] | MutableMappingT=dict) -> MutableMappingT:
+        into_c = com.standardize_mapping(into)
+        if is_object_dtype(self.dtype) or isinstance(self.dtype, ExtensionDtype):
+            return into_c(((k, maybe_box_native(v)) for (k, v) in self.items()))
+        else:
+            return into_c(self.items())
+
+    def to_frame(self, name: Hashable=lib.no_default) -> DataFrame:
+        columns: Index
+        if name is lib.no_default:
+            name = self.name
+            if name is None:
+                columns = default_index(1)
+            else:
+                columns = Index([name])
+        else:
+            columns = Index([name])
+        mgr = self._mgr.to_2d_mgr(columns)
+        df = self._constructor_expanddim_from_mgr(mgr, axes=mgr.axes)
+        return df.__finalize__(self, method='to_frame')
+
+    def _set_name(self, name, inplace: bool=False, deep: bool | None=None) -> Series:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        ser = self if inplace else self.copy(deep=False)
+        ser.name = name
+        return ser
+
+    @Appender(dedent('\n        Examples\n        --------\n        >>> ser = pd.Series([390., 350., 30., 20.],\n        ...                 index=[\'Falcon\', \'Falcon\', \'Parrot\', \'Parrot\'],\n        ...                 name="Max Speed")\n        >>> ser\n        Falcon    390.0\n        Falcon    350.0\n        Parrot     30.0\n        Parrot     20.0\n        Name: Max Speed, dtype: float64\n\n        We can pass a list of values to group the Series data by custom labels:\n\n        >>> ser.groupby(["a", "b", "a", "b"]).mean()\n        a    210.0\n        b    185.0\n        Name: Max Speed, dtype: float64\n\n        Grouping by numeric labels yields similar results:\n\n        >>> ser.groupby([0, 1, 0, 1]).mean()\n        0    210.0\n        1    185.0\n        Name: Max Speed, dtype: float64\n\n        We can group by a level of the index:\n\n        >>> ser.groupby(level=0).mean()\n        Falcon    370.0\n        Parrot     25.0\n        Name: Max Speed, dtype: float64\n\n        We can group by a condition applied to the Series values:\n\n        >>> ser.groupby(ser > 100).mean()\n        Max Speed\n        False     25.0\n        True     370.0\n        Name: Max Speed, dtype: float64\n\n        **Grouping by Indexes**\n\n        We can groupby different levels of a hierarchical index\n        using the `level` parameter:\n\n        >>> arrays = [[\'Falcon\', \'Falcon\', \'Parrot\', \'Parrot\'],\n        ...           [\'Captive\', \'Wild\', \'Captive\', \'Wild\']]\n        >>> index = pd.MultiIndex.from_arrays(arrays, names=(\'Animal\', \'Type\'))\n        >>> ser = pd.Series([390., 350., 30., 20.], index=index, name="Max Speed")\n        >>> ser\n        Animal  Type\n        Falcon  Captive    390.0\n                Wild       350.0\n        Parrot  Captive     30.0\n                Wild        20.0\n        Name: Max Speed, dtype: float64\n\n        >>> ser.groupby(level=0).mean()\n        Animal\n        Falcon    370.0\n        Parrot     25.0\n        Name: Max Speed, dtype: float64\n\n        We can also group by the \'Type\' level of the hierarchical index\n        to get the mean speed for each type:\n\n        >>> ser.groupby(level="Type").mean()\n        Type\n        Captive    210.0\n        Wild       185.0\n        Name: Max Speed, dtype: float64\n\n        We can also choose to include `NA` in group keys or not by defining\n        `dropna` parameter, the default setting is `True`.\n\n        >>> ser = pd.Series([1, 2, 3, 3], index=["a", \'a\', \'b\', np.nan])\n        >>> ser.groupby(level=0).sum()\n        a    3\n        b    3\n        dtype: int64\n\n        To include `NA` values in the group keys, set `dropna=False`:\n\n        >>> ser.groupby(level=0, dropna=False).sum()\n        a    3\n        b    3\n        NaN  3\n        dtype: int64\n\n        We can also group by a custom list with NaN values to handle\n        missing group labels:\n\n        >>> arrays = [\'Falcon\', \'Falcon\', \'Parrot\', \'Parrot\']\n        >>> ser = pd.Series([390., 350., 30., 20.], index=arrays, name="Max Speed")\n        >>> ser.groupby(["a", "b", "a", np.nan]).mean()\n        a    210.0\n        b    350.0\n        Name: Max Speed, dtype: float64\n\n        >>> ser.groupby(["a", "b", "a", np.nan], dropna=False).mean()\n        a    210.0\n        b    350.0\n        NaN   20.0\n        Name: Max Speed, dtype: float64\n        '))
+    @Appender(_shared_docs['groupby'] % _shared_doc_kwargs)
+    def groupby(self, by=None, level: IndexLabel | None=None, as_index: bool=True, sort: bool=True, group_keys: bool=True, observed: bool=False, dropna: bool=True) -> SeriesGroupBy:
+        from pandas.core.groupby.generic import SeriesGroupBy
+        if level is None and by is None:
+            raise TypeError("You have to supply one of 'by' and 'level'")
+        if not as_index:
+            raise TypeError('as_index=False only valid with DataFrame')
+        return SeriesGroupBy(obj=self, keys=by, level=level, as_index=as_index, sort=sort, group_keys=group_keys, observed=observed, dropna=dropna)
+
+    def count(self) -> int:
+        return notna(self._values).sum().astype('int64')
+
+    def mode(self, dropna: bool=True) -> Series:
+        values = self._values
+        if isinstance(values, np.ndarray):
+            res_values = algorithms.mode(values, dropna=dropna)
+        else:
+            res_values = values._mode(dropna=dropna)
+        return self._constructor(res_values, index=range(len(res_values)), name=self.name, copy=False, dtype=self.dtype).__finalize__(self, method='mode')
+
+    def unique(self) -> ArrayLike:
+        return super().unique()
+
+    @overload
+    def drop_duplicates(self, *, keep: DropKeep=..., inplace: Literal[False]=..., ignore_index: bool=...) -> Series:
+        ...
+
+    @overload
+    def drop_duplicates(self, *, keep: DropKeep=..., inplace: Literal[True], ignore_index: bool=...) -> None:
+        ...
+
+    @overload
+    def drop_duplicates(self, *, keep: DropKeep=..., inplace: bool=..., ignore_index: bool=...) -> Series | None:
+        ...
+
+    def drop_duplicates(self, *, keep: DropKeep='first', inplace: bool=False, ignore_index: bool=False) -> Series | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        result = super().drop_duplicates(keep=keep)
+        if ignore_index:
+            result.index = default_index(len(result))
+        if inplace:
+            self._update_inplace(result)
+            return None
+        else:
+            return result
+
+    def duplicated(self, keep: DropKeep='first') -> Series:
+        res = self._duplicated(keep=keep)
+        result = self._constructor(res, index=self.index, copy=False)
+        return result.__finalize__(self, method='duplicated')
+
+    def idxmin(self, axis: Axis=0, skipna: bool=True, *args, **kwargs) -> Hashable:
+        axis = self._get_axis_number(axis)
+        iloc = self.argmin(axis, skipna, *args, **kwargs)
+        return self.index[iloc]
+
+    def idxmax(self, axis: Axis=0, skipna: bool=True, *args, **kwargs) -> Hashable:
+        axis = self._get_axis_number(axis)
+        iloc = self.argmax(axis, skipna, *args, **kwargs)
+        return self.index[iloc]
+
+    def round(self, decimals: int=0, *args, **kwargs) -> Series:
+        nv.validate_round(args, kwargs)
+        new_mgr = self._mgr.round(decimals=decimals)
+        return self._constructor_from_mgr(new_mgr, axes=new_mgr.axes).__finalize__(self, method='round')
+
+    @overload
+    def quantile(self, q: float=..., interpolation: QuantileInterpolation=...) -> float:
+        ...
+
+    @overload
+    def quantile(self, q: Sequence[float] | AnyArrayLike, interpolation: QuantileInterpolation=...) -> Series:
+        ...
+
+    @overload
+    def quantile(self, q: float | Sequence[float] | AnyArrayLike=..., interpolation: QuantileInterpolation=...) -> float | Series:
+        ...
+
+    def quantile(self, q: float | Sequence[float] | AnyArrayLike=0.5, interpolation: QuantileInterpolation='linear') -> float | Series:
+        validate_percentile(q)
+        df = self.to_frame()
+        result = df.quantile(q=q, interpolation=interpolation, numeric_only=False)
+        if result.ndim == 2:
+            result = result.iloc[:, 0]
+        if is_list_like(q):
+            result.name = self.name
+            idx = Index(q, dtype=np.float64)
+            return self._constructor(result, index=idx, name=self.name)
+        else:
+            return result.iloc[0]
+
+    def corr(self, other: Series, method: CorrelationMethod='pearson', min_periods: int | None=None) -> float:
+        (this, other) = self.align(other, join='inner')
+        if len(this) == 0:
+            return np.nan
+        this_values = this.to_numpy(dtype=float, na_value=np.nan, copy=False)
+        other_values = other.to_numpy(dtype=float, na_value=np.nan, copy=False)
+        if method in ['pearson', 'spearman', 'kendall'] or callable(method):
+            return nanops.nancorr(this_values, other_values, method=method, min_periods=min_periods)
+        raise ValueError(f"method must be either 'pearson', 'spearman', 'kendall', or a callable, '{method}' was supplied")
+
+    def cov(self, other: Series, min_periods: int | None=None, ddof: int | None=1) -> float:
+        (this, other) = self.align(other, join='inner')
+        if len(this) == 0:
+            return np.nan
+        this_values = this.to_numpy(dtype=float, na_value=np.nan, copy=False)
+        other_values = other.to_numpy(dtype=float, na_value=np.nan, copy=False)
+        return nanops.nancov(this_values, other_values, min_periods=min_periods, ddof=ddof)
+
+    @doc(klass='Series', extra_params='', other_klass='DataFrame', examples=dedent('\n        Difference with previous row\n\n        >>> s = pd.Series([1, 1, 2, 3, 5, 8])\n        >>> s.diff()\n        0    NaN\n        1    0.0\n        2    1.0\n        3    1.0\n        4    2.0\n        5    3.0\n        dtype: float64\n\n        Difference with 3rd previous row\n\n        >>> s.diff(periods=3)\n        0    NaN\n        1    NaN\n        2    NaN\n        3    2.0\n        4    4.0\n        5    6.0\n        dtype: float64\n\n        Difference with following row\n\n        >>> s.diff(periods=-1)\n        0    0.0\n        1   -1.0\n        2   -1.0\n        3   -2.0\n        4   -3.0\n        5    NaN\n        dtype: float64\n\n        Overflow in input dtype\n\n        >>> s = pd.Series([1, 0], dtype=np.uint8)\n        >>> s.diff()\n        0      NaN\n        1    255.0\n        dtype: float64'))
+    def diff(self, periods: int=1) -> Series:
+        if not lib.is_integer(periods):
+            if not (is_float(periods) and periods.is_integer()):
+                raise ValueError('periods must be an integer')
+        result = algorithms.diff(self._values, periods)
+        return self._constructor(result, index=self.index, copy=False).__finalize__(self, method='diff')
+
+    def autocorr(self, lag: int=1) -> float:
+        return self.corr(cast(Series, self.shift(lag)))
+
+    def dot(self, other: AnyArrayLike | DataFrame) -> Series | np.ndarray:
+        if isinstance(other, (Series, ABCDataFrame)):
+            common = self.index.union(other.index)
+            if len(common) > len(self.index) or len(common) > len(other.index):
+                raise ValueError('matrices are not aligned')
+            left = self.reindex(index=common)
+            right = other.reindex(index=common)
+            lvals = left.values
+            rvals = right.values
+        else:
+            lvals = self.values
+            rvals = np.asarray(other)
+            if lvals.shape[0] != rvals.shape[0]:
+                raise Exception(f'Dot product shape mismatch, {lvals.shape} vs {rvals.shape}')
+        if isinstance(other, ABCDataFrame):
+            return self._constructor(np.dot(lvals, rvals), index=other.columns, copy=False).__finalize__(self, method='dot')
+        elif isinstance(other, Series):
+            return np.dot(lvals, rvals)
+        elif isinstance(rvals, np.ndarray):
+            return np.dot(lvals, rvals)
+        else:
+            raise TypeError(f'unsupported type: {type(other)}')
+
+    def __matmul__(self, other):
+        return self.dot(other)
+
+    def __rmatmul__(self, other):
+        return self.dot(np.transpose(other))
+
+    @doc(base.IndexOpsMixin.searchsorted, klass='Series')
+    def searchsorted(self, value: NumpyValueArrayLike | ExtensionArray, side: Literal['left', 'right']='left', sorter: NumpySorter | None=None) -> npt.NDArray[np.intp] | np.intp:
+        return base.IndexOpsMixin.searchsorted(self, value, side=side, sorter=sorter)
+
+    def _append(self, to_append, ignore_index: bool=False, verify_integrity: bool=False):
+        from pandas.core.reshape.concat import concat
+        if isinstance(to_append, (list, tuple)):
+            to_concat = [self]
+            to_concat.extend(to_append)
+        else:
+            to_concat = [self, to_append]
+        if any((isinstance(x, (ABCDataFrame,)) for x in to_concat[1:])):
+            msg = 'to_append should be a Series or list/tuple of Series, got DataFrame'
+            raise TypeError(msg)
+        return concat(to_concat, ignore_index=ignore_index, verify_integrity=verify_integrity)
+
+    @doc(_shared_docs['compare'], dedent('\n        Returns\n        -------\n        Series or DataFrame\n            If axis is 0 or \'index\' the result will be a Series.\n            The resulting index will be a MultiIndex with \'self\' and \'other\'\n            stacked alternately at the inner level.\n\n            If axis is 1 or \'columns\' the result will be a DataFrame.\n            It will have two columns namely \'self\' and \'other\'.\n\n        See Also\n        --------\n        DataFrame.compare : Compare with another DataFrame and show differences.\n\n        Notes\n        -----\n        Matching NaNs will not appear as a difference.\n\n        Examples\n        --------\n        >>> s1 = pd.Series(["a", "b", "c", "d", "e"])\n        >>> s2 = pd.Series(["a", "a", "c", "b", "e"])\n\n        Align the differences on columns\n\n        >>> s1.compare(s2)\n          self other\n        1    b     a\n        3    d     b\n\n        Stack the differences on indices\n\n        >>> s1.compare(s2, align_axis=0)\n        1  self     b\n           other    a\n        3  self     d\n           other    b\n        dtype: object\n\n        Keep all original rows\n\n        >>> s1.compare(s2, keep_shape=True)\n          self other\n        0  NaN   NaN\n        1    b     a\n        2  NaN   NaN\n        3    d     b\n        4  NaN   NaN\n\n        Keep all original rows and also all original values\n\n        >>> s1.compare(s2, keep_shape=True, keep_equal=True)\n          self other\n        0    a     a\n        1    b     a\n        2    c     c\n        3    d     b\n        4    e     e\n        '), klass=_shared_doc_kwargs['klass'])
+    def compare(self, other: Series, align_axis: Axis=1, keep_shape: bool=False, keep_equal: bool=False, result_names: Suffixes=('self', 'other')) -> DataFrame | Series:
+        return super().compare(other=other, align_axis=align_axis, keep_shape=keep_shape, keep_equal=keep_equal, result_names=result_names)
+
+    def combine(self, other: Series | Hashable, func: Callable[[Hashable, Hashable], Hashable], fill_value: Hashable | None=None) -> Series:
+        if fill_value is None:
+            fill_value = na_value_for_dtype(self.dtype, compat=False)
+        if isinstance(other, Series):
+            new_index = self.index.union(other.index)
+            new_name = ops.get_op_result_name(self, other)
+            new_values = np.empty(len(new_index), dtype=object)
+            with np.errstate(all='ignore'):
+                for (i, idx) in enumerate(new_index):
+                    lv = self.get(idx, fill_value)
+                    rv = other.get(idx, fill_value)
+                    new_values[i] = func(lv, rv)
+        else:
+            new_index = self.index
+            new_values = np.empty(len(new_index), dtype=object)
+            with np.errstate(all='ignore'):
+                new_values[:] = [func(lv, other) for lv in self._values]
+            new_name = self.name
+        npvalues = lib.maybe_convert_objects(new_values, try_float=False)
+        same_dtype = isinstance(self.dtype, (StringDtype, CategoricalDtype))
+        res_values = maybe_cast_pointwise_result(npvalues, self.dtype, same_dtype=same_dtype)
+        return self._constructor(res_values, index=new_index, name=new_name, copy=False)
+
+    def combine_first(self, other) -> Series:
+        from pandas.core.reshape.concat import concat
+        if self.dtype == other.dtype:
+            if self.index.equals(other.index):
+                return self.mask(self.isna(), other)
+            elif self._can_hold_na and (not isinstance(self.dtype, SparseDtype)):
+                (this, other) = self.align(other, join='outer')
+                return this.mask(this.isna(), other)
+        new_index = self.index.union(other.index)
+        this = self
+        keep_other = other.index.difference(this.index[notna(this)])
+        keep_this = this.index.difference(keep_other)
+        this = this.reindex(keep_this)
+        other = other.reindex(keep_other)
+        if this.dtype.kind == 'M' and other.dtype.kind != 'M':
+            other = to_datetime(other)
+        combined = concat([this, other])
+        combined = combined.reindex(new_index)
+        return combined.__finalize__(self, method='combine_first')
+
+    def update(self, other: Series | Sequence | Mapping) -> None:
+        if not PYPY:
+            if sys.getrefcount(self) <= REF_COUNT:
+                warnings.warn(_chained_assignment_method_msg, ChainedAssignmentError, stacklevel=2)
+        if not isinstance(other, Series):
+            other = Series(other)
+        other = other.reindex_like(self)
+        mask = notna(other)
+        self._mgr = self._mgr.putmask(mask=mask, new=other)
+
+    @overload
+    def sort_values(self, *, axis: Axis=..., ascending: bool | Sequence[bool]=..., inplace: Literal[False]=..., kind: SortKind=..., na_position: NaPosition=..., ignore_index: bool=..., key: ValueKeyFunc=...) -> Series:
+        ...
+
+    @overload
+    def sort_values(self, *, axis: Axis=..., ascending: bool | Sequence[bool]=..., inplace: Literal[True], kind: SortKind=..., na_position: NaPosition=..., ignore_index: bool=..., key: ValueKeyFunc=...) -> None:
+        ...
+
+    @overload
+    def sort_values(self, *, axis: Axis=..., ascending: bool | Sequence[bool]=..., inplace: bool=..., kind: SortKind=..., na_position: NaPosition=..., ignore_index: bool=..., key: ValueKeyFunc=...) -> Series | None:
+        ...
+
+    def sort_values(self, *, axis: Axis=0, ascending: bool | Sequence[bool]=True, inplace: bool=False, kind: SortKind='quicksort', na_position: NaPosition='last', ignore_index: bool=False, key: ValueKeyFunc | None=None) -> Series | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        self._get_axis_number(axis)
+        if is_list_like(ascending):
+            ascending = cast(Sequence[bool], ascending)
+            if len(ascending) != 1:
+                raise ValueError(f'Length of ascending ({len(ascending)}) must be 1 for Series')
+            ascending = ascending[0]
+        ascending = validate_ascending(ascending)
+        if na_position not in ['first', 'last']:
+            raise ValueError(f'invalid na_position: {na_position}')
+        if key:
+            values_to_sort = cast(Series, ensure_key_mapped(self, key))._values
+        else:
+            values_to_sort = self._values
+        sorted_index = nargsort(values_to_sort, kind, bool(ascending), na_position)
+        if is_range_indexer(sorted_index, len(sorted_index)):
+            if inplace:
+                return self._update_inplace(self)
+            return self.copy(deep=False)
+        result = self._constructor(self._values[sorted_index], index=self.index[sorted_index], copy=False)
+        if ignore_index:
+            result.index = default_index(len(sorted_index))
+        if not inplace:
+            return result.__finalize__(self, method='sort_values')
+        self._update_inplace(result)
+        return None
+
+    @overload
+    def sort_index(self, *, axis: Axis=..., level: IndexLabel=..., ascending: bool | Sequence[bool]=..., inplace: Literal[True], kind: SortKind=..., na_position: NaPosition=..., sort_remaining: bool=..., ignore_index: bool=..., key: IndexKeyFunc=...) -> None:
+        ...
+
+    @overload
+    def sort_index(self, *, axis: Axis=..., level: IndexLabel=..., ascending: bool | Sequence[bool]=..., inplace: Literal[False]=..., kind: SortKind=..., na_position: NaPosition=..., sort_remaining: bool=..., ignore_index: bool=..., key: IndexKeyFunc=...) -> Series:
+        ...
+
+    @overload
+    def sort_index(self, *, axis: Axis=..., level: IndexLabel=..., ascending: bool | Sequence[bool]=..., inplace: bool=..., kind: SortKind=..., na_position: NaPosition=..., sort_remaining: bool=..., ignore_index: bool=..., key: IndexKeyFunc=...) -> Series | None:
+        ...
+
+    def sort_index(self, *, axis: Axis=0, level: IndexLabel | None=None, ascending: bool | Sequence[bool]=True, inplace: bool=False, kind: SortKind='quicksort', na_position: NaPosition='last', sort_remaining: bool=True, ignore_index: bool=False, key: IndexKeyFunc | None=None) -> Series | None:
+        return super().sort_index(axis=axis, level=level, ascending=ascending, inplace=inplace, kind=kind, na_position=na_position, sort_remaining=sort_remaining, ignore_index=ignore_index, key=key)
+
+    def argsort(self, axis: Axis=0, kind: SortKind='quicksort', order: None=None, stable: None=None) -> Series:
+        if axis != -1:
+            self._get_axis_number(axis)
+        result = self.array.argsort(kind=kind)
+        res = self._constructor(result, index=self.index, name=self.name, dtype=np.intp, copy=False)
+        return res.__finalize__(self, method='argsort')
+
+    def nlargest(self, n: int=5, keep: Literal['first', 'last', 'all']='first') -> Series:
+        return selectn.SelectNSeries(self, n=n, keep=keep).nlargest()
+
+    def nsmallest(self, n: int=5, keep: Literal['first', 'last', 'all']='first') -> Series:
+        return selectn.SelectNSeries(self, n=n, keep=keep).nsmallest()
+
+    def swaplevel(self, i: Level=-2, j: Level=-1, copy: bool | lib.NoDefault=lib.no_default) -> Series:
+        self._check_copy_deprecation(copy)
+        assert isinstance(self.index, MultiIndex)
+        result = self.copy(deep=False)
+        result.index = self.index.swaplevel(i, j)
+        return result
+
+    def reorder_levels(self, order: Sequence[Level]) -> Series:
+        if not isinstance(self.index, MultiIndex):
+            raise Exception('Can only reorder levels on a hierarchical axis.')
+        result = self.copy(deep=False)
+        assert isinstance(result.index, MultiIndex)
+        result.index = result.index.reorder_levels(order)
+        return result
+
+    def explode(self, ignore_index: bool=False) -> Series:
+        if isinstance(self.dtype, ExtensionDtype):
+            (values, counts) = self._values._explode()
+        elif len(self) and is_object_dtype(self.dtype):
+            (values, counts) = reshape.explode(np.asarray(self._values))
+        else:
+            result = self.copy()
+            return result.reset_index(drop=True) if ignore_index else result
+        if ignore_index:
+            index: Index = default_index(len(values))
+        else:
+            index = self.index.repeat(counts)
+        return self._constructor(values, index=index, name=self.name, copy=False)
+
+    def unstack(self, level: IndexLabel=-1, fill_value: Hashable | None=None, sort: bool=True) -> DataFrame:
+        from pandas.core.reshape.reshape import unstack
+        return unstack(self, level, fill_value, sort)
+
+    def map(self, arg: Callable | Mapping | Series, na_action: Literal['ignore'] | None=None) -> Series:
+        new_values = self._map_values(arg, na_action=na_action)
+        return self._constructor(new_values, index=self.index, copy=False).__finalize__(self, method='map')
+
+    def _gotitem(self, key, ndim, subset=None) -> Self:
+        return self
+    _agg_see_also_doc = dedent('\n    See Also\n    --------\n    Series.apply : Invoke function on a Series.\n    Series.transform : Transform function producing a Series with like indexes.\n    ')
+    _agg_examples_doc = dedent("\n    Examples\n    --------\n    >>> s = pd.Series([1, 2, 3, 4])\n    >>> s\n    0    1\n    1    2\n    2    3\n    3    4\n    dtype: int64\n\n    >>> s.agg('min')\n    1\n\n    >>> s.agg(['min', 'max'])\n    min   1\n    max   4\n    dtype: int64\n    ")
+
+    @doc(_shared_docs['aggregate'], klass=_shared_doc_kwargs['klass'], axis=_shared_doc_kwargs['axis'], see_also=_agg_see_also_doc, examples=_agg_examples_doc)
+    def aggregate(self, func=None, axis: Axis=0, *args, **kwargs):
+        self._get_axis_number(axis)
+        if func is None:
+            func = dict(kwargs.items())
+        op = SeriesApply(self, func, args=args, kwargs=kwargs)
+        result = op.agg()
+        return result
+    agg = aggregate
+
+    @doc(_shared_docs['transform'], klass=_shared_doc_kwargs['klass'], axis=_shared_doc_kwargs['axis'])
+    def transform(self, func: AggFuncType, axis: Axis=0, *args, **kwargs) -> DataFrame | Series:
+        self._get_axis_number(axis)
+        ser = self.copy(deep=False)
+        result = SeriesApply(ser, func=func, args=args, kwargs=kwargs).transform()
+        return result
+
+    def apply(self, func: AggFuncType, args: tuple[Any, ...]=(), *, by_row: Literal[False, 'compat']='compat', **kwargs) -> DataFrame | Series:
+        return SeriesApply(self, func, by_row=by_row, args=args, kwargs=kwargs).apply()
+
+    def _reindex_indexer(self, new_index: Index | None, indexer: npt.NDArray[np.intp] | None) -> Series:
+        if indexer is None and (new_index is None or new_index.names == self.index.names):
+            return self.copy(deep=False)
+        new_values = algorithms.take_nd(self._values, indexer, allow_fill=True, fill_value=None)
+        return self._constructor(new_values, index=new_index, copy=False)
+
+    def _needs_reindex_multi(self, axes, method, level) -> bool:
+        return False
+
+    @overload
+    def rename(self, index: Renamer | Hashable | None=..., *, axis: Axis | None=..., copy: bool | lib.NoDefault=..., inplace: Literal[True], level: Level | None=..., errors: IgnoreRaise=...) -> None:
+        ...
+
+    @overload
+    def rename(self, index: Renamer | Hashable | None=..., *, axis: Axis | None=..., copy: bool | lib.NoDefault=..., inplace: Literal[False]=..., level: Level | None=..., errors: IgnoreRaise=...) -> Series:
+        ...
+
+    @overload
+    def rename(self, index: Renamer | Hashable | None=..., *, axis: Axis | None=..., copy: bool | lib.NoDefault=..., inplace: bool=..., level: Level | None=..., errors: IgnoreRaise=...) -> Series | None:
+        ...
+
+    def rename(self, index: Renamer | Hashable | None=None, *, axis: Axis | None=None, copy: bool | lib.NoDefault=lib.no_default, inplace: bool=False, level: Level | None=None, errors: IgnoreRaise='ignore') -> Series | None:
+        self._check_copy_deprecation(copy)
+        if axis is not None:
+            axis = self._get_axis_number(axis)
+        if callable(index) or is_dict_like(index):
+            return super()._rename(index, inplace=inplace, level=level, errors=errors)
+        else:
+            return self._set_name(index, inplace=inplace)
+
+    @Appender("\n        Examples\n        --------\n        >>> s = pd.Series([1, 2, 3])\n        >>> s\n        0    1\n        1    2\n        2    3\n        dtype: int64\n\n        >>> s.set_axis(['a', 'b', 'c'], axis=0)\n        a    1\n        b    2\n        c    3\n        dtype: int64\n    ")
+    @Substitution(klass=_shared_doc_kwargs['klass'], axes_single_arg=_shared_doc_kwargs['axes_single_arg'], extended_summary_sub='', axis_description_sub='', see_also_sub='')
+    @Appender(NDFrame.set_axis.__doc__)
+    def set_axis(self, labels, *, axis: Axis=0, copy: bool | lib.NoDefault=lib.no_default) -> Series:
+        return super().set_axis(labels, axis=axis, copy=copy)
+
+    @doc(NDFrame.reindex, klass=_shared_doc_kwargs['klass'], optional_reindex=_shared_doc_kwargs['optional_reindex'])
+    def reindex(self, index=None, *, axis: Axis | None=None, method: ReindexMethod | None=None, copy: bool | lib.NoDefault=lib.no_default, level: Level | None=None, fill_value: Scalar | None=None, limit: int | None=None, tolerance=None) -> Series:
+        return super().reindex(index=index, method=method, level=level, fill_value=fill_value, limit=limit, tolerance=tolerance, copy=copy)
+
+    @overload
+    def rename_axis(self, mapper: IndexLabel | lib.NoDefault=..., *, index=..., axis: Axis=..., copy: bool | lib.NoDefault=..., inplace: Literal[True]) -> None:
+        ...
+
+    @overload
+    def rename_axis(self, mapper: IndexLabel | lib.NoDefault=..., *, index=..., axis: Axis=..., copy: bool | lib.NoDefault=..., inplace: Literal[False]=...) -> Self:
+        ...
+
+    @overload
+    def rename_axis(self, mapper: IndexLabel | lib.NoDefault=..., *, index=..., axis: Axis=..., copy: bool | lib.NoDefault=..., inplace: bool=...) -> Self | None:
+        ...
+
+    def rename_axis(self, mapper: IndexLabel | lib.NoDefault=lib.no_default, *, index=lib.no_default, axis: Axis=0, copy: bool | lib.NoDefault=lib.no_default, inplace: bool=False) -> Self | None:
+        return super().rename_axis(mapper=mapper, index=index, axis=axis, inplace=inplace, copy=copy)
+
+    @overload
+    def drop(self, labels: IndexLabel | ListLike=..., *, axis: Axis=..., index: IndexLabel | ListLike=..., columns: IndexLabel | ListLike=..., level: Level | None=..., inplace: Literal[True], errors: IgnoreRaise=...) -> None:
+        ...
+
+    @overload
+    def drop(self, labels: IndexLabel | ListLike=..., *, axis: Axis=..., index: IndexLabel | ListLike=..., columns: IndexLabel | ListLike=..., level: Level | None=..., inplace: Literal[False]=..., errors: IgnoreRaise=...) -> Series:
+        ...
+
+    @overload
+    def drop(self, labels: IndexLabel | ListLike=..., *, axis: Axis=..., index: IndexLabel | ListLike=..., columns: IndexLabel | ListLike=..., level: Level | None=..., inplace: bool=..., errors: IgnoreRaise=...) -> Series | None:
+        ...
+
+    def drop(self, labels: IndexLabel | ListLike=None, *, axis: Axis=0, index: IndexLabel | ListLike=None, columns: IndexLabel | ListLike=None, level: Level | None=None, inplace: bool=False, errors: IgnoreRaise='raise') -> Series | None:
+        return super().drop(labels=labels, axis=axis, index=index, columns=columns, level=level, inplace=inplace, errors=errors)
+
+    def pop(self, item: Hashable) -> Any:
+        return super().pop(item=item)
+
+    @doc(INFO_DOCSTRING, **series_sub_kwargs)
+    def info(self, verbose: bool | None=None, buf: IO[str] | None=None, max_cols: int | None=None, memory_usage: bool | str | None=None, show_counts: bool=True) -> None:
+        return SeriesInfo(self, memory_usage).render(buf=buf, max_cols=max_cols, verbose=verbose, show_counts=show_counts)
+
+    def memory_usage(self, index: bool=True, deep: bool=False) -> int:
+        v = self._memory_usage(deep=deep)
+        if index:
+            v += self.index.memory_usage(deep=deep)
+        return v
+
+    def isin(self, values) -> Series:
+        result = algorithms.isin(self._values, values)
+        return self._constructor(result, index=self.index, copy=False).__finalize__(self, method='isin')
+
+    def between(self, left, right, inclusive: Literal['both', 'neither', 'left', 'right']='both') -> Series:
+        if inclusive == 'both':
+            lmask = self >= left
+            rmask = self <= right
+        elif inclusive == 'left':
+            lmask = self >= left
+            rmask = self < right
+        elif inclusive == 'right':
+            lmask = self > left
+            rmask = self <= right
+        elif inclusive == 'neither':
+            lmask = self > left
+            rmask = self < right
+        else:
+            raise ValueError("Inclusive has to be either string of 'both','left', 'right', or 'neither'.")
+        return lmask & rmask
+
+    def case_when(self, caselist: list[tuple[ArrayLike | Callable[[Series], Series | np.ndarray | Sequence[bool]], ArrayLike | Scalar | Callable[[Series], Series | np.ndarray]],]) -> Series:
+        if not isinstance(caselist, list):
+            raise TypeError(f'The caselist argument should be a list; instead got {type(caselist)}')
+        if not caselist:
+            raise ValueError('provide at least one boolean condition, with a corresponding replacement.')
+        for (num, entry) in enumerate(caselist):
+            if not isinstance(entry, tuple):
+                raise TypeError(f'Argument {num} must be a tuple; instead got {type(entry)}.')
+            if len(entry) != 2:
+                raise ValueError(f'Argument {num} must have length 2; a condition and replacement; instead got length {len(entry)}.')
+        caselist = [(com.apply_if_callable(condition, self), com.apply_if_callable(replacement, self)) for (condition, replacement) in caselist]
+        default = self.copy(deep=False)
+        (conditions, replacements) = zip(*caselist)
+        common_dtypes = [infer_dtype_from(arg)[0] for arg in [*replacements, default]]
+        if len(set(common_dtypes)) > 1:
+            common_dtype = find_common_type(common_dtypes)
+            updated_replacements = []
+            for (condition, replacement) in zip(conditions, replacements):
+                if is_scalar(replacement):
+                    replacement = construct_1d_arraylike_from_scalar(value=replacement, length=len(condition), dtype=common_dtype)
+                elif isinstance(replacement, ABCSeries):
+                    replacement = replacement.astype(common_dtype)
+                else:
+                    replacement = pd_array(replacement, dtype=common_dtype)
+                updated_replacements.append(replacement)
+            replacements = updated_replacements
+            default = default.astype(common_dtype)
+        counter = range(len(conditions) - 1, -1, -1)
+        for (position, condition, replacement) in zip(counter, reversed(conditions), reversed(replacements)):
+            try:
+                default = default.mask(condition, other=replacement, axis=0, inplace=False, level=None)
+            except Exception as error:
+                raise ValueError(f'Failed to apply condition{position} and replacement{position}.') from error
+        return default
+
+    @doc(NDFrame.isna, klass=_shared_doc_kwargs['klass'])
+    def isna(self) -> Series:
+        return NDFrame.isna(self)
+
+    @doc(NDFrame.isna, klass=_shared_doc_kwargs['klass'])
+    def isnull(self) -> Series:
+        return super().isnull()
+
+    @doc(NDFrame.notna, klass=_shared_doc_kwargs['klass'])
+    def notna(self) -> Series:
+        return super().notna()
+
+    @doc(NDFrame.notna, klass=_shared_doc_kwargs['klass'])
+    def notnull(self) -> Series:
+        return super().notnull()
+
+    @overload
+    def dropna(self, *, axis: Axis=..., inplace: Literal[False]=..., how: AnyAll | None=..., ignore_index: bool=...) -> Series:
+        ...
+
+    @overload
+    def dropna(self, *, axis: Axis=..., inplace: Literal[True], how: AnyAll | None=..., ignore_index: bool=...) -> None:
+        ...
+
+    def dropna(self, *, axis: Axis=0, inplace: bool=False, how: AnyAll | None=None, ignore_index: bool=False) -> Series | None:
+        inplace = validate_bool_kwarg(inplace, 'inplace')
+        ignore_index = validate_bool_kwarg(ignore_index, 'ignore_index')
+        self._get_axis_number(axis or 0)
+        if self._can_hold_na:
+            result = remove_na_arraylike(self)
+        elif not inplace:
+            result = self.copy(deep=False)
+        else:
+            result = self
+        if ignore_index:
+            result.index = default_index(len(result))
+        if inplace:
+            return self._update_inplace(result)
+        else:
+            return result
+
+    def to_timestamp(self, freq: Frequency | None=None, how: Literal['s', 'e', 'start', 'end']='start', copy: bool | lib.NoDefault=lib.no_default) -> Series:
+        self._check_copy_deprecation(copy)
+        if not isinstance(self.index, PeriodIndex):
+            raise TypeError(f'unsupported Type {type(self.index).__name__}')
+        new_obj = self.copy(deep=False)
+        new_index = self.index.to_timestamp(freq=freq, how=how)
+        setattr(new_obj, 'index', new_index)
+        return new_obj
+
+    def to_period(self, freq: str | None=None, copy: bool | lib.NoDefault=lib.no_default) -> Series:
+        self._check_copy_deprecation(copy)
+        if not isinstance(self.index, DatetimeIndex):
+            raise TypeError(f'unsupported Type {type(self.index).__name__}')
+        new_obj = self.copy(deep=False)
+        new_index = self.index.to_period(freq=freq)
+        setattr(new_obj, 'index', new_index)
+        return new_obj
+    _AXIS_ORDERS: list[Literal['index', 'columns']] = ['index']
+    _AXIS_LEN = len(_AXIS_ORDERS)
+    _info_axis_number: Literal[0] = 0
+    _info_axis_name: Literal['index'] = 'index'
+    index = properties.AxisProperty(axis=0, doc="\n        The index (axis labels) of the Series.\n\n        The index of a Series is used to label and identify each element of the\n        underlying data. The index can be thought of as an immutable ordered set\n        (technically a multi-set, as it may contain duplicate labels), and is\n        used to index and align data in pandas.\n\n        Returns\n        -------\n        Index\n            The index labels of the Series.\n\n        See Also\n        --------\n        Series.reindex : Conform Series to new index.\n        Index : The base pandas index type.\n\n        Notes\n        -----\n        For more information on pandas indexing, see the `indexing user guide\n        <https://pandas.pydata.org/docs/user_guide/indexing.html>`__.\n\n        Examples\n        --------\n        To create a Series with a custom index and view the index labels:\n\n        >>> cities = ['Kolkata', 'Chicago', 'Toronto', 'Lisbon']\n        >>> populations = [14.85, 2.71, 2.93, 0.51]\n        >>> city_series = pd.Series(populations, index=cities)\n        >>> city_series.index\n        Index(['Kolkata', 'Chicago', 'Toronto', 'Lisbon'], dtype='object')\n\n        To change the index labels of an existing Series:\n\n        >>> city_series.index = ['KOL', 'CHI', 'TOR', 'LIS']\n        >>> city_series.index\n        Index(['KOL', 'CHI', 'TOR', 'LIS'], dtype='object')\n        ")
+    str = Accessor('str', StringMethods)
+    dt = Accessor('dt', CombinedDatetimelikeProperties)
+    cat = Accessor('cat', CategoricalAccessor)
+    plot = Accessor('plot', pandas.plotting.PlotAccessor)
+    sparse = Accessor('sparse', SparseAccessor)
+    struct = Accessor('struct', StructAccessor)
+    list = Accessor('list', ListAccessor)
+    hist = pandas.plotting.hist_series
+
+    def _cmp_method(self, other, op):
+        res_name = ops.get_op_result_name(self, other)
+        if isinstance(other, Series) and (not self._indexed_same(other)):
+            raise ValueError('Can only compare identically-labeled Series objects')
+        lvalues = self._values
+        rvalues = extract_array(other, extract_numpy=True, extract_range=True)
+        res_values = ops.comparison_op(lvalues, rvalues, op)
+        return self._construct_result(res_values, name=res_name)
+
+    def _logical_method(self, other, op):
+        res_name = ops.get_op_result_name(self, other)
+        (self, other) = self._align_for_op(other, align_asobject=True)
+        lvalues = self._values
+        rvalues = extract_array(other, extract_numpy=True, extract_range=True)
+        res_values = ops.logical_op(lvalues, rvalues, op)
+        return self._construct_result(res_values, name=res_name)
+
+    def _arith_method(self, other, op):
+        (self, other) = self._align_for_op(other)
+        return base.IndexOpsMixin._arith_method(self, other, op)
+
+    def _align_for_op(self, right, align_asobject: bool=False):
+        left = self
+        if isinstance(right, Series):
+            if not left.index.equals(right.index):
+                if align_asobject:
+                    if left.dtype not in (object, np.bool_) or right.dtype not in (object, np.bool_):
+                        pass
+                    else:
+                        left = left.astype(object)
+                        right = right.astype(object)
+                (left, right) = left.align(right)
+        return (left, right)
+
+    def _binop(self, other: Series, func, level=None, fill_value=None) -> Series:
+        this = self
+        if not self.index.equals(other.index):
+            (this, other) = self.align(other, level=level, join='outer')
+        (this_vals, other_vals) = ops.fill_binop(this._values, other._values, fill_value)
+        with np.errstate(all='ignore'):
+            result = func(this_vals, other_vals)
+        name = ops.get_op_result_name(self, other)
+        out = this._construct_result(result, name)
+        return cast(Series, out)
+
+    def _construct_result(self, result: ArrayLike | tuple[ArrayLike, ArrayLike], name: Hashable) -> Series | tuple[Series, Series]:
+        if isinstance(result, tuple):
+            res1 = self._construct_result(result[0], name=name)
+            res2 = self._construct_result(result[1], name=name)
+            assert isinstance(res1, Series)
+            assert isinstance(res2, Series)
+            return (res1, res2)
+        dtype = getattr(result, 'dtype', None)
+        out = self._constructor(result, index=self.index, dtype=dtype, copy=False)
+        out = out.__finalize__(self)
+        out.name = name
+        return out
+
+    def _flex_method(self, other, op, *, level=None, fill_value=None, axis: Axis=0):
+        if axis is not None:
+            self._get_axis_number(axis)
+        res_name = ops.get_op_result_name(self, other)
+        if isinstance(other, Series):
+            return self._binop(other, op, level=level, fill_value=fill_value)
+        elif isinstance(other, (np.ndarray, list, tuple)):
+            if len(other) != len(self):
+                raise ValueError('Lengths must be equal')
+            other = self._constructor(other, self.index, copy=False)
+            result = self._binop(other, op, level=level, fill_value=fill_value)
+            result._name = res_name
+            return result
+        else:
+            if fill_value is not None:
+                if isna(other):
+                    return op(self, fill_value)
+                self = self.fillna(fill_value)
+            return op(self, other)
+
+    def eq(self, other, level: Level | None=None, fill_value: float | None=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.eq, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('ne', 'series'))
+    def ne(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.ne, level=level, fill_value=fill_value, axis=axis)
+
+    def le(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.le, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('lt', 'series'))
+    def lt(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.lt, level=level, fill_value=fill_value, axis=axis)
+
+    def ge(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.ge, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('gt', 'series'))
+    def gt(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.gt, level=level, fill_value=fill_value, axis=axis)
+
+    def add(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.add, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('radd', 'series'))
+    def radd(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, roperator.radd, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('sub', 'series'))
+    def sub(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.sub, level=level, fill_value=fill_value, axis=axis)
+    subtract = sub
+
+    @Appender(ops.make_flex_doc('rsub', 'series'))
+    def rsub(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, roperator.rsub, level=level, fill_value=fill_value, axis=axis)
+
+    def mul(self, other, level: Level | None=None, fill_value: float | None=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.mul, level=level, fill_value=fill_value, axis=axis)
+    multiply = mul
+
+    @Appender(ops.make_flex_doc('rmul', 'series'))
+    def rmul(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, roperator.rmul, level=level, fill_value=fill_value, axis=axis)
+
+    def truediv(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.truediv, level=level, fill_value=fill_value, axis=axis)
+    div = truediv
+    divide = truediv
+
+    @Appender(ops.make_flex_doc('rtruediv', 'series'))
+    def rtruediv(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, roperator.rtruediv, level=level, fill_value=fill_value, axis=axis)
+    rdiv = rtruediv
+
+    @Appender(ops.make_flex_doc('floordiv', 'series'))
+    def floordiv(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.floordiv, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('rfloordiv', 'series'))
+    def rfloordiv(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, roperator.rfloordiv, level=level, fill_value=fill_value, axis=axis)
+
+    def mod(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.mod, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('rmod', 'series'))
+    def rmod(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, roperator.rmod, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('pow', 'series'))
+    def pow(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, operator.pow, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('rpow', 'series'))
+    def rpow(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, roperator.rpow, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('divmod', 'series'))
+    def divmod(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, divmod, level=level, fill_value=fill_value, axis=axis)
+
+    @Appender(ops.make_flex_doc('rdivmod', 'series'))
+    def rdivmod(self, other, level=None, fill_value=None, axis: Axis=0) -> Series:
+        return self._flex_method(other, roperator.rdivmod, level=level, fill_value=fill_value, axis=axis)
+
+    def _reduce(self, op, name: str, *, axis: Axis=0, skipna: bool=True, numeric_only: bool=False, filter_type=None, **kwds):
+        delegate = self._values
+        if axis is not None:
+            self._get_axis_number(axis)
+        if isinstance(delegate, ExtensionArray):
+            return delegate._reduce(name, skipna=skipna, **kwds)
+        else:
+            if numeric_only and self.dtype.kind not in 'iufcb':
+                kwd_name = 'numeric_only'
+                if name in ['any', 'all']:
+                    kwd_name = 'bool_only'
+                raise TypeError(f'Series.{name} does not allow {kwd_name}={numeric_only} with non-numeric dtypes.')
+            return op(delegate, skipna=skipna, **kwds)
+
+    @Appender(make_doc('any', ndim=1))
+    def any(self, *, axis: Axis=0, bool_only: bool=False, skipna: bool=True, **kwargs) -> bool:
+        nv.validate_logical_func((), kwargs, fname='any')
+        validate_bool_kwarg(skipna, 'skipna', none_allowed=False)
+        return self._reduce(nanops.nanany, name='any', axis=axis, numeric_only=bool_only, skipna=skipna, filter_type='bool')
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='all')
+    @Appender(make_doc('all', ndim=1))
+    def all(self, axis: Axis=0, bool_only: bool=False, skipna: bool=True, **kwargs) -> bool:
+        nv.validate_logical_func((), kwargs, fname='all')
+        validate_bool_kwarg(skipna, 'skipna', none_allowed=False)
+        return self._reduce(nanops.nanall, name='all', axis=axis, numeric_only=bool_only, skipna=skipna, filter_type='bool')
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='min')
+    def min(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs):
+        return NDFrame.min(self, axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='max')
+    def max(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs):
+        return NDFrame.max(self, axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='sum')
+    def sum(self, axis: Axis | None=None, skipna: bool=True, numeric_only: bool=False, min_count: int=0, **kwargs):
+        return NDFrame.sum(self, axis=axis, skipna=skipna, numeric_only=numeric_only, min_count=min_count, **kwargs)
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='prod')
+    @doc(make_doc('prod', ndim=1))
+    def prod(self, axis: Axis | None=None, skipna: bool=True, numeric_only: bool=False, min_count: int=0, **kwargs):
+        return NDFrame.prod(self, axis=axis, skipna=skipna, numeric_only=numeric_only, min_count=min_count, **kwargs)
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='mean')
+    def mean(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Any:
+        return NDFrame.mean(self, axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='median')
+    def median(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs) -> Any:
+        return NDFrame.median(self, axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='sem')
+    @doc(make_doc('sem', ndim=1))
+    def sem(self, axis: Axis | None=None, skipna: bool=True, ddof: int=1, numeric_only: bool=False, **kwargs):
+        return NDFrame.sem(self, axis=axis, skipna=skipna, ddof=ddof, numeric_only=numeric_only, **kwargs)
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='var')
+    def var(self, axis: Axis | None=None, skipna: bool=True, ddof: int=1, numeric_only: bool=False, **kwargs):
+        return NDFrame.var(self, axis=axis, skipna=skipna, ddof=ddof, numeric_only=numeric_only, **kwargs)
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='std')
+    @doc(make_doc('std', ndim=1))
+    def std(self, axis: Axis | None=None, skipna: bool=True, ddof: int=1, numeric_only: bool=False, **kwargs):
+        return NDFrame.std(self, axis=axis, skipna=skipna, ddof=ddof, numeric_only=numeric_only, **kwargs)
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='skew')
+    @doc(make_doc('skew', ndim=1))
+    def skew(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs):
+        return NDFrame.skew(self, axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+
+    @deprecate_nonkeyword_arguments(version='4.0', allowed_args=['self'], name='kurt')
+    def kurt(self, axis: Axis | None=0, skipna: bool=True, numeric_only: bool=False, **kwargs):
+        return NDFrame.kurt(self, axis=axis, skipna=skipna, numeric_only=numeric_only, **kwargs)
+    kurtosis = kurt
+    product = prod
+
+    @doc(make_doc('cummin', ndim=1))
+    def cummin(self, axis: Axis=0, skipna: bool=True, *args, **kwargs) -> Self:
+        return NDFrame.cummin(self, axis, skipna, *args, **kwargs)
+
+    @doc(make_doc('cummax', ndim=1))
+    def cummax(self, axis: Axis=0, skipna: bool=True, *args, **kwargs) -> Self:
+        return NDFrame.cummax(self, axis, skipna, *args, **kwargs)
+
+    @doc(make_doc('cumsum', ndim=1))
+    def cumsum(self, axis: Axis=0, skipna: bool=True, *args, **kwargs) -> Self:
+        return NDFrame.cumsum(self, axis, skipna, *args, **kwargs)
+
+    @doc(make_doc('cumprod', 1))
+    def cumprod(self, axis: Axis=0, skipna: bool=True, *args, **kwargs) -> Self:
+        return NDFrame.cumprod(self, axis, skipna, *args, **kwargs)
+
+# File: pandas-main/pandas/core/shared_docs.py
+from __future__ import annotations
+_shared_docs: dict[str, str] = {}
+_shared_docs['aggregate'] = "\nAggregate using one or more operations over the specified axis.\n\nParameters\n----------\nfunc : function, str, list or dict\n    Function to use for aggregating the data. If a function, must either\n    work when passed a {klass} or when passed to {klass}.apply.\n\n    Accepted combinations are:\n\n    - function\n    - string function name\n    - list of functions and/or function names, e.g. ``[np.sum, 'mean']``\n    - dict of axis labels -> functions, function names or list of such.\n{axis}\n*args\n    Positional arguments to pass to `func`.\n**kwargs\n    Keyword arguments to pass to `func`.\n\nReturns\n-------\nscalar, Series or DataFrame\n\n    The return can be:\n\n    * scalar : when Series.agg is called with single function\n    * Series : when DataFrame.agg is called with a single function\n    * DataFrame : when DataFrame.agg is called with several functions\n{see_also}\nNotes\n-----\nThe aggregation operations are always performed over an axis, either the\nindex (default) or the column axis. This behavior is different from\n`numpy` aggregation functions (`mean`, `median`, `prod`, `sum`, `std`,\n`var`), where the default is to compute the aggregation of the flattened\narray, e.g., ``numpy.mean(arr_2d)`` as opposed to\n``numpy.mean(arr_2d, axis=0)``.\n\n`agg` is an alias for `aggregate`. Use the alias.\n\nFunctions that mutate the passed object can produce unexpected\nbehavior or errors and are not supported. See :ref:`gotchas.udf-mutation`\nfor more details.\n\nA passed user-defined-function will be passed a Series for evaluation.\n\nIf ``func`` defines an index relabeling, ``axis`` must be ``0`` or ``index``.\n{examples}"
+_shared_docs['compare'] = "\nCompare to another {klass} and show the differences.\n\nParameters\n----------\nother : {klass}\n    Object to compare with.\n\nalign_axis : {{0 or 'index', 1 or 'columns'}}, default 1\n    Determine which axis to align the comparison on.\n\n    * 0, or 'index' : Resulting differences are stacked vertically\n        with rows drawn alternately from self and other.\n    * 1, or 'columns' : Resulting differences are aligned horizontally\n        with columns drawn alternately from self and other.\n\nkeep_shape : bool, default False\n    If true, all rows and columns are kept.\n    Otherwise, only the ones with different values are kept.\n\nkeep_equal : bool, default False\n    If true, the result keeps values that are equal.\n    Otherwise, equal values are shown as NaNs.\n\nresult_names : tuple, default ('self', 'other')\n    Set the dataframes names in the comparison.\n\n    .. versionadded:: 1.5.0\n"
+_shared_docs['groupby'] = '\nGroup %(klass)s using a mapper or by a Series of columns.\n\nA groupby operation involves some combination of splitting the\nobject, applying a function, and combining the results. This can be\nused to group large amounts of data and compute operations on these\ngroups.\n\nParameters\n----------\nby : mapping, function, label, pd.Grouper or list of such\n    Used to determine the groups for the groupby.\n    If ``by`` is a function, it\'s called on each value of the object\'s\n    index. If a dict or Series is passed, the Series or dict VALUES\n    will be used to determine the groups (the Series\' values are first\n    aligned; see ``.align()`` method). If a list or ndarray of length\n    equal to the selected axis is passed (see the `groupby user guide\n    <https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#splitting-an-object-into-groups>`_),\n    the values are used as-is to determine the groups. A label or list\n    of labels may be passed to group by the columns in ``self``.\n    Notice that a tuple is interpreted as a (single) key.\nlevel : int, level name, or sequence of such, default None\n    If the axis is a MultiIndex (hierarchical), group by a particular\n    level or levels. Do not specify both ``by`` and ``level``.\nas_index : bool, default True\n    Return object with group labels as the\n    index. Only relevant for DataFrame input. as_index=False is\n    effectively "SQL-style" grouped output. This argument has no effect\n    on filtrations (see the `filtrations in the user guide\n    <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#filtration>`_),\n    such as ``head()``, ``tail()``, ``nth()`` and in transformations\n    (see the `transformations in the user guide\n    <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#transformation>`_).\nsort : bool, default True\n    Sort group keys. Get better performance by turning this off.\n    Note this does not influence the order of observations within each\n    group. Groupby preserves the order of rows within each group. If False,\n    the groups will appear in the same order as they did in the original DataFrame.\n    This argument has no effect on filtrations (see the `filtrations in the user guide\n    <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#filtration>`_),\n    such as ``head()``, ``tail()``, ``nth()`` and in transformations\n    (see the `transformations in the user guide\n    <https://pandas.pydata.org/docs/dev/user_guide/groupby.html#transformation>`_).\n\n    .. versionchanged:: 2.0.0\n\n        Specifying ``sort=False`` with an ordered categorical grouper will no\n        longer sort the values.\n\ngroup_keys : bool, default True\n    When calling apply and the ``by`` argument produces a like-indexed\n    (i.e. :ref:`a transform <groupby.transform>`) result, add group keys to\n    index to identify pieces. By default group keys are not included\n    when the result\'s index (and column) labels match the inputs, and\n    are included otherwise.\n\n    .. versionchanged:: 1.5.0\n\n       Warns that ``group_keys`` will no longer be ignored when the\n       result from ``apply`` is a like-indexed Series or DataFrame.\n       Specify ``group_keys`` explicitly to include the group keys or\n       not.\n\n    .. versionchanged:: 2.0.0\n\n       ``group_keys`` now defaults to ``True``.\n\nobserved : bool, default True\n    This only applies if any of the groupers are Categoricals.\n    If True: only show observed values for categorical groupers.\n    If False: show all values for categorical groupers.\n\n    .. versionchanged:: 3.0.0\n\n        The default value is now ``True``.\n\ndropna : bool, default True\n    If True, and if group keys contain NA values, NA values together\n    with row/column will be dropped.\n    If False, NA values will also be treated as the key in groups.\n\nReturns\n-------\npandas.api.typing.%(klass)sGroupBy\n    Returns a groupby object that contains information about the groups.\n\nSee Also\n--------\nresample : Convenience method for frequency conversion and resampling\n    of time series.\n\nNotes\n-----\nSee the `user guide\n<https://pandas.pydata.org/pandas-docs/stable/groupby.html>`__ for more\ndetailed usage and examples, including splitting an object into groups,\niterating through groups, selecting a group, aggregation, and more.\n\nThe implementation of groupby is hash-based, meaning in particular that\nobjects that compare as equal will be considered to be in the same group.\nAn exception to this is that pandas has special handling of NA values:\nany NA values will be collapsed to a single group, regardless of how\nthey compare. See the user guide linked above for more details.\n'
+_shared_docs['transform'] = '\nCall ``func`` on self producing a {klass} with the same axis shape as self.\n\nParameters\n----------\nfunc : function, str, list-like or dict-like\n    Function to use for transforming the data. If a function, must either\n    work when passed a {klass} or when passed to {klass}.apply. If func\n    is both list-like and dict-like, dict-like behavior takes precedence.\n\n    Accepted combinations are:\n\n    - function\n    - string function name\n    - list-like of functions and/or function names, e.g. ``[np.exp, \'sqrt\']``\n    - dict-like of axis labels -> functions, function names or list-like of such.\n{axis}\n*args\n    Positional arguments to pass to `func`.\n**kwargs\n    Keyword arguments to pass to `func`.\n\nReturns\n-------\n{klass}\n    A {klass} that must have the same length as self.\n\nRaises\n------\nValueError : If the returned {klass} has a different length than self.\n\nSee Also\n--------\n{klass}.agg : Only perform aggregating type operations.\n{klass}.apply : Invoke function on a {klass}.\n\nNotes\n-----\nFunctions that mutate the passed object can produce unexpected\nbehavior or errors and are not supported. See :ref:`gotchas.udf-mutation`\nfor more details.\n\nExamples\n--------\n>>> df = pd.DataFrame({{\'A\': range(3), \'B\': range(1, 4)}})\n>>> df\n   A  B\n0  0  1\n1  1  2\n2  2  3\n>>> df.transform(lambda x: x + 1)\n   A  B\n0  1  2\n1  2  3\n2  3  4\n\nEven though the resulting {klass} must have the same length as the\ninput {klass}, it is possible to provide several input functions:\n\n>>> s = pd.Series(range(3))\n>>> s\n0    0\n1    1\n2    2\ndtype: int64\n>>> s.transform([np.sqrt, np.exp])\n       sqrt        exp\n0  0.000000   1.000000\n1  1.000000   2.718282\n2  1.414214   7.389056\n\nYou can call transform on a GroupBy object:\n\n>>> df = pd.DataFrame({{\n...     "Date": [\n...         "2015-05-08", "2015-05-07", "2015-05-06", "2015-05-05",\n...         "2015-05-08", "2015-05-07", "2015-05-06", "2015-05-05"],\n...     "Data": [5, 8, 6, 1, 50, 100, 60, 120],\n... }})\n>>> df\n         Date  Data\n0  2015-05-08     5\n1  2015-05-07     8\n2  2015-05-06     6\n3  2015-05-05     1\n4  2015-05-08    50\n5  2015-05-07   100\n6  2015-05-06    60\n7  2015-05-05   120\n>>> df.groupby(\'Date\')[\'Data\'].transform(\'sum\')\n0     55\n1    108\n2     66\n3    121\n4     55\n5    108\n6     66\n7    121\nName: Data, dtype: int64\n\n>>> df = pd.DataFrame({{\n...     "c": [1, 1, 1, 2, 2, 2, 2],\n...     "type": ["m", "n", "o", "m", "m", "n", "n"]\n... }})\n>>> df\n   c type\n0  1    m\n1  1    n\n2  1    o\n3  2    m\n4  2    m\n5  2    n\n6  2    n\n>>> df[\'size\'] = df.groupby(\'c\')[\'type\'].transform(len)\n>>> df\n   c type size\n0  1    m    3\n1  1    n    3\n2  1    o    3\n3  2    m    4\n4  2    m    4\n5  2    n    4\n6  2    n    4\n'
+_shared_docs['storage_options'] = 'storage_options : dict, optional\n    Extra options that make sense for a particular storage connection, e.g.\n    host, port, username, password, etc. For HTTP(S) URLs the key-value pairs\n    are forwarded to ``urllib.request.Request`` as header options. For other\n    URLs (e.g. starting with "s3://", and "gcs://") the key-value pairs are\n    forwarded to ``fsspec.open``. Please see ``fsspec`` and ``urllib`` for more\n    details, and for more examples on storage options refer `here\n    <https://pandas.pydata.org/docs/user_guide/io.html?\n    highlight=storage_options#reading-writing-remote-files>`_.'
+_shared_docs['compression_options'] = "compression : str or dict, default 'infer'\n    For on-the-fly compression of the output data. If 'infer' and '%s' is\n    path-like, then detect compression from the following extensions: '.gz',\n    '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'\n    (otherwise no compression).\n    Set to ``None`` for no compression.\n    Can also be a dict with key ``'method'`` set\n    to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and\n    other key-value pairs are forwarded to\n    ``zipfile.ZipFile``, ``gzip.GzipFile``,\n    ``bz2.BZ2File``, ``zstandard.ZstdCompressor``, ``lzma.LZMAFile`` or\n    ``tarfile.TarFile``, respectively.\n    As an example, the following could be passed for faster compression and to create\n    a reproducible gzip archive:\n    ``compression={'method': 'gzip', 'compresslevel': 1, 'mtime': 1}``.\n\n    .. versionadded:: 1.5.0\n        Added support for `.tar` files."
+_shared_docs['decompression_options'] = "compression : str or dict, default 'infer'\n    For on-the-fly decompression of on-disk data. If 'infer' and '%s' is\n    path-like, then detect compression from the following extensions: '.gz',\n    '.bz2', '.zip', '.xz', '.zst', '.tar', '.tar.gz', '.tar.xz' or '.tar.bz2'\n    (otherwise no compression).\n    If using 'zip' or 'tar', the ZIP file must contain only one data file to be read in.\n    Set to ``None`` for no decompression.\n    Can also be a dict with key ``'method'`` set\n    to one of {``'zip'``, ``'gzip'``, ``'bz2'``, ``'zstd'``, ``'xz'``, ``'tar'``} and\n    other key-value pairs are forwarded to\n    ``zipfile.ZipFile``, ``gzip.GzipFile``,\n    ``bz2.BZ2File``, ``zstandard.ZstdDecompressor``, ``lzma.LZMAFile`` or\n    ``tarfile.TarFile``, respectively.\n    As an example, the following could be passed for Zstandard decompression using a\n    custom compression dictionary:\n    ``compression={'method': 'zstd', 'dict_data': my_compression_dict}``.\n\n    .. versionadded:: 1.5.0\n        Added support for `.tar` files."
+_shared_docs['replace'] = "\n    Replace values given in `to_replace` with `value`.\n\n    Values of the {klass} are replaced with other values dynamically.\n    This differs from updating with ``.loc`` or ``.iloc``, which require\n    you to specify a location to update with some value.\n\n    Parameters\n    ----------\n    to_replace : str, regex, list, dict, Series, int, float, or None\n        How to find the values that will be replaced.\n\n        * numeric, str or regex:\n\n            - numeric: numeric values equal to `to_replace` will be\n              replaced with `value`\n            - str: string exactly matching `to_replace` will be replaced\n              with `value`\n            - regex: regexs matching `to_replace` will be replaced with\n              `value`\n\n        * list of str, regex, or numeric:\n\n            - First, if `to_replace` and `value` are both lists, they\n              **must** be the same length.\n            - Second, if ``regex=True`` then all of the strings in **both**\n              lists will be interpreted as regexs otherwise they will match\n              directly. This doesn't matter much for `value` since there\n              are only a few possible substitution regexes you can use.\n            - str, regex and numeric rules apply as above.\n\n        * dict:\n\n            - Dicts can be used to specify different replacement values\n              for different existing values. For example,\n              ``{{'a': 'b', 'y': 'z'}}`` replaces the value 'a' with 'b' and\n              'y' with 'z'. To use a dict in this way, the optional `value`\n              parameter should not be given.\n            - For a DataFrame a dict can specify that different values\n              should be replaced in different columns. For example,\n              ``{{'a': 1, 'b': 'z'}}`` looks for the value 1 in column 'a'\n              and the value 'z' in column 'b' and replaces these values\n              with whatever is specified in `value`. The `value` parameter\n              should not be ``None`` in this case. You can treat this as a\n              special case of passing two lists except that you are\n              specifying the column to search in.\n            - For a DataFrame nested dictionaries, e.g.,\n              ``{{'a': {{'b': np.nan}}}}``, are read as follows: look in column\n              'a' for the value 'b' and replace it with NaN. The optional `value`\n              parameter should not be specified to use a nested dict in this\n              way. You can nest regular expressions as well. Note that\n              column names (the top-level dictionary keys in a nested\n              dictionary) **cannot** be regular expressions.\n\n        * None:\n\n            - This means that the `regex` argument must be a string,\n              compiled regular expression, or list, dict, ndarray or\n              Series of such elements. If `value` is also ``None`` then\n              this **must** be a nested dictionary or Series.\n\n        See the examples section for examples of each of these.\n    value : scalar, dict, list, str, regex, default None\n        Value to replace any values matching `to_replace` with.\n        For a DataFrame a dict of values can be used to specify which\n        value to use for each column (columns not in the dict will not be\n        filled). Regular expressions, strings and lists or dicts of such\n        objects are also allowed.\n    {inplace}\n    regex : bool or same types as `to_replace`, default False\n        Whether to interpret `to_replace` and/or `value` as regular\n        expressions. Alternatively, this could be a regular expression or a\n        list, dict, or array of regular expressions in which case\n        `to_replace` must be ``None``.\n\n    Returns\n    -------\n    {klass}\n        Object after replacement.\n\n    Raises\n    ------\n    AssertionError\n        * If `regex` is not a ``bool`` and `to_replace` is not\n          ``None``.\n\n    TypeError\n        * If `to_replace` is not a scalar, array-like, ``dict``, or ``None``\n        * If `to_replace` is a ``dict`` and `value` is not a ``list``,\n          ``dict``, ``ndarray``, or ``Series``\n        * If `to_replace` is ``None`` and `regex` is not compilable\n          into a regular expression or is a list, dict, ndarray, or\n          Series.\n        * When replacing multiple ``bool`` or ``datetime64`` objects and\n          the arguments to `to_replace` does not match the type of the\n          value being replaced\n\n    ValueError\n        * If a ``list`` or an ``ndarray`` is passed to `to_replace` and\n          `value` but they are not the same length.\n\n    See Also\n    --------\n    Series.fillna : Fill NA values.\n    DataFrame.fillna : Fill NA values.\n    Series.where : Replace values based on boolean condition.\n    DataFrame.where : Replace values based on boolean condition.\n    DataFrame.map: Apply a function to a Dataframe elementwise.\n    Series.map: Map values of Series according to an input mapping or function.\n    Series.str.replace : Simple string replacement.\n\n    Notes\n    -----\n    * Regex substitution is performed under the hood with ``re.sub``. The\n      rules for substitution for ``re.sub`` are the same.\n    * Regular expressions will only substitute on strings, meaning you\n      cannot provide, for example, a regular expression matching floating\n      point numbers and expect the columns in your frame that have a\n      numeric dtype to be matched. However, if those floating point\n      numbers *are* strings, then you can do this.\n    * This method has *a lot* of options. You are encouraged to experiment\n      and play with this method to gain intuition about how it works.\n    * When dict is used as the `to_replace` value, it is like\n      key(s) in the dict are the to_replace part and\n      value(s) in the dict are the value parameter.\n\n    Examples\n    --------\n\n    **Scalar `to_replace` and `value`**\n\n    >>> s = pd.Series([1, 2, 3, 4, 5])\n    >>> s.replace(1, 5)\n    0    5\n    1    2\n    2    3\n    3    4\n    4    5\n    dtype: int64\n\n    >>> df = pd.DataFrame({{'A': [0, 1, 2, 3, 4],\n    ...                    'B': [5, 6, 7, 8, 9],\n    ...                    'C': ['a', 'b', 'c', 'd', 'e']}})\n    >>> df.replace(0, 5)\n        A  B  C\n    0  5  5  a\n    1  1  6  b\n    2  2  7  c\n    3  3  8  d\n    4  4  9  e\n\n    **List-like `to_replace`**\n\n    >>> df.replace([0, 1, 2, 3], 4)\n        A  B  C\n    0  4  5  a\n    1  4  6  b\n    2  4  7  c\n    3  4  8  d\n    4  4  9  e\n\n    >>> df.replace([0, 1, 2, 3], [4, 3, 2, 1])\n        A  B  C\n    0  4  5  a\n    1  3  6  b\n    2  2  7  c\n    3  1  8  d\n    4  4  9  e\n\n    **dict-like `to_replace`**\n\n    >>> df.replace({{0: 10, 1: 100}})\n            A  B  C\n    0   10  5  a\n    1  100  6  b\n    2    2  7  c\n    3    3  8  d\n    4    4  9  e\n\n    >>> df.replace({{'A': 0, 'B': 5}}, 100)\n            A    B  C\n    0  100  100  a\n    1    1    6  b\n    2    2    7  c\n    3    3    8  d\n    4    4    9  e\n\n    >>> df.replace({{'A': {{0: 100, 4: 400}}}})\n            A  B  C\n    0  100  5  a\n    1    1  6  b\n    2    2  7  c\n    3    3  8  d\n    4  400  9  e\n\n    **Regular expression `to_replace`**\n\n    >>> df = pd.DataFrame({{'A': ['bat', 'foo', 'bait'],\n    ...                    'B': ['abc', 'bar', 'xyz']}})\n    >>> df.replace(to_replace=r'^ba.$', value='new', regex=True)\n            A    B\n    0   new  abc\n    1   foo  new\n    2  bait  xyz\n\n    >>> df.replace({{'A': r'^ba.$'}}, {{'A': 'new'}}, regex=True)\n            A    B\n    0   new  abc\n    1   foo  bar\n    2  bait  xyz\n\n    >>> df.replace(regex=r'^ba.$', value='new')\n            A    B\n    0   new  abc\n    1   foo  new\n    2  bait  xyz\n\n    >>> df.replace(regex={{r'^ba.$': 'new', 'foo': 'xyz'}})\n            A    B\n    0   new  abc\n    1   xyz  new\n    2  bait  xyz\n\n    >>> df.replace(regex=[r'^ba.$', 'foo'], value='new')\n            A    B\n    0   new  abc\n    1   new  new\n    2  bait  xyz\n\n    Compare the behavior of ``s.replace({{'a': None}})`` and\n    ``s.replace('a', None)`` to understand the peculiarities\n    of the `to_replace` parameter:\n\n    >>> s = pd.Series([10, 'a', 'a', 'b', 'a'])\n\n    When one uses a dict as the `to_replace` value, it is like the\n    value(s) in the dict are equal to the `value` parameter.\n    ``s.replace({{'a': None}})`` is equivalent to\n    ``s.replace(to_replace={{'a': None}}, value=None)``:\n\n    >>> s.replace({{'a': None}})\n    0      10\n    1    None\n    2    None\n    3       b\n    4    None\n    dtype: object\n\n    If ``None`` is explicitly passed for ``value``, it will be respected:\n\n    >>> s.replace('a', None)\n    0      10\n    1    None\n    2    None\n    3       b\n    4    None\n    dtype: object\n\n        .. versionchanged:: 1.4.0\n            Previously the explicit ``None`` was silently ignored.\n\n    When ``regex=True``, ``value`` is not ``None`` and `to_replace` is a string,\n    the replacement will be applied in all columns of the DataFrame.\n\n    >>> df = pd.DataFrame({{'A': [0, 1, 2, 3, 4],\n    ...                    'B': ['a', 'b', 'c', 'd', 'e'],\n    ...                    'C': ['f', 'g', 'h', 'i', 'j']}})\n\n    >>> df.replace(to_replace='^[a-g]', value='e', regex=True)\n        A  B  C\n    0  0  e  e\n    1  1  e  e\n    2  2  e  h\n    3  3  e  i\n    4  4  e  j\n\n    If ``value`` is not ``None`` and `to_replace` is a dictionary, the dictionary\n    keys will be the DataFrame columns that the replacement will be applied.\n\n    >>> df.replace(to_replace={{'B': '^[a-c]', 'C': '^[h-j]'}}, value='e', regex=True)\n        A  B  C\n    0  0  e  f\n    1  1  e  g\n    2  2  e  e\n    3  3  d  e\n    4  4  e  e\n"
+
+# File: pandas-main/pandas/core/sorting.py
+""""""
+from __future__ import annotations
+import itertools
+from typing import TYPE_CHECKING, cast
+import numpy as np
+from pandas._libs import algos, hashtable, lib
+from pandas._libs.hashtable import unique_label_indices
+from pandas.core.dtypes.common import ensure_int64, ensure_platform_int
+from pandas.core.dtypes.generic import ABCMultiIndex, ABCRangeIndex
+from pandas.core.dtypes.missing import isna
+from pandas.core.construction import extract_array
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Sequence
+    from pandas._typing import ArrayLike, AxisInt, IndexKeyFunc, Level, NaPosition, Shape, SortKind, npt
+    from pandas import MultiIndex, Series
+    from pandas.core.arrays import ExtensionArray
+    from pandas.core.indexes.base import Index
+
+def get_indexer_indexer(target: Index, level: Level | list[Level] | None, ascending: list[bool] | bool, kind: SortKind, na_position: NaPosition, sort_remaining: bool, key: IndexKeyFunc) -> npt.NDArray[np.intp] | None:
+    target = ensure_key_mapped(target, key, levels=level)
+    target = target._sort_levels_monotonic()
+    if level is not None:
+        (_, indexer) = target.sortlevel(level, ascending=ascending, sort_remaining=sort_remaining, na_position=na_position)
+    elif np.all(ascending) and target.is_monotonic_increasing or (not np.any(ascending) and target.is_monotonic_decreasing):
+        return None
+    elif isinstance(target, ABCMultiIndex):
+        codes = [lev.codes for lev in target._get_codes_for_sorting()]
+        indexer = lexsort_indexer(codes, orders=ascending, na_position=na_position, codes_given=True)
+    else:
+        indexer = nargsort(target, kind=kind, ascending=cast(bool, ascending), na_position=na_position)
+    return indexer
+
+def get_group_index(labels, shape: Shape, sort: bool, xnull: bool) -> npt.NDArray[np.int64]:
+
+    def _int64_cut_off(shape) -> int:
+        acc = 1
+        for (i, mul) in enumerate(shape):
+            acc *= int(mul)
+            if not acc < lib.i8max:
+                return i
+        return len(shape)
+
+    def maybe_lift(lab, size: int) -> tuple[np.ndarray, int]:
+        return (lab + 1, size + 1) if (lab == -1).any() else (lab, size)
+    labels = [ensure_int64(x) for x in labels]
+    lshape = list(shape)
+    if not xnull:
+        for (i, (lab, size)) in enumerate(zip(labels, shape)):
+            (labels[i], lshape[i]) = maybe_lift(lab, size)
+    while True:
+        nlev = _int64_cut_off(lshape)
+        stride = np.prod(lshape[1:nlev], dtype='i8')
+        out = stride * labels[0].astype('i8', subok=False, copy=False)
+        for i in range(1, nlev):
+            if lshape[i] == 0:
+                stride = np.int64(0)
+            else:
+                stride //= lshape[i]
+            out += labels[i] * stride
+        if xnull:
+            mask = labels[0] == -1
+            for lab in labels[1:nlev]:
+                mask |= lab == -1
+            out[mask] = -1
+        if nlev == len(lshape):
+            break
+        (comp_ids, obs_ids) = compress_group_index(out, sort=sort)
+        labels = [comp_ids] + labels[nlev:]
+        lshape = [len(obs_ids)] + lshape[nlev:]
+    return out
+
+def get_compressed_ids(labels, sizes: Shape) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.int64]]:
+    ids = get_group_index(labels, sizes, sort=True, xnull=False)
+    return compress_group_index(ids, sort=True)
+
+def is_int64_overflow_possible(shape: Shape) -> bool:
+    the_prod = 1
+    for x in shape:
+        the_prod *= int(x)
+    return the_prod >= lib.i8max
+
+def _decons_group_index(comp_labels: npt.NDArray[np.intp], shape: Shape) -> list[npt.NDArray[np.intp]]:
+    if is_int64_overflow_possible(shape):
+        raise ValueError('cannot deconstruct factorized group indices!')
+    label_list = []
+    factor = 1
+    y = np.array(0)
+    x = comp_labels
+    for i in reversed(range(len(shape))):
+        labels = (x - y) % (factor * shape[i]) // factor
+        np.putmask(labels, comp_labels < 0, -1)
+        label_list.append(labels)
+        y = labels * factor
+        factor *= shape[i]
+    return label_list[::-1]
+
+def decons_obs_group_ids(comp_ids: npt.NDArray[np.intp], obs_ids: npt.NDArray[np.intp], shape: Shape, labels: Sequence[npt.NDArray[np.signedinteger]], xnull: bool) -> list[npt.NDArray[np.intp]]:
+    if not xnull:
+        lift = np.fromiter(((a == -1).any() for a in labels), dtype=np.intp)
+        arr_shape = np.asarray(shape, dtype=np.intp) + lift
+        shape = tuple(arr_shape)
+    if not is_int64_overflow_possible(shape):
+        out = _decons_group_index(obs_ids, shape)
+        return out if xnull or not lift.any() else [x - y for (x, y) in zip(out, lift)]
+    indexer = unique_label_indices(comp_ids)
+    return [lab[indexer].astype(np.intp, subok=False, copy=True) for lab in labels]
+
+def lexsort_indexer(keys: Sequence[ArrayLike | Index | Series], orders=None, na_position: str='last', key: Callable | None=None, codes_given: bool=False) -> npt.NDArray[np.intp]:
+    from pandas.core.arrays import Categorical
+    if na_position not in ['last', 'first']:
+        raise ValueError(f'invalid na_position: {na_position}')
+    if isinstance(orders, bool):
+        orders = itertools.repeat(orders, len(keys))
+    elif orders is None:
+        orders = itertools.repeat(True, len(keys))
+    else:
+        orders = reversed(orders)
+    labels = []
+    for (k, order) in zip(reversed(keys), orders):
+        k = ensure_key_mapped(k, key)
+        if codes_given:
+            codes = cast(np.ndarray, k)
+            n = codes.max() + 1 if len(codes) else 0
+        else:
+            cat = Categorical(k, ordered=True)
+            codes = cat.codes
+            n = len(cat.categories)
+        mask = codes == -1
+        if na_position == 'last' and mask.any():
+            codes = np.where(mask, n, codes)
+        if not order:
+            codes = np.where(mask, codes, n - codes - 1)
+        labels.append(codes)
+    return np.lexsort(labels)
+
+def nargsort(items: ArrayLike | Index | Series, kind: SortKind='quicksort', ascending: bool=True, na_position: str='last', key: Callable | None=None, mask: npt.NDArray[np.bool_] | None=None) -> npt.NDArray[np.intp]:
+    if key is not None:
+        items = ensure_key_mapped(items, key)
+        return nargsort(items, kind=kind, ascending=ascending, na_position=na_position, key=None, mask=mask)
+    if isinstance(items, ABCRangeIndex):
+        return items.argsort(ascending=ascending)
+    elif not isinstance(items, ABCMultiIndex):
+        items = extract_array(items)
+    else:
+        raise TypeError('nargsort does not support MultiIndex. Use index.sort_values instead.')
+    if mask is None:
+        mask = np.asarray(isna(items))
+    if not isinstance(items, np.ndarray):
+        return items.argsort(ascending=ascending, kind=kind, na_position=na_position)
+    idx = np.arange(len(items))
+    non_nans = items[~mask]
+    non_nan_idx = idx[~mask]
+    nan_idx = np.nonzero(mask)[0]
+    if not ascending:
+        non_nans = non_nans[::-1]
+        non_nan_idx = non_nan_idx[::-1]
+    indexer = non_nan_idx[non_nans.argsort(kind=kind)]
+    if not ascending:
+        indexer = indexer[::-1]
+    if na_position == 'last':
+        indexer = np.concatenate([indexer, nan_idx])
+    elif na_position == 'first':
+        indexer = np.concatenate([nan_idx, indexer])
+    else:
+        raise ValueError(f'invalid na_position: {na_position}')
+    return ensure_platform_int(indexer)
+
+def nargminmax(values: ExtensionArray, method: str, axis: AxisInt=0):
+    assert method in {'argmax', 'argmin'}
+    func = np.argmax if method == 'argmax' else np.argmin
+    mask = np.asarray(isna(values))
+    arr_values = values._values_for_argsort()
+    if arr_values.ndim > 1:
+        if mask.any():
+            if axis == 1:
+                zipped = zip(arr_values, mask)
+            else:
+                zipped = zip(arr_values.T, mask.T)
+            return np.array([_nanargminmax(v, m, func) for (v, m) in zipped])
+        return func(arr_values, axis=axis)
+    return _nanargminmax(arr_values, mask, func)
+
+def _nanargminmax(values: np.ndarray, mask: npt.NDArray[np.bool_], func) -> int:
+    idx = np.arange(values.shape[0])
+    non_nans = values[~mask]
+    non_nan_idx = idx[~mask]
+    return non_nan_idx[func(non_nans)]
+
+def _ensure_key_mapped_multiindex(index: MultiIndex, key: Callable, level=None) -> MultiIndex:
+    if level is not None:
+        if isinstance(level, (str, int)):
+            level_iter = [level]
+        else:
+            level_iter = level
+        sort_levels: range | set = {index._get_level_number(lev) for lev in level_iter}
+    else:
+        sort_levels = range(index.nlevels)
+    mapped = [ensure_key_mapped(index._get_level_values(level), key) if level in sort_levels else index._get_level_values(level) for level in range(index.nlevels)]
+    return type(index).from_arrays(mapped)
+
+def ensure_key_mapped(values: ArrayLike | Index | Series, key: Callable | None, levels=None) -> ArrayLike | Index | Series:
+    from pandas.core.indexes.api import Index
+    if not key:
+        return values
+    if isinstance(values, ABCMultiIndex):
+        return _ensure_key_mapped_multiindex(values, key, level=levels)
+    result = key(values.copy())
+    if len(result) != len(values):
+        raise ValueError('User-provided `key` function must not change the shape of the array.')
+    try:
+        if isinstance(values, Index):
+            result = Index(result, tupleize_cols=False)
+        else:
+            type_of_values = type(values)
+            result = type_of_values(result)
+    except TypeError as err:
+        raise TypeError(f'User-provided `key` function returned an invalid type {type(result)}             which could not be converted to {type(values)}.') from err
+    return result
+
+def get_indexer_dict(label_list: list[np.ndarray], keys: list[Index]) -> dict[Hashable, npt.NDArray[np.intp]]:
+    shape = tuple((len(x) for x in keys))
+    group_index = get_group_index(label_list, shape, sort=True, xnull=True)
+    if np.all(group_index == -1):
+        return {}
+    ngroups = (group_index.size and group_index.max()) + 1 if is_int64_overflow_possible(shape) else np.prod(shape, dtype='i8')
+    sorter = get_group_index_sorter(group_index, ngroups)
+    sorted_labels = [lab.take(sorter) for lab in label_list]
+    group_index = group_index.take(sorter)
+    return lib.indices_fast(sorter, group_index, keys, sorted_labels)
+
+def get_group_index_sorter(group_index: npt.NDArray[np.intp], ngroups: int | None=None) -> npt.NDArray[np.intp]:
+    if ngroups is None:
+        ngroups = 1 + group_index.max()
+    count = len(group_index)
+    alpha = 0.0
+    beta = 1.0
+    do_groupsort = count > 0 and alpha + beta * ngroups < count * np.log(count)
+    if do_groupsort:
+        (sorter, _) = algos.groupsort_indexer(ensure_platform_int(group_index), ngroups)
+    else:
+        sorter = group_index.argsort(kind='mergesort')
+    return ensure_platform_int(sorter)
+
+def compress_group_index(group_index: npt.NDArray[np.int64], sort: bool=True) -> tuple[npt.NDArray[np.int64], npt.NDArray[np.int64]]:
+    if len(group_index) and np.all(group_index[1:] >= group_index[:-1]):
+        unique_mask = np.concatenate([group_index[:1] > -1, group_index[1:] != group_index[:-1]])
+        comp_ids = unique_mask.cumsum()
+        comp_ids -= 1
+        obs_group_ids = group_index[unique_mask]
+    else:
+        size_hint = len(group_index)
+        table = hashtable.Int64HashTable(size_hint)
+        group_index = ensure_int64(group_index)
+        (comp_ids, obs_group_ids) = table.get_labels_groupby(group_index)
+        if sort and len(obs_group_ids) > 0:
+            (obs_group_ids, comp_ids) = _reorder_by_uniques(obs_group_ids, comp_ids)
+    return (ensure_int64(comp_ids), ensure_int64(obs_group_ids))
+
+def _reorder_by_uniques(uniques: npt.NDArray[np.int64], labels: npt.NDArray[np.intp]) -> tuple[npt.NDArray[np.int64], npt.NDArray[np.intp]]:
+    sorter = uniques.argsort()
+    reverse_indexer = np.empty(len(sorter), dtype=np.intp)
+    reverse_indexer.put(sorter, np.arange(len(sorter)))
+    mask = labels < 0
+    labels = reverse_indexer.take(labels)
+    np.putmask(labels, mask, -1)
+    uniques = uniques.take(sorter)
+    return (uniques, labels)
+
+# File: pandas-main/pandas/core/strings/__init__.py
+""""""
+
+# File: pandas-main/pandas/core/strings/accessor.py
+from __future__ import annotations
+import codecs
+from functools import wraps
+import re
+from typing import TYPE_CHECKING, Literal, cast
+import warnings
+import numpy as np
+from pandas._libs import lib
+from pandas._typing import AlignJoin, DtypeObj, F, Scalar, npt
+from pandas.util._decorators import Appender
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import ensure_object, is_bool_dtype, is_extension_array_dtype, is_integer, is_list_like, is_object_dtype, is_re
+from pandas.core.dtypes.dtypes import ArrowDtype, CategoricalDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCIndex, ABCMultiIndex, ABCSeries
+from pandas.core.dtypes.missing import isna
+from pandas.core.arrays import ExtensionArray
+from pandas.core.base import NoNewAttributesMixin
+from pandas.core.construction import extract_array
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Iterator
+    from pandas._typing import NpDtype
+    from pandas import DataFrame, Index, Series
+_shared_docs: dict[str, str] = {}
+_cpython_optimized_encoders = ('utf-8', 'utf8', 'latin-1', 'latin1', 'iso-8859-1', 'mbcs', 'ascii')
+_cpython_optimized_decoders = _cpython_optimized_encoders + ('utf-16', 'utf-32')
+
+def forbid_nonstring_types(forbidden: list[str] | None, name: str | None=None) -> Callable[[F], F]:
+    forbidden = [] if forbidden is None else forbidden
+    allowed_types = {'string', 'empty', 'bytes', 'mixed', 'mixed-integer'} - set(forbidden)
+
+    def _forbid_nonstring_types(func: F) -> F:
+        func_name = func.__name__ if name is None else name
+
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            if self._inferred_dtype not in allowed_types:
+                msg = f"Cannot use .str.{func_name} with values of inferred dtype '{self._inferred_dtype}'."
+                raise TypeError(msg)
+            return func(self, *args, **kwargs)
+        wrapper.__name__ = func_name
+        return cast(F, wrapper)
+    return _forbid_nonstring_types
+
+def _map_and_wrap(name: str | None, docstring: str | None):
+
+    @forbid_nonstring_types(['bytes'], name=name)
+    def wrapper(self):
+        result = getattr(self._data.array, f'_str_{name}')()
+        return self._wrap_result(result, returns_string=name not in ('isnumeric', 'isdecimal'))
+    wrapper.__doc__ = docstring
+    return wrapper
+
+class StringMethods(NoNewAttributesMixin):
+
+    def __init__(self, data) -> None:
+        from pandas.core.arrays.string_ import StringDtype
+        self._inferred_dtype = self._validate(data)
+        self._is_categorical = isinstance(data.dtype, CategoricalDtype)
+        self._is_string = isinstance(data.dtype, StringDtype)
+        self._data = data
+        self._index = self._name = None
+        if isinstance(data, ABCSeries):
+            self._index = data.index
+            self._name = data.name
+        self._parent = data._values.categories if self._is_categorical else data
+        self._orig = data
+        self._freeze()
+
+    @staticmethod
+    def _validate(data):
+        if isinstance(data, ABCMultiIndex):
+            raise AttributeError('Can only use .str accessor with Index, not MultiIndex')
+        allowed_types = ['string', 'empty', 'bytes', 'mixed', 'mixed-integer']
+        data = extract_array(data)
+        values = getattr(data, 'categories', data)
+        inferred_dtype = lib.infer_dtype(values, skipna=True)
+        if inferred_dtype not in allowed_types:
+            raise AttributeError('Can only use .str accessor with string values!')
+        return inferred_dtype
+
+    def __getitem__(self, key):
+        result = self._data.array._str_getitem(key)
+        return self._wrap_result(result)
+
+    def __iter__(self) -> Iterator:
+        raise TypeError(f"'{type(self).__name__}' object is not iterable")
+
+    def _wrap_result(self, result, name=None, expand: bool | None=None, fill_value=np.nan, returns_string: bool=True, dtype=None):
+        from pandas import Index, MultiIndex
+        if not hasattr(result, 'ndim') or not hasattr(result, 'dtype'):
+            if isinstance(result, ABCDataFrame):
+                result = result.__finalize__(self._orig, name='str')
+            return result
+        assert result.ndim < 3
+        if expand is None:
+            expand = result.ndim != 1
+        elif expand is True and (not isinstance(self._orig, ABCIndex)):
+            if isinstance(result.dtype, ArrowDtype):
+                import pyarrow as pa
+                from pandas.compat import pa_version_under11p0
+                from pandas.core.arrays.arrow.array import ArrowExtensionArray
+                value_lengths = pa.compute.list_value_length(result._pa_array)
+                max_len = pa.compute.max(value_lengths).as_py()
+                min_len = pa.compute.min(value_lengths).as_py()
+                if result._hasna:
+                    result = ArrowExtensionArray(result._pa_array.fill_null([None] * max_len))
+                if min_len < max_len:
+                    if not pa_version_under11p0:
+                        result = ArrowExtensionArray(pa.compute.list_slice(result._pa_array, start=0, stop=max_len, return_fixed_size_list=True))
+                    else:
+                        all_null = np.full(max_len, fill_value=None, dtype=object)
+                        values = result.to_numpy()
+                        new_values = []
+                        for row in values:
+                            if len(row) < max_len:
+                                nulls = all_null[:max_len - len(row)]
+                                row = np.append(row, nulls)
+                            new_values.append(row)
+                        pa_type = result._pa_array.type
+                        result = ArrowExtensionArray(pa.array(new_values, type=pa_type))
+                if name is None:
+                    name = range(max_len)
+                result = pa.compute.list_flatten(result._pa_array).to_numpy().reshape(len(result), max_len)
+                result = {label: ArrowExtensionArray(pa.array(res)) for (label, res) in zip(name, result.T)}
+            elif is_object_dtype(result):
+
+                def cons_row(x):
+                    if is_list_like(x):
+                        return x
+                    else:
+                        return [x]
+                result = [cons_row(x) for x in result]
+                if result and (not self._is_string):
+                    max_len = max((len(x) for x in result))
+                    result = [x * max_len if len(x) == 0 or x[0] is np.nan else x for x in result]
+        if not isinstance(expand, bool):
+            raise ValueError('expand must be True or False')
+        if expand is False:
+            if name is None:
+                name = getattr(result, 'name', None)
+            if name is None:
+                name = self._orig.name
+        if isinstance(self._orig, ABCIndex):
+            if is_bool_dtype(result):
+                return result
+            if expand:
+                result = list(result)
+                out: Index = MultiIndex.from_tuples(result, names=name)
+                if out.nlevels == 1:
+                    out = out.get_level_values(0)
+                return out
+            else:
+                return Index(result, name=name, dtype=dtype)
+        else:
+            index = self._orig.index
+            _dtype: DtypeObj | str | None = dtype
+            vdtype = getattr(result, 'dtype', None)
+            if self._is_string:
+                if is_bool_dtype(vdtype):
+                    _dtype = result.dtype
+                elif returns_string:
+                    _dtype = self._orig.dtype
+                else:
+                    _dtype = vdtype
+            elif vdtype is not None:
+                _dtype = vdtype
+            if expand:
+                cons = self._orig._constructor_expanddim
+                result = cons(result, columns=name, index=index, dtype=_dtype)
+            else:
+                cons = self._orig._constructor
+                result = cons(result, name=name, index=index, dtype=_dtype)
+            result = result.__finalize__(self._orig, method='str')
+            if name is not None and result.ndim == 1:
+                result.name = name
+            return result
+
+    def _get_series_list(self, others):
+        from pandas import DataFrame, Series
+        idx = self._orig if isinstance(self._orig, ABCIndex) else self._orig.index
+        if isinstance(others, ABCSeries):
+            return [others]
+        elif isinstance(others, ABCIndex):
+            return [Series(others, index=idx, dtype=others.dtype)]
+        elif isinstance(others, ABCDataFrame):
+            return [others[x] for x in others]
+        elif isinstance(others, np.ndarray) and others.ndim == 2:
+            others = DataFrame(others, index=idx)
+            return [others[x] for x in others]
+        elif is_list_like(others, allow_sets=False):
+            try:
+                others = list(others)
+            except TypeError:
+                pass
+            else:
+                if all((isinstance(x, (ABCSeries, ABCIndex, ExtensionArray)) or (isinstance(x, np.ndarray) and x.ndim == 1) for x in others)):
+                    los: list[Series] = []
+                    while others:
+                        los = los + self._get_series_list(others.pop(0))
+                    return los
+                elif all((not is_list_like(x) for x in others)):
+                    return [Series(others, index=idx)]
+        raise TypeError('others must be Series, Index, DataFrame, np.ndarray or list-like (either containing only strings or containing only objects of type Series/Index/np.ndarray[1-dim])')
+
+    @forbid_nonstring_types(['bytes', 'mixed', 'mixed-integer'])
+    def cat(self, others=None, sep: str | None=None, na_rep=None, join: AlignJoin='left') -> str | Series | Index:
+        from pandas import Index, Series, concat
+        if isinstance(others, str):
+            raise ValueError('Did you mean to supply a `sep` keyword?')
+        if sep is None:
+            sep = ''
+        if isinstance(self._orig, ABCIndex):
+            data = Series(self._orig, index=self._orig, dtype=self._orig.dtype)
+        else:
+            data = self._orig
+        if others is None:
+            data = ensure_object(data)
+            na_mask = isna(data)
+            if na_rep is None and na_mask.any():
+                return sep.join(data[~na_mask])
+            elif na_rep is not None and na_mask.any():
+                return sep.join(np.where(na_mask, na_rep, data))
+            else:
+                return sep.join(data)
+        try:
+            others = self._get_series_list(others)
+        except ValueError as err:
+            raise ValueError('If `others` contains arrays or lists (or other list-likes without an index), these must all be of the same length as the calling Series/Index.') from err
+        if any((not data.index.equals(x.index) for x in others)):
+            others = concat(others, axis=1, join=join if join == 'inner' else 'outer', keys=range(len(others)), sort=False)
+            (data, others) = data.align(others, join=join)
+            others = [others[x] for x in others]
+        all_cols = [ensure_object(x) for x in [data] + others]
+        na_masks = np.array([isna(x) for x in all_cols])
+        union_mask = np.logical_or.reduce(na_masks, axis=0)
+        if na_rep is None and union_mask.any():
+            result = np.empty(len(data), dtype=object)
+            np.putmask(result, union_mask, np.nan)
+            not_masked = ~union_mask
+            result[not_masked] = cat_safe([x[not_masked] for x in all_cols], sep)
+        elif na_rep is not None and union_mask.any():
+            all_cols = [np.where(nm, na_rep, col) for (nm, col) in zip(na_masks, all_cols)]
+            result = cat_safe(all_cols, sep)
+        else:
+            result = cat_safe(all_cols, sep)
+        out: Index | Series
+        if isinstance(self._orig.dtype, CategoricalDtype):
+            dtype = self._orig.dtype.categories.dtype
+        else:
+            dtype = self._orig.dtype
+        if isinstance(self._orig, ABCIndex):
+            if isna(result).all():
+                dtype = object
+            out = Index(result, dtype=dtype, name=self._orig.name)
+        else:
+            res_ser = Series(result, dtype=dtype, index=data.index, name=self._orig.name, copy=False)
+            out = res_ser.__finalize__(self._orig, method='str_cat')
+        return out
+    _shared_docs['str_split'] = '\n    Split strings around given separator/delimiter.\n\n    Splits the string in the Series/Index from the %(side)s,\n    at the specified delimiter string.\n\n    Parameters\n    ----------\n    pat : str%(pat_regex)s, optional\n        %(pat_description)s.\n        If not specified, split on whitespace.\n    n : int, default -1 (all)\n        Limit number of splits in output.\n        ``None``, 0 and -1 will be interpreted as return all splits.\n    expand : bool, default False\n        Expand the split strings into separate columns.\n\n        - If ``True``, return DataFrame/MultiIndex expanding dimensionality.\n        - If ``False``, return Series/Index, containing lists of strings.\n    %(regex_argument)s\n    Returns\n    -------\n    Series, Index, DataFrame or MultiIndex\n        Type matches caller unless ``expand=True`` (see Notes).\n    %(raises_split)s\n    See Also\n    --------\n    Series.str.split : Split strings around given separator/delimiter.\n    Series.str.rsplit : Splits string around given separator/delimiter,\n        starting from the right.\n    Series.str.join : Join lists contained as elements in the Series/Index\n        with passed delimiter.\n    str.split : Standard library version for split.\n    str.rsplit : Standard library version for rsplit.\n\n    Notes\n    -----\n    The handling of the `n` keyword depends on the number of found splits:\n\n    - If found splits > `n`,  make first `n` splits only\n    - If found splits <= `n`, make all splits\n    - If for a certain row the number of found splits < `n`,\n      append `None` for padding up to `n` if ``expand=True``\n\n    If using ``expand=True``, Series and Index callers return DataFrame and\n    MultiIndex objects, respectively.\n    %(regex_pat_note)s\n    Examples\n    --------\n    >>> s = pd.Series(\n    ...     [\n    ...         "this is a regular sentence",\n    ...         "https://docs.python.org/3/tutorial/index.html",\n    ...         np.nan\n    ...     ]\n    ... )\n    >>> s\n    0                       this is a regular sentence\n    1    https://docs.python.org/3/tutorial/index.html\n    2                                              NaN\n    dtype: object\n\n    In the default setting, the string is split by whitespace.\n\n    >>> s.str.split()\n    0                   [this, is, a, regular, sentence]\n    1    [https://docs.python.org/3/tutorial/index.html]\n    2                                                NaN\n    dtype: object\n\n    Without the `n` parameter, the outputs of `rsplit` and `split`\n    are identical.\n\n    >>> s.str.rsplit()\n    0                   [this, is, a, regular, sentence]\n    1    [https://docs.python.org/3/tutorial/index.html]\n    2                                                NaN\n    dtype: object\n\n    The `n` parameter can be used to limit the number of splits on the\n    delimiter. The outputs of `split` and `rsplit` are different.\n\n    >>> s.str.split(n=2)\n    0                     [this, is, a regular sentence]\n    1    [https://docs.python.org/3/tutorial/index.html]\n    2                                                NaN\n    dtype: object\n\n    >>> s.str.rsplit(n=2)\n    0                     [this is a, regular, sentence]\n    1    [https://docs.python.org/3/tutorial/index.html]\n    2                                                NaN\n    dtype: object\n\n    The `pat` parameter can be used to split by other characters.\n\n    >>> s.str.split(pat="/")\n    0                         [this is a regular sentence]\n    1    [https:, , docs.python.org, 3, tutorial, index...\n    2                                                  NaN\n    dtype: object\n\n    When using ``expand=True``, the split elements will expand out into\n    separate columns. If NaN is present, it is propagated throughout\n    the columns during the split.\n\n    >>> s.str.split(expand=True)\n                                                   0     1     2        3         4\n    0                                           this    is     a  regular  sentence\n    1  https://docs.python.org/3/tutorial/index.html  None  None     None      None\n    2                                            NaN   NaN   NaN      NaN       NaN\n\n    For slightly more complex use cases like splitting the html document name\n    from a url, a combination of parameter settings can be used.\n\n    >>> s.str.rsplit("/", n=1, expand=True)\n                                        0           1\n    0          this is a regular sentence        None\n    1  https://docs.python.org/3/tutorial  index.html\n    2                                 NaN         NaN\n    %(regex_examples)s'
+
+    @Appender(_shared_docs['str_split'] % {'side': 'beginning', 'pat_regex': ' or compiled regex', 'pat_description': 'String or regular expression to split on', 'regex_argument': '\n    regex : bool, default None\n        Determines if the passed-in pattern is a regular expression:\n\n        - If ``True``, assumes the passed-in pattern is a regular expression\n        - If ``False``, treats the pattern as a literal string.\n        - If ``None`` and `pat` length is 1, treats `pat` as a literal string.\n        - If ``None`` and `pat` length is not 1, treats `pat` as a regular expression.\n        - Cannot be set to False if `pat` is a compiled regex\n\n        .. versionadded:: 1.4.0\n         ', 'raises_split': '\n                      Raises\n                      ------\n                      ValueError\n                          * if `regex` is False and `pat` is a compiled regex\n                      ', 'regex_pat_note': '\n    Use of `regex =False` with a `pat` as a compiled regex will raise an error.\n            ', 'method': 'split', 'regex_examples': '\n    Remember to escape special characters when explicitly using regular expressions.\n\n    >>> s = pd.Series(["foo and bar plus baz"])\n    >>> s.str.split(r"and|plus", expand=True)\n        0   1   2\n    0 foo bar baz\n\n    Regular expressions can be used to handle urls or file names.\n    When `pat` is a string and ``regex=None`` (the default), the given `pat` is compiled\n    as a regex only if ``len(pat) != 1``.\n\n    >>> s = pd.Series([\'foojpgbar.jpg\'])\n    >>> s.str.split(r".", expand=True)\n               0    1\n    0  foojpgbar  jpg\n\n    >>> s.str.split(r"\\.jpg", expand=True)\n               0 1\n    0  foojpgbar\n\n    When ``regex=True``, `pat` is interpreted as a regex\n\n    >>> s.str.split(r"\\.jpg", regex=True, expand=True)\n               0 1\n    0  foojpgbar\n\n    A compiled regex can be passed as `pat`\n\n    >>> import re\n    >>> s.str.split(re.compile(r"\\.jpg"), expand=True)\n               0 1\n    0  foojpgbar\n\n    When ``regex=False``, `pat` is interpreted as the string itself\n\n    >>> s.str.split(r"\\.jpg", regex=False, expand=True)\n                   0\n    0  foojpgbar.jpg\n    '})
+    @forbid_nonstring_types(['bytes'])
+    def split(self, pat: str | re.Pattern | None=None, *, n=-1, expand: bool=False, regex: bool | None=None):
+        if regex is False and is_re(pat):
+            raise ValueError('Cannot use a compiled regex as replacement pattern with regex=False')
+        if is_re(pat):
+            regex = True
+        result = self._data.array._str_split(pat, n, expand, regex)
+        if self._data.dtype == 'category':
+            dtype = self._data.dtype.categories.dtype
+        else:
+            dtype = object if self._data.dtype == object else None
+        return self._wrap_result(result, expand=expand, returns_string=expand, dtype=dtype)
+
+    @Appender(_shared_docs['str_split'] % {'side': 'end', 'pat_regex': '', 'pat_description': 'String to split on', 'regex_argument': '', 'raises_split': '', 'regex_pat_note': '', 'method': 'rsplit', 'regex_examples': ''})
+    @forbid_nonstring_types(['bytes'])
+    def rsplit(self, pat=None, *, n=-1, expand: bool=False):
+        result = self._data.array._str_rsplit(pat, n=n)
+        dtype = object if self._data.dtype == object else None
+        return self._wrap_result(result, expand=expand, returns_string=expand, dtype=dtype)
+    _shared_docs['str_partition'] = "\n    Split the string at the %(side)s occurrence of `sep`.\n\n    This method splits the string at the %(side)s occurrence of `sep`,\n    and returns 3 elements containing the part before the separator,\n    the separator itself, and the part after the separator.\n    If the separator is not found, return %(return)s.\n\n    Parameters\n    ----------\n    sep : str, default whitespace\n        String to split on.\n    expand : bool, default True\n        If True, return DataFrame/MultiIndex expanding dimensionality.\n        If False, return Series/Index.\n\n    Returns\n    -------\n    DataFrame/MultiIndex or Series/Index of objects\n        Returns appropriate type based on `expand` parameter with strings\n        split based on the `sep` parameter.\n\n    See Also\n    --------\n    %(also)s\n    Series.str.split : Split strings around given separators.\n    str.partition : Standard library version.\n\n    Examples\n    --------\n\n    >>> s = pd.Series(['Linda van der Berg', 'George Pitt-Rivers'])\n    >>> s\n    0    Linda van der Berg\n    1    George Pitt-Rivers\n    dtype: object\n\n    >>> s.str.partition()\n            0  1             2\n    0   Linda     van der Berg\n    1  George      Pitt-Rivers\n\n    To partition by the last space instead of the first one:\n\n    >>> s.str.rpartition()\n                   0  1            2\n    0  Linda van der            Berg\n    1         George     Pitt-Rivers\n\n    To partition by something different than a space:\n\n    >>> s.str.partition('-')\n                        0  1       2\n    0  Linda van der Berg\n    1         George Pitt  -  Rivers\n\n    To return a Series containing tuples instead of a DataFrame:\n\n    >>> s.str.partition('-', expand=False)\n    0    (Linda van der Berg, , )\n    1    (George Pitt, -, Rivers)\n    dtype: object\n\n    Also available on indices:\n\n    >>> idx = pd.Index(['X 123', 'Y 999'])\n    >>> idx\n    Index(['X 123', 'Y 999'], dtype='object')\n\n    Which will create a MultiIndex:\n\n    >>> idx.str.partition()\n    MultiIndex([('X', ' ', '123'),\n                ('Y', ' ', '999')],\n               )\n\n    Or an index with tuples with ``expand=False``:\n\n    >>> idx.str.partition(expand=False)\n    Index([('X', ' ', '123'), ('Y', ' ', '999')], dtype='object')\n    "
+
+    @Appender(_shared_docs['str_partition'] % {'side': 'first', 'return': '3 elements containing the string itself, followed by two empty strings', 'also': 'rpartition : Split the string at the last occurrence of `sep`.'})
+    @forbid_nonstring_types(['bytes'])
+    def partition(self, sep: str=' ', expand: bool=True):
+        result = self._data.array._str_partition(sep, expand)
+        if self._data.dtype == 'category':
+            dtype = self._data.dtype.categories.dtype
+        else:
+            dtype = object if self._data.dtype == object else None
+        return self._wrap_result(result, expand=expand, returns_string=expand, dtype=dtype)
+
+    @Appender(_shared_docs['str_partition'] % {'side': 'last', 'return': '3 elements containing two empty strings, followed by the string itself', 'also': 'partition : Split the string at the first occurrence of `sep`.'})
+    @forbid_nonstring_types(['bytes'])
+    def rpartition(self, sep: str=' ', expand: bool=True):
+        result = self._data.array._str_rpartition(sep, expand)
+        if self._data.dtype == 'category':
+            dtype = self._data.dtype.categories.dtype
+        else:
+            dtype = object if self._data.dtype == object else None
+        return self._wrap_result(result, expand=expand, returns_string=expand, dtype=dtype)
+
+    def get(self, i):
+        result = self._data.array._str_get(i)
+        return self._wrap_result(result)
+
+    @forbid_nonstring_types(['bytes'])
+    def join(self, sep: str):
+        result = self._data.array._str_join(sep)
+        return self._wrap_result(result)
+
+    @forbid_nonstring_types(['bytes'])
+    def contains(self, pat, case: bool=True, flags: int=0, na=None, regex: bool=True):
+        if regex and re.compile(pat).groups:
+            warnings.warn('This pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.', UserWarning, stacklevel=find_stack_level())
+        result = self._data.array._str_contains(pat, case, flags, na, regex)
+        return self._wrap_result(result, fill_value=na, returns_string=False)
+
+    @forbid_nonstring_types(['bytes'])
+    def match(self, pat: str, case: bool=True, flags: int=0, na=None):
+        result = self._data.array._str_match(pat, case=case, flags=flags, na=na)
+        return self._wrap_result(result, fill_value=na, returns_string=False)
+
+    @forbid_nonstring_types(['bytes'])
+    def fullmatch(self, pat, case: bool=True, flags: int=0, na=None):
+        result = self._data.array._str_fullmatch(pat, case=case, flags=flags, na=na)
+        return self._wrap_result(result, fill_value=na, returns_string=False)
+
+    @forbid_nonstring_types(['bytes'])
+    def replace(self, pat: str | re.Pattern | dict, repl: str | Callable | None=None, n: int=-1, case: bool | None=None, flags: int=0, regex: bool=False):
+        if isinstance(pat, dict) and repl is not None:
+            raise ValueError('repl cannot be used when pat is a dictionary')
+        if not isinstance(pat, dict) and (not (isinstance(repl, str) or callable(repl))):
+            raise TypeError('repl must be a string or callable')
+        is_compiled_re = is_re(pat)
+        if regex or regex is None:
+            if is_compiled_re and (case is not None or flags != 0):
+                raise ValueError('case and flags cannot be set when pat is a compiled regex')
+        elif is_compiled_re:
+            raise ValueError('Cannot use a compiled regex as replacement pattern with regex=False')
+        elif callable(repl):
+            raise ValueError('Cannot use a callable replacement when regex=False')
+        if case is None:
+            case = True
+        res_output = self._data
+        if not isinstance(pat, dict):
+            pat = {pat: repl}
+        for (key, value) in pat.items():
+            result = res_output.array._str_replace(key, value, n=n, case=case, flags=flags, regex=regex)
+            res_output = self._wrap_result(result)
+        return res_output
+
+    @forbid_nonstring_types(['bytes'])
+    def repeat(self, repeats):
+        result = self._data.array._str_repeat(repeats)
+        return self._wrap_result(result)
+
+    @forbid_nonstring_types(['bytes'])
+    def pad(self, width: int, side: Literal['left', 'right', 'both']='left', fillchar: str=' '):
+        if not isinstance(fillchar, str):
+            msg = f'fillchar must be a character, not {type(fillchar).__name__}'
+            raise TypeError(msg)
+        if len(fillchar) != 1:
+            raise TypeError('fillchar must be a character, not str')
+        if not is_integer(width):
+            msg = f'width must be of integer type, not {type(width).__name__}'
+            raise TypeError(msg)
+        result = self._data.array._str_pad(width, side=side, fillchar=fillchar)
+        return self._wrap_result(result)
+    _shared_docs['str_pad'] = "\n    Pad %(side)s side of strings in the Series/Index.\n\n    Equivalent to :meth:`str.%(method)s`.\n\n    Parameters\n    ----------\n    width : int\n        Minimum width of resulting string; additional characters will be filled\n        with ``fillchar``.\n    fillchar : str\n        Additional character for filling, default is whitespace.\n\n    Returns\n    -------\n    Series/Index of objects.\n        A Series or Index where the strings are modified by :meth:`str.%(method)s`.\n\n    See Also\n    --------\n    Series.str.rjust : Fills the left side of strings with an arbitrary\n        character.\n    Series.str.ljust : Fills the right side of strings with an arbitrary\n        character.\n    Series.str.center : Fills both sides of strings with an arbitrary\n        character.\n    Series.str.zfill : Pad strings in the Series/Index by prepending '0'\n        character.\n\n    Examples\n    --------\n    For Series.str.center:\n\n    >>> ser = pd.Series(['dog', 'bird', 'mouse'])\n    >>> ser.str.center(8, fillchar='.')\n    0   ..dog...\n    1   ..bird..\n    2   .mouse..\n    dtype: object\n\n    For Series.str.ljust:\n\n    >>> ser = pd.Series(['dog', 'bird', 'mouse'])\n    >>> ser.str.ljust(8, fillchar='.')\n    0   dog.....\n    1   bird....\n    2   mouse...\n    dtype: object\n\n    For Series.str.rjust:\n\n    >>> ser = pd.Series(['dog', 'bird', 'mouse'])\n    >>> ser.str.rjust(8, fillchar='.')\n    0   .....dog\n    1   ....bird\n    2   ...mouse\n    dtype: object\n    "
+
+    @Appender(_shared_docs['str_pad'] % {'side': 'left and right', 'method': 'center'})
+    @forbid_nonstring_types(['bytes'])
+    def center(self, width: int, fillchar: str=' '):
+        return self.pad(width, side='both', fillchar=fillchar)
+
+    @Appender(_shared_docs['str_pad'] % {'side': 'right', 'method': 'ljust'})
+    @forbid_nonstring_types(['bytes'])
+    def ljust(self, width: int, fillchar: str=' '):
+        return self.pad(width, side='right', fillchar=fillchar)
+
+    @Appender(_shared_docs['str_pad'] % {'side': 'left', 'method': 'rjust'})
+    @forbid_nonstring_types(['bytes'])
+    def rjust(self, width: int, fillchar: str=' '):
+        return self.pad(width, side='left', fillchar=fillchar)
+
+    @forbid_nonstring_types(['bytes'])
+    def zfill(self, width: int):
+        if not is_integer(width):
+            msg = f'width must be of integer type, not {type(width).__name__}'
+            raise TypeError(msg)
+        f = lambda x: x.zfill(width)
+        result = self._data.array._str_map(f)
+        return self._wrap_result(result)
+
+    def slice(self, start=None, stop=None, step=None):
+        result = self._data.array._str_slice(start, stop, step)
+        return self._wrap_result(result)
+
+    @forbid_nonstring_types(['bytes'])
+    def slice_replace(self, start=None, stop=None, repl=None):
+        result = self._data.array._str_slice_replace(start, stop, repl)
+        return self._wrap_result(result)
+
+    def decode(self, encoding, errors: str='strict'):
+        if encoding in _cpython_optimized_decoders:
+            f = lambda x: x.decode(encoding, errors)
+        else:
+            decoder = codecs.getdecoder(encoding)
+            f = lambda x: decoder(x, errors)[0]
+        arr = self._data.array
+        result = arr._str_map(f)
+        return self._wrap_result(result)
+
+    @forbid_nonstring_types(['bytes'])
+    def encode(self, encoding, errors: str='strict'):
+        result = self._data.array._str_encode(encoding, errors)
+        return self._wrap_result(result, returns_string=False)
+    _shared_docs['str_strip'] = "\n    Remove %(position)s characters.\n\n    Strip whitespaces (including newlines) or a set of specified characters\n    from each string in the Series/Index from %(side)s.\n    Replaces any non-strings in Series with NaNs.\n    Equivalent to :meth:`str.%(method)s`.\n\n    Parameters\n    ----------\n    to_strip : str or None, default None\n        Specifying the set of characters to be removed.\n        All combinations of this set of characters will be stripped.\n        If None then whitespaces are removed.\n\n    Returns\n    -------\n    Series or Index of object\n        Series or Index with the strings being stripped from the %(side)s.\n\n    See Also\n    --------\n    Series.str.strip : Remove leading and trailing characters in Series/Index.\n    Series.str.lstrip : Remove leading characters in Series/Index.\n    Series.str.rstrip : Remove trailing characters in Series/Index.\n\n    Examples\n    --------\n    >>> s = pd.Series(['1. Ant.  ', '2. Bee!\\n', '3. Cat?\\t', np.nan, 10, True])\n    >>> s\n    0    1. Ant.\n    1    2. Bee!\\n\n    2    3. Cat?\\t\n    3          NaN\n    4           10\n    5         True\n    dtype: object\n\n    >>> s.str.strip()\n    0    1. Ant.\n    1    2. Bee!\n    2    3. Cat?\n    3        NaN\n    4        NaN\n    5        NaN\n    dtype: object\n\n    >>> s.str.lstrip('123.')\n    0    Ant.\n    1    Bee!\\n\n    2    Cat?\\t\n    3       NaN\n    4       NaN\n    5       NaN\n    dtype: object\n\n    >>> s.str.rstrip('.!? \\n\\t')\n    0    1. Ant\n    1    2. Bee\n    2    3. Cat\n    3       NaN\n    4       NaN\n    5       NaN\n    dtype: object\n\n    >>> s.str.strip('123.!? \\n\\t')\n    0    Ant\n    1    Bee\n    2    Cat\n    3    NaN\n    4    NaN\n    5    NaN\n    dtype: object\n    "
+
+    @Appender(_shared_docs['str_strip'] % {'side': 'left and right sides', 'method': 'strip', 'position': 'leading and trailing'})
+    @forbid_nonstring_types(['bytes'])
+    def strip(self, to_strip=None):
+        result = self._data.array._str_strip(to_strip)
+        return self._wrap_result(result)
+
+    @Appender(_shared_docs['str_strip'] % {'side': 'left side', 'method': 'lstrip', 'position': 'leading'})
+    @forbid_nonstring_types(['bytes'])
+    def lstrip(self, to_strip=None):
+        result = self._data.array._str_lstrip(to_strip)
+        return self._wrap_result(result)
+
+    @Appender(_shared_docs['str_strip'] % {'side': 'right side', 'method': 'rstrip', 'position': 'trailing'})
+    @forbid_nonstring_types(['bytes'])
+    def rstrip(self, to_strip=None):
+        result = self._data.array._str_rstrip(to_strip)
+        return self._wrap_result(result)
+    _shared_docs['str_removefix'] = '\n    Remove a %(side)s from an object series.\n\n    If the %(side)s is not present, the original string will be returned.\n\n    Parameters\n    ----------\n    %(side)s : str\n        Remove the %(side)s of the string.\n\n    Returns\n    -------\n    Series/Index: object\n        The Series or Index with given %(side)s removed.\n\n    See Also\n    --------\n    Series.str.remove%(other_side)s : Remove a %(other_side)s from an object series.\n\n    Examples\n    --------\n    >>> s = pd.Series(["str_foo", "str_bar", "no_prefix"])\n    >>> s\n    0    str_foo\n    1    str_bar\n    2    no_prefix\n    dtype: object\n    >>> s.str.removeprefix("str_")\n    0    foo\n    1    bar\n    2    no_prefix\n    dtype: object\n\n    >>> s = pd.Series(["foo_str", "bar_str", "no_suffix"])\n    >>> s\n    0    foo_str\n    1    bar_str\n    2    no_suffix\n    dtype: object\n    >>> s.str.removesuffix("_str")\n    0    foo\n    1    bar\n    2    no_suffix\n    dtype: object\n    '
+
+    @Appender(_shared_docs['str_removefix'] % {'side': 'prefix', 'other_side': 'suffix'})
+    @forbid_nonstring_types(['bytes'])
+    def removeprefix(self, prefix: str):
+        result = self._data.array._str_removeprefix(prefix)
+        return self._wrap_result(result)
+
+    @Appender(_shared_docs['str_removefix'] % {'side': 'suffix', 'other_side': 'prefix'})
+    @forbid_nonstring_types(['bytes'])
+    def removesuffix(self, suffix: str):
+        result = self._data.array._str_removesuffix(suffix)
+        return self._wrap_result(result)
+
+    @forbid_nonstring_types(['bytes'])
+    def wrap(self, width: int, expand_tabs: bool=True, tabsize: int=8, replace_whitespace: bool=True, drop_whitespace: bool=True, initial_indent: str='', subsequent_indent: str='', fix_sentence_endings: bool=False, break_long_words: bool=True, break_on_hyphens: bool=True, max_lines: int | None=None, placeholder: str=' [...]'):
+        result = self._data.array._str_wrap(width=width, expand_tabs=expand_tabs, tabsize=tabsize, replace_whitespace=replace_whitespace, drop_whitespace=drop_whitespace, initial_indent=initial_indent, subsequent_indent=subsequent_indent, fix_sentence_endings=fix_sentence_endings, break_long_words=break_long_words, break_on_hyphens=break_on_hyphens, max_lines=max_lines, placeholder=placeholder)
+        return self._wrap_result(result)
+
+    @forbid_nonstring_types(['bytes'])
+    def get_dummies(self, sep: str='|', dtype: NpDtype | None=None):
+        from pandas.core.frame import DataFrame
+        (result, name) = self._data.array._str_get_dummies(sep, dtype)
+        if is_extension_array_dtype(dtype) or isinstance(dtype, ArrowDtype):
+            return self._wrap_result(DataFrame(result, columns=name, dtype=dtype), name=name, returns_string=False)
+        return self._wrap_result(result, name=name, expand=True, returns_string=False)
+
+    @forbid_nonstring_types(['bytes'])
+    def translate(self, table):
+        result = self._data.array._str_translate(table)
+        dtype = object if self._data.dtype == 'object' else None
+        return self._wrap_result(result, dtype=dtype)
+
+    @forbid_nonstring_types(['bytes'])
+    def count(self, pat, flags: int=0):
+        result = self._data.array._str_count(pat, flags)
+        return self._wrap_result(result, returns_string=False)
+
+    @forbid_nonstring_types(['bytes'])
+    def startswith(self, pat: str | tuple[str, ...], na: Scalar | None=None) -> Series | Index:
+        if not isinstance(pat, (str, tuple)):
+            msg = f'expected a string or tuple, not {type(pat).__name__}'
+            raise TypeError(msg)
+        result = self._data.array._str_startswith(pat, na=na)
+        return self._wrap_result(result, returns_string=False)
+
+    @forbid_nonstring_types(['bytes'])
+    def endswith(self, pat: str | tuple[str, ...], na: Scalar | None=None) -> Series | Index:
+        if not isinstance(pat, (str, tuple)):
+            msg = f'expected a string or tuple, not {type(pat).__name__}'
+            raise TypeError(msg)
+        result = self._data.array._str_endswith(pat, na=na)
+        return self._wrap_result(result, returns_string=False)
+
+    @forbid_nonstring_types(['bytes'])
+    def findall(self, pat, flags: int=0):
+        result = self._data.array._str_findall(pat, flags)
+        return self._wrap_result(result, returns_string=False)
+
+    @forbid_nonstring_types(['bytes'])
+    def extract(self, pat: str, flags: int=0, expand: bool=True) -> DataFrame | Series | Index:
+        from pandas import DataFrame
+        if not isinstance(expand, bool):
+            raise ValueError('expand must be True or False')
+        regex = re.compile(pat, flags=flags)
+        if regex.groups == 0:
+            raise ValueError('pattern contains no capture groups')
+        if not expand and regex.groups > 1 and isinstance(self._data, ABCIndex):
+            raise ValueError('only one regex group is supported with Index')
+        obj = self._data
+        result_dtype = _result_dtype(obj)
+        returns_df = regex.groups > 1 or expand
+        if returns_df:
+            name = None
+            columns = _get_group_names(regex)
+            if obj.array.size == 0:
+                result = DataFrame(columns=columns, dtype=result_dtype)
+            else:
+                result_list = self._data.array._str_extract(pat, flags=flags, expand=returns_df)
+                result_index: Index | None
+                if isinstance(obj, ABCSeries):
+                    result_index = obj.index
+                else:
+                    result_index = None
+                result = DataFrame(result_list, columns=columns, index=result_index, dtype=result_dtype)
+        else:
+            name = _get_single_group_name(regex)
+            result = self._data.array._str_extract(pat, flags=flags, expand=returns_df)
+        return self._wrap_result(result, name=name, dtype=result_dtype)
+
+    @forbid_nonstring_types(['bytes'])
+    def extractall(self, pat, flags: int=0) -> DataFrame:
+        return str_extractall(self._orig, pat, flags)
+    _shared_docs['find'] = '\n    Return %(side)s indexes in each strings in the Series/Index.\n\n    Each of returned indexes corresponds to the position where the\n    substring is fully contained between [start:end]. Return -1 on\n    failure. Equivalent to standard :meth:`str.%(method)s`.\n\n    Parameters\n    ----------\n    sub : str\n        Substring being searched.\n    start : int\n        Left edge index.\n    end : int\n        Right edge index.\n\n    Returns\n    -------\n    Series or Index of int.\n        A Series (if the input is a Series) or an Index (if the input is an\n        Index) of the %(side)s indexes corresponding to the positions where the\n        substring is found in each string of the input.\n\n    See Also\n    --------\n    %(also)s\n\n    Examples\n    --------\n    For Series.str.find:\n\n    >>> ser = pd.Series(["_cow_", "duck_", "do_v_e"])\n    >>> ser.str.find("_")\n    0   0\n    1   4\n    2   2\n    dtype: int64\n\n    For Series.str.rfind:\n\n    >>> ser = pd.Series(["_cow_", "duck_", "do_v_e"])\n    >>> ser.str.rfind("_")\n    0   4\n    1   4\n    2   4\n    dtype: int64\n    '
+
+    @Appender(_shared_docs['find'] % {'side': 'lowest', 'method': 'find', 'also': 'rfind : Return highest indexes in each strings.'})
+    @forbid_nonstring_types(['bytes'])
+    def find(self, sub, start: int=0, end=None):
+        if not isinstance(sub, str):
+            msg = f'expected a string object, not {type(sub).__name__}'
+            raise TypeError(msg)
+        result = self._data.array._str_find(sub, start, end)
+        return self._wrap_result(result, returns_string=False)
+
+    @Appender(_shared_docs['find'] % {'side': 'highest', 'method': 'rfind', 'also': 'find : Return lowest indexes in each strings.'})
+    @forbid_nonstring_types(['bytes'])
+    def rfind(self, sub, start: int=0, end=None):
+        if not isinstance(sub, str):
+            msg = f'expected a string object, not {type(sub).__name__}'
+            raise TypeError(msg)
+        result = self._data.array._str_rfind(sub, start=start, end=end)
+        return self._wrap_result(result, returns_string=False)
+
+    @forbid_nonstring_types(['bytes'])
+    def normalize(self, form):
+        result = self._data.array._str_normalize(form)
+        return self._wrap_result(result)
+    _shared_docs['index'] = '\n    Return %(side)s indexes in each string in Series/Index.\n\n    Each of the returned indexes corresponds to the position where the\n    substring is fully contained between [start:end]. This is the same\n    as ``str.%(similar)s`` except instead of returning -1, it raises a\n    ValueError when the substring is not found. Equivalent to standard\n    ``str.%(method)s``.\n\n    Parameters\n    ----------\n    sub : str\n        Substring being searched.\n    start : int\n        Left edge index.\n    end : int\n        Right edge index.\n\n    Returns\n    -------\n    Series or Index of object\n        Returns a Series or an Index of the %(side)s indexes\n        in each string of the input.\n\n    See Also\n    --------\n    %(also)s\n\n    Examples\n    --------\n    For Series.str.index:\n\n    >>> ser = pd.Series(["horse", "eagle", "donkey"])\n    >>> ser.str.index("e")\n    0   4\n    1   0\n    2   4\n    dtype: int64\n\n    For Series.str.rindex:\n\n    >>> ser = pd.Series(["Deer", "eagle", "Sheep"])\n    >>> ser.str.rindex("e")\n    0   2\n    1   4\n    2   3\n    dtype: int64\n    '
+
+    @Appender(_shared_docs['index'] % {'side': 'lowest', 'similar': 'find', 'method': 'index', 'also': 'rindex : Return highest indexes in each strings.'})
+    @forbid_nonstring_types(['bytes'])
+    def index(self, sub, start: int=0, end=None):
+        if not isinstance(sub, str):
+            msg = f'expected a string object, not {type(sub).__name__}'
+            raise TypeError(msg)
+        result = self._data.array._str_index(sub, start=start, end=end)
+        return self._wrap_result(result, returns_string=False)
+
+    @Appender(_shared_docs['index'] % {'side': 'highest', 'similar': 'rfind', 'method': 'rindex', 'also': 'index : Return lowest indexes in each strings.'})
+    @forbid_nonstring_types(['bytes'])
+    def rindex(self, sub, start: int=0, end=None):
+        if not isinstance(sub, str):
+            msg = f'expected a string object, not {type(sub).__name__}'
+            raise TypeError(msg)
+        result = self._data.array._str_rindex(sub, start=start, end=end)
+        return self._wrap_result(result, returns_string=False)
+
+    def len(self):
+        result = self._data.array._str_len()
+        return self._wrap_result(result, returns_string=False)
+    _shared_docs['casemethods'] = "\n    Convert strings in the Series/Index to %(type)s.\n    %(version)s\n    Equivalent to :meth:`str.%(method)s`.\n\n    Returns\n    -------\n    Series or Index of objects\n        A Series or Index where the strings are modified by :meth:`str.%(method)s`.\n\n    See Also\n    --------\n    Series.str.lower : Converts all characters to lowercase.\n    Series.str.upper : Converts all characters to uppercase.\n    Series.str.title : Converts first character of each word to uppercase and\n        remaining to lowercase.\n    Series.str.capitalize : Converts first character to uppercase and\n        remaining to lowercase.\n    Series.str.swapcase : Converts uppercase to lowercase and lowercase to\n        uppercase.\n    Series.str.casefold: Removes all case distinctions in the string.\n\n    Examples\n    --------\n    >>> s = pd.Series(['lower', 'CAPITALS', 'this is a sentence', 'SwApCaSe'])\n    >>> s\n    0                 lower\n    1              CAPITALS\n    2    this is a sentence\n    3              SwApCaSe\n    dtype: object\n\n    >>> s.str.lower()\n    0                 lower\n    1              capitals\n    2    this is a sentence\n    3              swapcase\n    dtype: object\n\n    >>> s.str.upper()\n    0                 LOWER\n    1              CAPITALS\n    2    THIS IS A SENTENCE\n    3              SWAPCASE\n    dtype: object\n\n    >>> s.str.title()\n    0                 Lower\n    1              Capitals\n    2    This Is A Sentence\n    3              Swapcase\n    dtype: object\n\n    >>> s.str.capitalize()\n    0                 Lower\n    1              Capitals\n    2    This is a sentence\n    3              Swapcase\n    dtype: object\n\n    >>> s.str.swapcase()\n    0                 LOWER\n    1              capitals\n    2    THIS IS A SENTENCE\n    3              sWaPcAsE\n    dtype: object\n    "
+    _doc_args: dict[str, dict[str, str]] = {}
+    _doc_args['lower'] = {'type': 'lowercase', 'method': 'lower', 'version': ''}
+    _doc_args['upper'] = {'type': 'uppercase', 'method': 'upper', 'version': ''}
+    _doc_args['title'] = {'type': 'titlecase', 'method': 'title', 'version': ''}
+    _doc_args['capitalize'] = {'type': 'be capitalized', 'method': 'capitalize', 'version': ''}
+    _doc_args['swapcase'] = {'type': 'be swapcased', 'method': 'swapcase', 'version': ''}
+    _doc_args['casefold'] = {'type': 'be casefolded', 'method': 'casefold', 'version': ''}
+
+    @Appender(_shared_docs['casemethods'] % _doc_args['lower'])
+    @forbid_nonstring_types(['bytes'])
+    def lower(self):
+        result = self._data.array._str_lower()
+        return self._wrap_result(result)
+
+    @Appender(_shared_docs['casemethods'] % _doc_args['upper'])
+    @forbid_nonstring_types(['bytes'])
+    def upper(self):
+        result = self._data.array._str_upper()
+        return self._wrap_result(result)
+
+    @Appender(_shared_docs['casemethods'] % _doc_args['title'])
+    @forbid_nonstring_types(['bytes'])
+    def title(self):
+        result = self._data.array._str_title()
+        return self._wrap_result(result)
+
+    @Appender(_shared_docs['casemethods'] % _doc_args['capitalize'])
+    @forbid_nonstring_types(['bytes'])
+    def capitalize(self):
+        result = self._data.array._str_capitalize()
+        return self._wrap_result(result)
+
+    @Appender(_shared_docs['casemethods'] % _doc_args['swapcase'])
+    @forbid_nonstring_types(['bytes'])
+    def swapcase(self):
+        result = self._data.array._str_swapcase()
+        return self._wrap_result(result)
+
+    @Appender(_shared_docs['casemethods'] % _doc_args['casefold'])
+    @forbid_nonstring_types(['bytes'])
+    def casefold(self):
+        result = self._data.array._str_casefold()
+        return self._wrap_result(result)
+    _shared_docs['ismethods'] = "\n    Check whether all characters in each string are %(type)s.\n\n    This is equivalent to running the Python string method\n    :meth:`str.%(method)s` for each element of the Series/Index. If a string\n    has zero characters, ``False`` is returned for that check.\n\n    Returns\n    -------\n    Series or Index of bool\n        Series or Index of boolean values with the same length as the original\n        Series/Index.\n\n    See Also\n    --------\n    Series.str.isalpha : Check whether all characters are alphabetic.\n    Series.str.isnumeric : Check whether all characters are numeric.\n    Series.str.isalnum : Check whether all characters are alphanumeric.\n    Series.str.isdigit : Check whether all characters are digits.\n    Series.str.isdecimal : Check whether all characters are decimal.\n    Series.str.isspace : Check whether all characters are whitespace.\n    Series.str.islower : Check whether all characters are lowercase.\n    Series.str.isupper : Check whether all characters are uppercase.\n    Series.str.istitle : Check whether all characters are titlecase.\n\n    Examples\n    --------\n    **Checks for Alphabetic and Numeric Characters**\n\n    >>> s1 = pd.Series(['one', 'one1', '1', ''])\n\n    >>> s1.str.isalpha()\n    0     True\n    1    False\n    2    False\n    3    False\n    dtype: bool\n\n    >>> s1.str.isnumeric()\n    0    False\n    1    False\n    2     True\n    3    False\n    dtype: bool\n\n    >>> s1.str.isalnum()\n    0     True\n    1     True\n    2     True\n    3    False\n    dtype: bool\n\n    Note that checks against characters mixed with any additional punctuation\n    or whitespace will evaluate to false for an alphanumeric check.\n\n    >>> s2 = pd.Series(['A B', '1.5', '3,000'])\n    >>> s2.str.isalnum()\n    0    False\n    1    False\n    2    False\n    dtype: bool\n\n    **More Detailed Checks for Numeric Characters**\n\n    There are several different but overlapping sets of numeric characters that\n    can be checked for.\n\n    >>> s3 = pd.Series(['23', '³', '⅕', ''])\n\n    The ``s3.str.isdecimal`` method checks for characters used to form numbers\n    in base 10.\n\n    >>> s3.str.isdecimal()\n    0     True\n    1    False\n    2    False\n    3    False\n    dtype: bool\n\n    The ``s.str.isdigit`` method is the same as ``s3.str.isdecimal`` but also\n    includes special digits, like superscripted and subscripted digits in\n    unicode.\n\n    >>> s3.str.isdigit()\n    0     True\n    1     True\n    2    False\n    3    False\n    dtype: bool\n\n    The ``s.str.isnumeric`` method is the same as ``s3.str.isdigit`` but also\n    includes other characters that can represent quantities such as unicode\n    fractions.\n\n    >>> s3.str.isnumeric()\n    0     True\n    1     True\n    2     True\n    3    False\n    dtype: bool\n\n    **Checks for Whitespace**\n\n    >>> s4 = pd.Series([' ', '\\t\\r\\n ', ''])\n    >>> s4.str.isspace()\n    0     True\n    1     True\n    2    False\n    dtype: bool\n\n    **Checks for Character Case**\n\n    >>> s5 = pd.Series(['leopard', 'Golden Eagle', 'SNAKE', ''])\n\n    >>> s5.str.islower()\n    0     True\n    1    False\n    2    False\n    3    False\n    dtype: bool\n\n    >>> s5.str.isupper()\n    0    False\n    1    False\n    2     True\n    3    False\n    dtype: bool\n\n    The ``s5.str.istitle`` method checks for whether all words are in title\n    case (whether only the first letter of each word is capitalized). Words are\n    assumed to be as any sequence of non-numeric characters separated by\n    whitespace characters.\n\n    >>> s5.str.istitle()\n    0    False\n    1     True\n    2    False\n    3    False\n    dtype: bool\n    "
+    _doc_args['isalnum'] = {'type': 'alphanumeric', 'method': 'isalnum'}
+    _doc_args['isalpha'] = {'type': 'alphabetic', 'method': 'isalpha'}
+    _doc_args['isdigit'] = {'type': 'digits', 'method': 'isdigit'}
+    _doc_args['isspace'] = {'type': 'whitespace', 'method': 'isspace'}
+    _doc_args['islower'] = {'type': 'lowercase', 'method': 'islower'}
+    _doc_args['isupper'] = {'type': 'uppercase', 'method': 'isupper'}
+    _doc_args['istitle'] = {'type': 'titlecase', 'method': 'istitle'}
+    _doc_args['isnumeric'] = {'type': 'numeric', 'method': 'isnumeric'}
+    _doc_args['isdecimal'] = {'type': 'decimal', 'method': 'isdecimal'}
+    isalnum = _map_and_wrap('isalnum', docstring=_shared_docs['ismethods'] % _doc_args['isalnum'])
+    isalpha = _map_and_wrap('isalpha', docstring=_shared_docs['ismethods'] % _doc_args['isalpha'])
+    isdigit = _map_and_wrap('isdigit', docstring=_shared_docs['ismethods'] % _doc_args['isdigit'])
+    isspace = _map_and_wrap('isspace', docstring=_shared_docs['ismethods'] % _doc_args['isspace'])
+    islower = _map_and_wrap('islower', docstring=_shared_docs['ismethods'] % _doc_args['islower'])
+    isupper = _map_and_wrap('isupper', docstring=_shared_docs['ismethods'] % _doc_args['isupper'])
+    istitle = _map_and_wrap('istitle', docstring=_shared_docs['ismethods'] % _doc_args['istitle'])
+    isnumeric = _map_and_wrap('isnumeric', docstring=_shared_docs['ismethods'] % _doc_args['isnumeric'])
+    isdecimal = _map_and_wrap('isdecimal', docstring=_shared_docs['ismethods'] % _doc_args['isdecimal'])
+
+def cat_safe(list_of_columns: list[npt.NDArray[np.object_]], sep: str):
+    try:
+        result = cat_core(list_of_columns, sep)
+    except TypeError:
+        for column in list_of_columns:
+            dtype = lib.infer_dtype(column, skipna=True)
+            if dtype not in ['string', 'empty']:
+                raise TypeError(f'Concatenation requires list-likes containing only strings (or missing values). Offending values found in column {dtype}') from None
+    return result
+
+def cat_core(list_of_columns: list, sep: str):
+    if sep == '':
+        arr_of_cols = np.asarray(list_of_columns, dtype=object)
+        return np.sum(arr_of_cols, axis=0)
+    list_with_sep = [sep] * (2 * len(list_of_columns) - 1)
+    list_with_sep[::2] = list_of_columns
+    arr_with_sep = np.asarray(list_with_sep, dtype=object)
+    return np.sum(arr_with_sep, axis=0)
+
+def _result_dtype(arr):
+    from pandas.core.arrays.string_ import StringDtype
+    if isinstance(arr.dtype, (ArrowDtype, StringDtype)):
+        return arr.dtype
+    return object
+
+def _get_single_group_name(regex: re.Pattern) -> Hashable:
+    if regex.groupindex:
+        return next(iter(regex.groupindex))
+    else:
+        return None
+
+def _get_group_names(regex: re.Pattern) -> list[Hashable] | range:
+    rng = range(regex.groups)
+    names = {v: k for (k, v) in regex.groupindex.items()}
+    if not names:
+        return rng
+    result: list[Hashable] = [names.get(1 + i, i) for i in rng]
+    arr = np.array(result)
+    if arr.dtype.kind == 'i' and lib.is_range_indexer(arr, len(arr)):
+        return rng
+    return result
+
+def str_extractall(arr, pat, flags: int=0) -> DataFrame:
+    regex = re.compile(pat, flags=flags)
+    if regex.groups == 0:
+        raise ValueError('pattern contains no capture groups')
+    if isinstance(arr, ABCIndex):
+        arr = arr.to_series().reset_index(drop=True).astype(arr.dtype)
+    columns = _get_group_names(regex)
+    match_list = []
+    index_list = []
+    is_mi = arr.index.nlevels > 1
+    for (subject_key, subject) in arr.items():
+        if isinstance(subject, str):
+            if not is_mi:
+                subject_key = (subject_key,)
+            for (match_i, match_tuple) in enumerate(regex.findall(subject)):
+                if isinstance(match_tuple, str):
+                    match_tuple = (match_tuple,)
+                na_tuple = [np.nan if group == '' else group for group in match_tuple]
+                match_list.append(na_tuple)
+                result_key = tuple(subject_key + (match_i,))
+                index_list.append(result_key)
+    from pandas import MultiIndex
+    index = MultiIndex.from_tuples(index_list, names=arr.index.names + ['match'])
+    dtype = _result_dtype(arr)
+    result = arr._constructor_expanddim(match_list, index=index, columns=columns, dtype=dtype)
+    return result
+
+# File: pandas-main/pandas/core/strings/base.py
+from __future__ import annotations
+import abc
+from typing import TYPE_CHECKING, Literal
+import numpy as np
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+    import re
+    from pandas._typing import NpDtype, Scalar, Self
+
+class BaseStringArrayMethods(abc.ABC):
+
+    def _str_getitem(self, key):
+        if isinstance(key, slice):
+            return self._str_slice(start=key.start, stop=key.stop, step=key.step)
+        else:
+            return self._str_get(key)
+
+    @abc.abstractmethod
+    def _str_count(self, pat, flags: int=0):
+        pass
+
+    @abc.abstractmethod
+    def _str_pad(self, width: int, side: Literal['left', 'right', 'both']='left', fillchar: str=' '):
+        pass
+
+    @abc.abstractmethod
+    def _str_contains(self, pat, case: bool=True, flags: int=0, na=None, regex: bool=True):
+        pass
+
+    @abc.abstractmethod
+    def _str_startswith(self, pat, na=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_endswith(self, pat, na=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_replace(self, pat: str | re.Pattern, repl: str | Callable, n: int=-1, case: bool=True, flags: int=0, regex: bool=True):
+        pass
+
+    @abc.abstractmethod
+    def _str_repeat(self, repeats: int | Sequence[int]):
+        pass
+
+    @abc.abstractmethod
+    def _str_match(self, pat: str, case: bool=True, flags: int=0, na: Scalar=np.nan):
+        pass
+
+    @abc.abstractmethod
+    def _str_fullmatch(self, pat: str | re.Pattern, case: bool=True, flags: int=0, na: Scalar=np.nan):
+        pass
+
+    @abc.abstractmethod
+    def _str_encode(self, encoding, errors: str='strict'):
+        pass
+
+    @abc.abstractmethod
+    def _str_find(self, sub, start: int=0, end=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_rfind(self, sub, start: int=0, end=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_findall(self, pat, flags: int=0):
+        pass
+
+    @abc.abstractmethod
+    def _str_get(self, i):
+        pass
+
+    @abc.abstractmethod
+    def _str_index(self, sub, start: int=0, end=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_rindex(self, sub, start: int=0, end=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_join(self, sep: str):
+        pass
+
+    @abc.abstractmethod
+    def _str_partition(self, sep: str, expand):
+        pass
+
+    @abc.abstractmethod
+    def _str_rpartition(self, sep: str, expand):
+        pass
+
+    @abc.abstractmethod
+    def _str_len(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_slice(self, start=None, stop=None, step=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_slice_replace(self, start=None, stop=None, repl=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_translate(self, table):
+        pass
+
+    @abc.abstractmethod
+    def _str_wrap(self, width: int, **kwargs):
+        pass
+
+    @abc.abstractmethod
+    def _str_get_dummies(self, sep: str='|', dtype: NpDtype | None=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_isalnum(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_isalpha(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_isdecimal(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_isdigit(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_islower(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_isnumeric(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_isspace(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_istitle(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_isupper(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_capitalize(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_casefold(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_title(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_swapcase(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_lower(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_upper(self):
+        pass
+
+    @abc.abstractmethod
+    def _str_normalize(self, form):
+        pass
+
+    @abc.abstractmethod
+    def _str_strip(self, to_strip=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_lstrip(self, to_strip=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_rstrip(self, to_strip=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_removeprefix(self, prefix: str) -> Self:
+        pass
+
+    @abc.abstractmethod
+    def _str_removesuffix(self, suffix: str) -> Self:
+        pass
+
+    @abc.abstractmethod
+    def _str_split(self, pat=None, n=-1, expand: bool=False, regex: bool | None=None):
+        pass
+
+    @abc.abstractmethod
+    def _str_rsplit(self, pat=None, n=-1):
+        pass
+
+    @abc.abstractmethod
+    def _str_extract(self, pat: str, flags: int=0, expand: bool=True):
+        pass
+
+# File: pandas-main/pandas/core/strings/object_array.py
+from __future__ import annotations
+import functools
+import re
+import textwrap
+from typing import TYPE_CHECKING, Literal, cast
+import unicodedata
+import warnings
+import numpy as np
+from pandas._libs import lib
+import pandas._libs.missing as libmissing
+import pandas._libs.ops as libops
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import pandas_dtype
+from pandas.core.dtypes.missing import isna
+from pandas.core.strings.base import BaseStringArrayMethods
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+    from pandas._typing import NpDtype, Scalar
+
+class ObjectStringArrayMixin(BaseStringArrayMethods):
+
+    def __len__(self) -> int:
+        raise NotImplementedError
+
+    def _str_map(self, f, na_value=None, dtype: NpDtype | None=None, convert: bool=True):
+        if dtype is None:
+            dtype = np.dtype('object')
+        if na_value is None:
+            na_value = self.dtype.na_value
+        if not len(self):
+            return np.array([], dtype=dtype)
+        arr = np.asarray(self, dtype=object)
+        mask = isna(arr)
+        map_convert = convert and (not np.all(mask))
+        try:
+            result = lib.map_infer_mask(arr, f, mask.view(np.uint8), convert=map_convert)
+        except (TypeError, AttributeError) as err:
+            p_err = '((takes)|(missing)) (?(2)from \\d+ to )?\\d+ (?(3)required )positional arguments?'
+            if len(err.args) >= 1 and re.search(p_err, err.args[0]):
+                raise err
+
+            def g(x):
+                try:
+                    return f(x)
+                except (TypeError, AttributeError):
+                    return na_value
+            return self._str_map(g, na_value=na_value, dtype=dtype)
+        if not isinstance(result, np.ndarray):
+            return result
+        if na_value is not np.nan:
+            np.putmask(result, mask, na_value)
+            if convert and result.dtype == object:
+                result = lib.maybe_convert_objects(result)
+        return result
+
+    def _str_count(self, pat, flags: int=0):
+        regex = re.compile(pat, flags=flags)
+        f = lambda x: len(regex.findall(x))
+        return self._str_map(f, dtype='int64')
+
+    def _str_pad(self, width: int, side: Literal['left', 'right', 'both']='left', fillchar: str=' '):
+        if side == 'left':
+            f = lambda x: x.rjust(width, fillchar)
+        elif side == 'right':
+            f = lambda x: x.ljust(width, fillchar)
+        elif side == 'both':
+            f = lambda x: x.center(width, fillchar)
+        else:
+            raise ValueError('Invalid side')
+        return self._str_map(f)
+
+    def _str_contains(self, pat, case: bool=True, flags: int=0, na=np.nan, regex: bool=True):
+        if regex:
+            if not case:
+                flags |= re.IGNORECASE
+            pat = re.compile(pat, flags=flags)
+            f = lambda x: pat.search(x) is not None
+        elif case:
+            f = lambda x: pat in x
+        else:
+            upper_pat = pat.upper()
+            f = lambda x: upper_pat in x.upper()
+        if not isna(na) and (not isinstance(na, bool)):
+            warnings.warn("Allowing a non-bool 'na' in obj.str.contains is deprecated and will raise in a future version.", FutureWarning, stacklevel=find_stack_level())
+        return self._str_map(f, na, dtype=np.dtype('bool'))
+
+    def _str_startswith(self, pat, na=None):
+        f = lambda x: x.startswith(pat)
+        if not isna(na) and (not isinstance(na, bool)):
+            warnings.warn("Allowing a non-bool 'na' in obj.str.startswith is deprecated and will raise in a future version.", FutureWarning, stacklevel=find_stack_level())
+        return self._str_map(f, na_value=na, dtype=np.dtype(bool))
+
+    def _str_endswith(self, pat, na=None):
+        f = lambda x: x.endswith(pat)
+        if not isna(na) and (not isinstance(na, bool)):
+            warnings.warn("Allowing a non-bool 'na' in obj.str.endswith is deprecated and will raise in a future version.", FutureWarning, stacklevel=find_stack_level())
+        return self._str_map(f, na_value=na, dtype=np.dtype(bool))
+
+    def _str_replace(self, pat: str | re.Pattern, repl: str | Callable, n: int=-1, case: bool=True, flags: int=0, regex: bool=True):
+        if case is False:
+            flags |= re.IGNORECASE
+        if regex or flags or callable(repl):
+            if not isinstance(pat, re.Pattern):
+                if regex is False:
+                    pat = re.escape(pat)
+                pat = re.compile(pat, flags=flags)
+            n = n if n >= 0 else 0
+            f = lambda x: pat.sub(repl=repl, string=x, count=n)
+        else:
+            f = lambda x: x.replace(pat, repl, n)
+        return self._str_map(f, dtype=str)
+
+    def _str_repeat(self, repeats: int | Sequence[int]):
+        if lib.is_integer(repeats):
+            rint = cast(int, repeats)
+
+            def scalar_rep(x):
+                try:
+                    return bytes.__mul__(x, rint)
+                except TypeError:
+                    return str.__mul__(x, rint)
+            return self._str_map(scalar_rep, dtype=str)
+        else:
+            from pandas.core.arrays.string_ import BaseStringArray
+
+            def rep(x, r):
+                if x is libmissing.NA:
+                    return x
+                try:
+                    return bytes.__mul__(x, r)
+                except TypeError:
+                    return str.__mul__(x, r)
+            result = libops.vec_binop(np.asarray(self), np.asarray(repeats, dtype=object), rep)
+            if not isinstance(self, BaseStringArray):
+                return result
+            return type(self)._from_sequence(result, dtype=self.dtype)
+
+    def _str_match(self, pat: str, case: bool=True, flags: int=0, na: Scalar | None=None):
+        if not case:
+            flags |= re.IGNORECASE
+        regex = re.compile(pat, flags=flags)
+        f = lambda x: regex.match(x) is not None
+        return self._str_map(f, na_value=na, dtype=np.dtype(bool))
+
+    def _str_fullmatch(self, pat: str | re.Pattern, case: bool=True, flags: int=0, na: Scalar | None=None):
+        if not case:
+            flags |= re.IGNORECASE
+        regex = re.compile(pat, flags=flags)
+        f = lambda x: regex.fullmatch(x) is not None
+        return self._str_map(f, na_value=na, dtype=np.dtype(bool))
+
+    def _str_encode(self, encoding, errors: str='strict'):
+        f = lambda x: x.encode(encoding, errors=errors)
+        return self._str_map(f, dtype=object)
+
+    def _str_find(self, sub, start: int=0, end=None):
+        return self._str_find_(sub, start, end, side='left')
+
+    def _str_rfind(self, sub, start: int=0, end=None):
+        return self._str_find_(sub, start, end, side='right')
+
+    def _str_find_(self, sub, start, end, side):
+        if side == 'left':
+            method = 'find'
+        elif side == 'right':
+            method = 'rfind'
+        else:
+            raise ValueError('Invalid side')
+        if end is None:
+            f = lambda x: getattr(x, method)(sub, start)
+        else:
+            f = lambda x: getattr(x, method)(sub, start, end)
+        return self._str_map(f, dtype='int64')
+
+    def _str_findall(self, pat, flags: int=0):
+        regex = re.compile(pat, flags=flags)
+        return self._str_map(regex.findall, dtype='object')
+
+    def _str_get(self, i):
+
+        def f(x):
+            if isinstance(x, dict):
+                return x.get(i)
+            elif len(x) > i >= -len(x):
+                return x[i]
+            return self.dtype.na_value
+        return self._str_map(f)
+
+    def _str_index(self, sub, start: int=0, end=None):
+        if end:
+            f = lambda x: x.index(sub, start, end)
+        else:
+            f = lambda x: x.index(sub, start, end)
+        return self._str_map(f, dtype='int64')
+
+    def _str_rindex(self, sub, start: int=0, end=None):
+        if end:
+            f = lambda x: x.rindex(sub, start, end)
+        else:
+            f = lambda x: x.rindex(sub, start, end)
+        return self._str_map(f, dtype='int64')
+
+    def _str_join(self, sep: str):
+        return self._str_map(sep.join)
+
+    def _str_partition(self, sep: str, expand):
+        result = self._str_map(lambda x: x.partition(sep), dtype='object')
+        return result
+
+    def _str_rpartition(self, sep: str, expand):
+        return self._str_map(lambda x: x.rpartition(sep), dtype='object')
+
+    def _str_len(self):
+        return self._str_map(len, dtype='int64')
+
+    def _str_slice(self, start=None, stop=None, step=None):
+        obj = slice(start, stop, step)
+        return self._str_map(lambda x: x[obj])
+
+    def _str_slice_replace(self, start=None, stop=None, repl=None):
+        if repl is None:
+            repl = ''
+
+        def f(x):
+            if x[start:stop] == '':
+                local_stop = start
+            else:
+                local_stop = stop
+            y = ''
+            if start is not None:
+                y += x[:start]
+            y += repl
+            if stop is not None:
+                y += x[local_stop:]
+            return y
+        return self._str_map(f)
+
+    def _str_split(self, pat: str | re.Pattern | None=None, n=-1, expand: bool=False, regex: bool | None=None):
+        if pat is None:
+            if n is None or n == 0:
+                n = -1
+            f = lambda x: x.split(pat, n)
+        else:
+            new_pat: str | re.Pattern
+            if regex is True or isinstance(pat, re.Pattern):
+                new_pat = re.compile(pat)
+            elif regex is False:
+                new_pat = pat
+            elif len(pat) == 1:
+                new_pat = pat
+            else:
+                new_pat = re.compile(pat)
+            if isinstance(new_pat, re.Pattern):
+                if n is None or n == -1:
+                    n = 0
+                f = lambda x: new_pat.split(x, maxsplit=n)
+            else:
+                if n is None or n == 0:
+                    n = -1
+                f = lambda x: x.split(pat, n)
+        return self._str_map(f, dtype=object)
+
+    def _str_rsplit(self, pat=None, n=-1):
+        if n is None or n == 0:
+            n = -1
+        f = lambda x: x.rsplit(pat, n)
+        return self._str_map(f, dtype='object')
+
+    def _str_translate(self, table):
+        return self._str_map(lambda x: x.translate(table))
+
+    def _str_wrap(self, width: int, **kwargs):
+        kwargs['width'] = width
+        tw = textwrap.TextWrapper(**kwargs)
+        return self._str_map(lambda s: '\n'.join(tw.wrap(s)))
+
+    def _str_get_dummies(self, sep: str='|', dtype: NpDtype | None=None):
+        from pandas import Series
+        if dtype is None:
+            dtype = np.int64
+        arr = Series(self).fillna('')
+        try:
+            arr = sep + arr + sep
+        except (TypeError, NotImplementedError):
+            arr = sep + arr.astype(str) + sep
+        tags: set[str] = set()
+        for ts in Series(arr, copy=False).str.split(sep):
+            tags.update(ts)
+        tags2 = sorted(tags - {''})
+        _dtype = pandas_dtype(dtype)
+        dummies_dtype: NpDtype
+        if isinstance(_dtype, np.dtype):
+            dummies_dtype = _dtype
+        else:
+            dummies_dtype = np.bool_
+        dummies = np.empty((len(arr), len(tags2)), dtype=dummies_dtype)
+
+        def _isin(test_elements: str, element: str) -> bool:
+            return element in test_elements
+        for (i, t) in enumerate(tags2):
+            pat = sep + t + sep
+            dummies[:, i] = lib.map_infer(arr.to_numpy(), functools.partial(_isin, element=pat))
+        return (dummies, tags2)
+
+    def _str_upper(self):
+        return self._str_map(lambda x: x.upper())
+
+    def _str_isalnum(self):
+        return self._str_map(str.isalnum, dtype='bool')
+
+    def _str_isalpha(self):
+        return self._str_map(str.isalpha, dtype='bool')
+
+    def _str_isdecimal(self):
+        return self._str_map(str.isdecimal, dtype='bool')
+
+    def _str_isdigit(self):
+        return self._str_map(str.isdigit, dtype='bool')
+
+    def _str_islower(self):
+        return self._str_map(str.islower, dtype='bool')
+
+    def _str_isnumeric(self):
+        return self._str_map(str.isnumeric, dtype='bool')
+
+    def _str_isspace(self):
+        return self._str_map(str.isspace, dtype='bool')
+
+    def _str_istitle(self):
+        return self._str_map(str.istitle, dtype='bool')
+
+    def _str_isupper(self):
+        return self._str_map(str.isupper, dtype='bool')
+
+    def _str_capitalize(self):
+        return self._str_map(str.capitalize)
+
+    def _str_casefold(self):
+        return self._str_map(str.casefold)
+
+    def _str_title(self):
+        return self._str_map(str.title)
+
+    def _str_swapcase(self):
+        return self._str_map(str.swapcase)
+
+    def _str_lower(self):
+        return self._str_map(str.lower)
+
+    def _str_normalize(self, form):
+        f = lambda x: unicodedata.normalize(form, x)
+        return self._str_map(f)
+
+    def _str_strip(self, to_strip=None):
+        return self._str_map(lambda x: x.strip(to_strip))
+
+    def _str_lstrip(self, to_strip=None):
+        return self._str_map(lambda x: x.lstrip(to_strip))
+
+    def _str_rstrip(self, to_strip=None):
+        return self._str_map(lambda x: x.rstrip(to_strip))
+
+    def _str_removeprefix(self, prefix: str):
+        return self._str_map(lambda x: x.removeprefix(prefix))
+
+    def _str_removesuffix(self, suffix: str):
+        return self._str_map(lambda x: x.removesuffix(suffix))
+
+    def _str_extract(self, pat: str, flags: int=0, expand: bool=True):
+        regex = re.compile(pat, flags=flags)
+        na_value = self.dtype.na_value
+        if not expand:
+
+            def g(x):
+                m = regex.search(x)
+                return m.groups()[0] if m else na_value
+            return self._str_map(g, convert=False)
+        empty_row = [na_value] * regex.groups
+
+        def f(x):
+            if not isinstance(x, str):
+                return empty_row
+            m = regex.search(x)
+            if m:
+                return [na_value if item is None else item for item in m.groups()]
+            else:
+                return empty_row
+        return [f(val) for val in np.asarray(self)]
+
+# File: pandas-main/pandas/core/tools/datetimes.py
+from __future__ import annotations
+from collections import abc
+from datetime import date
+from functools import partial
+from itertools import islice
+from typing import TYPE_CHECKING, TypedDict, Union, cast, overload
+import warnings
+import numpy as np
+from pandas._libs import lib, tslib
+from pandas._libs.tslibs import OutOfBoundsDatetime, Timedelta, Timestamp, astype_overflowsafe, is_supported_dtype, timezones as libtimezones
+from pandas._libs.tslibs.conversion import cast_from_unit_vectorized
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas._libs.tslibs.parsing import DateParseError, guess_datetime_format
+from pandas._libs.tslibs.strptime import array_strptime
+from pandas._typing import AnyArrayLike, ArrayLike, DateTimeErrorChoices
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import ensure_object, is_float, is_integer, is_integer_dtype, is_list_like, is_numeric_dtype
+from pandas.core.dtypes.dtypes import ArrowDtype, DatetimeTZDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.arrays import DatetimeArray, IntegerArray, NumpyExtensionArray
+from pandas.core.algorithms import unique
+from pandas.core.arrays import ArrowExtensionArray
+from pandas.core.arrays.base import ExtensionArray
+from pandas.core.arrays.datetimes import maybe_convert_dtype, objects_to_datetime64, tz_to_dtype
+from pandas.core.construction import extract_array
+from pandas.core.indexes.base import Index
+from pandas.core.indexes.datetimes import DatetimeIndex
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable
+    from pandas._libs.tslibs.nattype import NaTType
+    from pandas._libs.tslibs.timedeltas import UnitChoices
+    from pandas import DataFrame, Series
+ArrayConvertible = Union[list, tuple, AnyArrayLike]
+Scalar = Union[float, str]
+DatetimeScalar = Union[Scalar, date, np.datetime64]
+DatetimeScalarOrArrayConvertible = Union[DatetimeScalar, ArrayConvertible]
+DatetimeDictArg = Union[list[Scalar], tuple[Scalar, ...], AnyArrayLike]
+
+class YearMonthDayDict(TypedDict, total=True):
+    year: DatetimeDictArg
+    month: DatetimeDictArg
+    day: DatetimeDictArg
+
+class FulldatetimeDict(YearMonthDayDict, total=False):
+    hour: DatetimeDictArg
+    hours: DatetimeDictArg
+    minute: DatetimeDictArg
+    minutes: DatetimeDictArg
+    second: DatetimeDictArg
+    seconds: DatetimeDictArg
+    ms: DatetimeDictArg
+    us: DatetimeDictArg
+    ns: DatetimeDictArg
+DictConvertible = Union[FulldatetimeDict, 'DataFrame']
+start_caching_at = 50
+
+def _guess_datetime_format_for_array(arr, dayfirst: bool | None=False) -> str | None:
+    if (first_non_null := tslib.first_non_null(arr)) != -1:
+        if type((first_non_nan_element := arr[first_non_null])) is str:
+            guessed_format = guess_datetime_format(first_non_nan_element, dayfirst=dayfirst)
+            if guessed_format is not None:
+                return guessed_format
+            if tslib.first_non_null(arr[first_non_null + 1:]) != -1:
+                warnings.warn('Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.', UserWarning, stacklevel=find_stack_level())
+    return None
+
+def should_cache(arg: ArrayConvertible, unique_share: float=0.7, check_count: int | None=None) -> bool:
+    do_caching = True
+    if check_count is None:
+        if len(arg) <= start_caching_at:
+            return False
+        if len(arg) <= 5000:
+            check_count = len(arg) // 10
+        else:
+            check_count = 500
+    else:
+        assert 0 <= check_count <= len(arg), 'check_count must be in next bounds: [0; len(arg)]'
+        if check_count == 0:
+            return False
+    assert 0 < unique_share < 1, 'unique_share must be in next bounds: (0; 1)'
+    try:
+        unique_elements = set(islice(arg, check_count))
+    except TypeError:
+        return False
+    if len(unique_elements) > check_count * unique_share:
+        do_caching = False
+    return do_caching
+
+def _maybe_cache(arg: ArrayConvertible, format: str | None, cache: bool, convert_listlike: Callable) -> Series:
+    from pandas import Series
+    cache_array = Series(dtype=object)
+    if cache:
+        if not should_cache(arg):
+            return cache_array
+        if not isinstance(arg, (np.ndarray, ExtensionArray, Index, ABCSeries)):
+            arg = np.array(arg)
+        unique_dates = unique(arg)
+        if len(unique_dates) < len(arg):
+            cache_dates = convert_listlike(unique_dates, format)
+            try:
+                cache_array = Series(cache_dates, index=unique_dates, copy=False)
+            except OutOfBoundsDatetime:
+                return cache_array
+            if not cache_array.index.is_unique:
+                cache_array = cache_array[~cache_array.index.duplicated()]
+    return cache_array
+
+def _box_as_indexlike(dt_array: ArrayLike, utc: bool=False, name: Hashable | None=None) -> Index:
+    if lib.is_np_dtype(dt_array.dtype, 'M'):
+        tz = 'utc' if utc else None
+        return DatetimeIndex(dt_array, tz=tz, name=name)
+    return Index(dt_array, name=name, dtype=dt_array.dtype)
+
+def _convert_and_box_cache(arg: DatetimeScalarOrArrayConvertible, cache_array: Series, name: Hashable | None=None) -> Index:
+    from pandas import Series
+    result = Series(arg, dtype=cache_array.index.dtype).map(cache_array)
+    return _box_as_indexlike(result._values, utc=False, name=name)
+
+def _convert_listlike_datetimes(arg, format: str | None, name: Hashable | None=None, utc: bool=False, unit: str | None=None, errors: DateTimeErrorChoices='raise', dayfirst: bool | None=None, yearfirst: bool | None=None, exact: bool=True):
+    if isinstance(arg, (list, tuple)):
+        arg = np.array(arg, dtype='O')
+    elif isinstance(arg, NumpyExtensionArray):
+        arg = np.array(arg)
+    arg_dtype = getattr(arg, 'dtype', None)
+    tz = 'utc' if utc else None
+    if isinstance(arg_dtype, DatetimeTZDtype):
+        if not isinstance(arg, (DatetimeArray, DatetimeIndex)):
+            return DatetimeIndex(arg, tz=tz, name=name)
+        if utc:
+            arg = arg.tz_convert(None).tz_localize('utc')
+        return arg
+    elif isinstance(arg_dtype, ArrowDtype) and arg_dtype.type is Timestamp:
+        if utc:
+            if isinstance(arg, Index):
+                arg_array = cast(ArrowExtensionArray, arg.array)
+                if arg_dtype.pyarrow_dtype.tz is not None:
+                    arg_array = arg_array._dt_tz_convert('UTC')
+                else:
+                    arg_array = arg_array._dt_tz_localize('UTC')
+                arg = Index(arg_array)
+            elif arg_dtype.pyarrow_dtype.tz is not None:
+                arg = arg._dt_tz_convert('UTC')
+            else:
+                arg = arg._dt_tz_localize('UTC')
+        return arg
+    elif lib.is_np_dtype(arg_dtype, 'M'):
+        if not is_supported_dtype(arg_dtype):
+            arg = astype_overflowsafe(np.asarray(arg), np.dtype('M8[s]'), is_coerce=errors == 'coerce')
+        if not isinstance(arg, (DatetimeArray, DatetimeIndex)):
+            return DatetimeIndex(arg, tz=tz, name=name)
+        elif utc:
+            return arg.tz_localize('utc')
+        return arg
+    elif unit is not None:
+        if format is not None:
+            raise ValueError('cannot specify both format and unit')
+        return _to_datetime_with_unit(arg, unit, name, utc, errors)
+    elif getattr(arg, 'ndim', 1) > 1:
+        raise TypeError('arg must be a string, datetime, list, tuple, 1-d array, or Series')
+    try:
+        (arg, _) = maybe_convert_dtype(arg, copy=False, tz=libtimezones.maybe_get_tz(tz))
+    except TypeError:
+        if errors == 'coerce':
+            npvalues = np.full(len(arg), np.datetime64('NaT', 'ns'))
+            return DatetimeIndex(npvalues, name=name)
+        raise
+    arg = ensure_object(arg)
+    if format is None:
+        format = _guess_datetime_format_for_array(arg, dayfirst=dayfirst)
+    if format is not None and format != 'mixed':
+        return _array_strptime_with_fallback(arg, name, utc, format, exact, errors)
+    (result, tz_parsed) = objects_to_datetime64(arg, dayfirst=dayfirst, yearfirst=yearfirst, utc=utc, errors=errors, allow_object=True)
+    if tz_parsed is not None:
+        out_unit = np.datetime_data(result.dtype)[0]
+        dtype = tz_to_dtype(tz_parsed, out_unit)
+        dt64_values = result.view(f'M8[{dtype.unit}]')
+        dta = DatetimeArray._simple_new(dt64_values, dtype=dtype)
+        return DatetimeIndex._simple_new(dta, name=name)
+    return _box_as_indexlike(result, utc=utc, name=name)
+
+def _array_strptime_with_fallback(arg, name, utc: bool, fmt: str, exact: bool, errors: str) -> Index:
+    (result, tz_out) = array_strptime(arg, fmt, exact=exact, errors=errors, utc=utc)
+    if tz_out is not None:
+        unit = np.datetime_data(result.dtype)[0]
+        dtype = DatetimeTZDtype(tz=tz_out, unit=unit)
+        dta = DatetimeArray._simple_new(result, dtype=dtype)
+        if utc:
+            dta = dta.tz_convert('UTC')
+        return Index(dta, name=name)
+    elif result.dtype != object and utc:
+        unit = np.datetime_data(result.dtype)[0]
+        res = Index(result, dtype=f'M8[{unit}, UTC]', name=name)
+        return res
+    return Index(result, dtype=result.dtype, name=name)
+
+def _to_datetime_with_unit(arg, unit, name, utc: bool, errors: str) -> Index:
+    arg = extract_array(arg, extract_numpy=True)
+    if isinstance(arg, IntegerArray):
+        arr = arg.astype(f'datetime64[{unit}]')
+        tz_parsed = None
+    else:
+        arg = np.asarray(arg)
+        if arg.dtype.kind in 'iu':
+            arr = arg.astype(f'datetime64[{unit}]', copy=False)
+            try:
+                arr = astype_overflowsafe(arr, np.dtype('M8[ns]'), copy=False)
+            except OutOfBoundsDatetime:
+                if errors == 'raise':
+                    raise
+                arg = arg.astype(object)
+                return _to_datetime_with_unit(arg, unit, name, utc, errors)
+            tz_parsed = None
+        elif arg.dtype.kind == 'f':
+            with np.errstate(over='raise'):
+                try:
+                    arr = cast_from_unit_vectorized(arg, unit=unit)
+                except OutOfBoundsDatetime as err:
+                    if errors != 'raise':
+                        return _to_datetime_with_unit(arg.astype(object), unit, name, utc, errors)
+                    raise OutOfBoundsDatetime(f"cannot convert input with unit '{unit}'") from err
+            arr = arr.view('M8[ns]')
+            tz_parsed = None
+        else:
+            arg = arg.astype(object, copy=False)
+            (arr, tz_parsed) = tslib.array_to_datetime(arg, utc=utc, errors=errors, unit_for_numerics=unit, creso=NpyDatetimeUnit.NPY_FR_ns.value)
+    result = DatetimeIndex(arr, name=name)
+    if not isinstance(result, DatetimeIndex):
+        return result
+    result = result.tz_localize('UTC').tz_convert(tz_parsed)
+    if utc:
+        if result.tz is None:
+            result = result.tz_localize('utc')
+        else:
+            result = result.tz_convert('utc')
+    return result
+
+def _adjust_to_origin(arg, origin, unit):
+    if origin == 'julian':
+        original = arg
+        j0 = Timestamp(0).to_julian_date()
+        if unit != 'D':
+            raise ValueError("unit must be 'D' for origin='julian'")
+        try:
+            arg = arg - j0
+        except TypeError as err:
+            raise ValueError("incompatible 'arg' type for given 'origin'='julian'") from err
+        j_max = Timestamp.max.to_julian_date() - j0
+        j_min = Timestamp.min.to_julian_date() - j0
+        if np.any(arg > j_max) or np.any(arg < j_min):
+            raise OutOfBoundsDatetime(f"{original} is Out of Bounds for origin='julian'")
+    else:
+        if not ((is_integer(arg) or is_float(arg)) or is_numeric_dtype(np.asarray(arg))):
+            raise ValueError(f"'{arg}' is not compatible with origin='{origin}'; it must be numeric with a unit specified")
+        try:
+            offset = Timestamp(origin, unit=unit)
+        except OutOfBoundsDatetime as err:
+            raise OutOfBoundsDatetime(f'origin {origin} is Out of Bounds') from err
+        except ValueError as err:
+            raise ValueError(f'origin {origin} cannot be converted to a Timestamp') from err
+        if offset.tz is not None:
+            raise ValueError(f'origin offset {offset} must be tz-naive')
+        td_offset = offset - Timestamp(0)
+        ioffset = td_offset // Timedelta(1, unit=unit)
+        if is_list_like(arg) and (not isinstance(arg, (ABCSeries, Index, np.ndarray))):
+            arg = np.asarray(arg)
+        arg = arg + ioffset
+    return arg
+
+@overload
+def to_datetime(arg: DatetimeScalar, errors: DateTimeErrorChoices=..., dayfirst: bool=..., yearfirst: bool=..., utc: bool=..., format: str | None=..., exact: bool=..., unit: str | None=..., origin=..., cache: bool=...) -> Timestamp:
+    ...
+
+@overload
+def to_datetime(arg: Series | DictConvertible, errors: DateTimeErrorChoices=..., dayfirst: bool=..., yearfirst: bool=..., utc: bool=..., format: str | None=..., exact: bool=..., unit: str | None=..., origin=..., cache: bool=...) -> Series:
+    ...
+
+@overload
+def to_datetime(arg: list | tuple | Index | ArrayLike, errors: DateTimeErrorChoices=..., dayfirst: bool=..., yearfirst: bool=..., utc: bool=..., format: str | None=..., exact: bool=..., unit: str | None=..., origin=..., cache: bool=...) -> DatetimeIndex:
+    ...
+
+def to_datetime(arg: DatetimeScalarOrArrayConvertible | DictConvertible, errors: DateTimeErrorChoices='raise', dayfirst: bool=False, yearfirst: bool=False, utc: bool=False, format: str | None=None, exact: bool | lib.NoDefault=lib.no_default, unit: str | None=None, origin: str='unix', cache: bool=True) -> DatetimeIndex | Series | DatetimeScalar | NaTType | None:
+    if exact is not lib.no_default and format in {'mixed', 'ISO8601'}:
+        raise ValueError("Cannot use 'exact' when 'format' is 'mixed' or 'ISO8601'")
+    if arg is None:
+        return None
+    if origin != 'unix':
+        arg = _adjust_to_origin(arg, origin, unit)
+    convert_listlike = partial(_convert_listlike_datetimes, utc=utc, unit=unit, dayfirst=dayfirst, yearfirst=yearfirst, errors=errors, exact=exact)
+    result: Timestamp | NaTType | Series | Index
+    if isinstance(arg, Timestamp):
+        result = arg
+        if utc:
+            if arg.tz is not None:
+                result = arg.tz_convert('utc')
+            else:
+                result = arg.tz_localize('utc')
+    elif isinstance(arg, ABCSeries):
+        cache_array = _maybe_cache(arg, format, cache, convert_listlike)
+        if not cache_array.empty:
+            result = arg.map(cache_array)
+        else:
+            values = convert_listlike(arg._values, format)
+            result = arg._constructor(values, index=arg.index, name=arg.name)
+    elif isinstance(arg, (ABCDataFrame, abc.MutableMapping)):
+        result = _assemble_from_unit_mappings(arg, errors, utc)
+    elif isinstance(arg, Index):
+        cache_array = _maybe_cache(arg, format, cache, convert_listlike)
+        if not cache_array.empty:
+            result = _convert_and_box_cache(arg, cache_array, name=arg.name)
+        else:
+            result = convert_listlike(arg, format, name=arg.name)
+    elif is_list_like(arg):
+        try:
+            argc = cast(Union[list, tuple, ExtensionArray, np.ndarray, 'Series', Index], arg)
+            cache_array = _maybe_cache(argc, format, cache, convert_listlike)
+        except OutOfBoundsDatetime:
+            if errors == 'raise':
+                raise
+            from pandas import Series
+            cache_array = Series([], dtype=object)
+        if not cache_array.empty:
+            result = _convert_and_box_cache(argc, cache_array)
+        else:
+            result = convert_listlike(argc, format)
+    else:
+        result = convert_listlike(np.array([arg]), format)[0]
+        if isinstance(arg, bool) and isinstance(result, np.bool_):
+            result = bool(result)
+    return result
+_unit_map = {'year': 'year', 'years': 'year', 'month': 'month', 'months': 'month', 'day': 'day', 'days': 'day', 'hour': 'h', 'hours': 'h', 'minute': 'm', 'minutes': 'm', 'second': 's', 'seconds': 's', 'ms': 'ms', 'millisecond': 'ms', 'milliseconds': 'ms', 'us': 'us', 'microsecond': 'us', 'microseconds': 'us', 'ns': 'ns', 'nanosecond': 'ns', 'nanoseconds': 'ns'}
+
+def _assemble_from_unit_mappings(arg, errors: DateTimeErrorChoices, utc: bool) -> Series:
+    from pandas import DataFrame, to_numeric, to_timedelta
+    arg = DataFrame(arg)
+    if not arg.columns.is_unique:
+        raise ValueError('cannot assemble with duplicate keys')
+
+    def f(value):
+        if value in _unit_map:
+            return _unit_map[value]
+        if value.lower() in _unit_map:
+            return _unit_map[value.lower()]
+        return value
+    unit = {k: f(k) for k in arg.keys()}
+    unit_rev = {v: k for (k, v) in unit.items()}
+    required = ['year', 'month', 'day']
+    req = set(required) - set(unit_rev.keys())
+    if len(req):
+        _required = ','.join(sorted(req))
+        raise ValueError(f'to assemble mappings requires at least that [year, month, day] be specified: [{_required}] is missing')
+    excess = set(unit_rev.keys()) - set(_unit_map.values())
+    if len(excess):
+        _excess = ','.join(sorted(excess))
+        raise ValueError(f'extra keys have been passed to the datetime assemblage: [{_excess}]')
+
+    def coerce(values):
+        values = to_numeric(values, errors=errors)
+        if is_integer_dtype(values.dtype):
+            values = values.astype('int64')
+        return values
+    values = coerce(arg[unit_rev['year']]) * 10000 + coerce(arg[unit_rev['month']]) * 100 + coerce(arg[unit_rev['day']])
+    try:
+        values = to_datetime(values, format='%Y%m%d', errors=errors, utc=utc)
+    except (TypeError, ValueError) as err:
+        raise ValueError(f'cannot assemble the datetimes: {err}') from err
+    units: list[UnitChoices] = ['h', 'm', 's', 'ms', 'us', 'ns']
+    for u in units:
+        value = unit_rev.get(u)
+        if value is not None and value in arg:
+            try:
+                values += to_timedelta(coerce(arg[value]), unit=u, errors=errors)
+            except (TypeError, ValueError) as err:
+                raise ValueError(f'cannot assemble the datetimes [{value}]: {err}') from err
+    return values
+__all__ = ['DateParseError', 'should_cache', 'to_datetime']
+
+# File: pandas-main/pandas/core/tools/numeric.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, Literal
+import numpy as np
+from pandas._libs import lib, missing as libmissing
+from pandas.util._validators import check_dtype_backend
+from pandas.core.dtypes.cast import maybe_downcast_numeric
+from pandas.core.dtypes.common import ensure_object, is_bool_dtype, is_decimal, is_integer_dtype, is_number, is_numeric_dtype, is_scalar, is_string_dtype, needs_i8_conversion
+from pandas.core.dtypes.dtypes import ArrowDtype
+from pandas.core.dtypes.generic import ABCIndex, ABCSeries
+from pandas.core.arrays import BaseMaskedArray
+from pandas.core.arrays.string_ import StringDtype
+if TYPE_CHECKING:
+    from pandas._typing import DateTimeErrorChoices, DtypeBackend, npt
+
+def to_numeric(arg, errors: DateTimeErrorChoices='raise', downcast: Literal['integer', 'signed', 'unsigned', 'float'] | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default):
+    if downcast not in (None, 'integer', 'signed', 'unsigned', 'float'):
+        raise ValueError('invalid downcasting method provided')
+    if errors not in ('raise', 'coerce'):
+        raise ValueError('invalid error value specified')
+    check_dtype_backend(dtype_backend)
+    is_series = False
+    is_index = False
+    is_scalars = False
+    if isinstance(arg, ABCSeries):
+        is_series = True
+        values = arg.values
+    elif isinstance(arg, ABCIndex):
+        is_index = True
+        if needs_i8_conversion(arg.dtype):
+            values = arg.view('i8')
+        else:
+            values = arg.values
+    elif isinstance(arg, (list, tuple)):
+        values = np.array(arg, dtype='O')
+    elif is_scalar(arg):
+        if is_decimal(arg):
+            return float(arg)
+        if is_number(arg):
+            return arg
+        is_scalars = True
+        values = np.array([arg], dtype='O')
+    elif getattr(arg, 'ndim', 1) > 1:
+        raise TypeError('arg must be a list, tuple, 1-d array, or Series')
+    else:
+        values = arg
+    mask: npt.NDArray[np.bool_] | None = None
+    if isinstance(values, BaseMaskedArray):
+        mask = values._mask
+        values = values._data[~mask]
+    values_dtype = getattr(values, 'dtype', None)
+    if isinstance(values_dtype, ArrowDtype):
+        mask = values.isna()
+        values = values.dropna().to_numpy()
+    new_mask: np.ndarray | None = None
+    if is_numeric_dtype(values_dtype):
+        pass
+    elif lib.is_np_dtype(values_dtype, 'mM'):
+        values = values.view(np.int64)
+    else:
+        values = ensure_object(values)
+        coerce_numeric = errors != 'raise'
+        (values, new_mask) = lib.maybe_convert_numeric(values, set(), coerce_numeric=coerce_numeric, convert_to_masked_nullable=dtype_backend is not lib.no_default or (isinstance(values_dtype, StringDtype) and values_dtype.na_value is libmissing.NA))
+    if new_mask is not None:
+        values = values[~new_mask]
+    elif dtype_backend is not lib.no_default and new_mask is None or (isinstance(values_dtype, StringDtype) and values_dtype.na_value is libmissing.NA):
+        new_mask = np.zeros(values.shape, dtype=np.bool_)
+    if downcast is not None and is_numeric_dtype(values.dtype):
+        typecodes: str | None = None
+        if downcast in ('integer', 'signed'):
+            typecodes = np.typecodes['Integer']
+        elif downcast == 'unsigned' and (not len(values) or np.min(values) >= 0):
+            typecodes = np.typecodes['UnsignedInteger']
+        elif downcast == 'float':
+            typecodes = np.typecodes['Float']
+            float_32_char = np.dtype(np.float32).char
+            float_32_ind = typecodes.index(float_32_char)
+            typecodes = typecodes[float_32_ind:]
+        if typecodes is not None:
+            for typecode in typecodes:
+                dtype = np.dtype(typecode)
+                if dtype.itemsize <= values.dtype.itemsize:
+                    values = maybe_downcast_numeric(values, dtype)
+                    if values.dtype == dtype:
+                        break
+    if (mask is not None or new_mask is not None) and (not is_string_dtype(values.dtype)):
+        if mask is None or (new_mask is not None and new_mask.shape == mask.shape):
+            mask = new_mask
+        else:
+            mask = mask.copy()
+        assert isinstance(mask, np.ndarray)
+        data = np.zeros(mask.shape, dtype=values.dtype)
+        data[~mask] = values
+        from pandas.core.arrays import ArrowExtensionArray, BooleanArray, FloatingArray, IntegerArray
+        klass: type[IntegerArray | BooleanArray | FloatingArray]
+        if is_integer_dtype(data.dtype):
+            klass = IntegerArray
+        elif is_bool_dtype(data.dtype):
+            klass = BooleanArray
+        else:
+            klass = FloatingArray
+        values = klass(data, mask)
+        if dtype_backend == 'pyarrow' or isinstance(values_dtype, ArrowDtype):
+            values = ArrowExtensionArray(values.__arrow_array__())
+    if is_series:
+        return arg._constructor(values, index=arg.index, name=arg.name)
+    elif is_index:
+        from pandas import Index
+        return Index(values, name=arg.name)
+    elif is_scalars:
+        return values[0]
+    else:
+        return values
+
+# File: pandas-main/pandas/core/tools/timedeltas.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, overload
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.tslibs import NaT, NaTType
+from pandas._libs.tslibs.timedeltas import Timedelta, disallow_ambiguous_unit, parse_timedelta_unit
+from pandas.core.dtypes.common import is_list_like
+from pandas.core.dtypes.dtypes import ArrowDtype
+from pandas.core.dtypes.generic import ABCIndex, ABCSeries
+from pandas.core.arrays.timedeltas import sequence_to_td64ns
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+    from datetime import timedelta
+    from pandas._libs.tslibs.timedeltas import UnitChoices
+    from pandas._typing import ArrayLike, DateTimeErrorChoices
+    from pandas import Index, Series, TimedeltaIndex
+
+@overload
+def to_timedelta(arg: str | float | timedelta, unit: UnitChoices | None=..., errors: DateTimeErrorChoices=...) -> Timedelta:
+    ...
+
+@overload
+def to_timedelta(arg: Series, unit: UnitChoices | None=..., errors: DateTimeErrorChoices=...) -> Series:
+    ...
+
+@overload
+def to_timedelta(arg: list | tuple | range | ArrayLike | Index, unit: UnitChoices | None=..., errors: DateTimeErrorChoices=...) -> TimedeltaIndex:
+    ...
+
+def to_timedelta(arg: str | int | float | timedelta | list | tuple | range | ArrayLike | Index | Series, unit: UnitChoices | None=None, errors: DateTimeErrorChoices='raise') -> Timedelta | TimedeltaIndex | Series | NaTType | Any:
+    if unit is not None:
+        unit = parse_timedelta_unit(unit)
+        disallow_ambiguous_unit(unit)
+    if errors not in ('raise', 'coerce'):
+        raise ValueError("errors must be one of 'raise', or 'coerce'.")
+    if arg is None:
+        return arg
+    elif isinstance(arg, ABCSeries):
+        values = _convert_listlike(arg._values, unit=unit, errors=errors)
+        return arg._constructor(values, index=arg.index, name=arg.name)
+    elif isinstance(arg, ABCIndex):
+        return _convert_listlike(arg, unit=unit, errors=errors, name=arg.name)
+    elif isinstance(arg, np.ndarray) and arg.ndim == 0:
+        arg = lib.item_from_zerodim(arg)
+    elif is_list_like(arg) and getattr(arg, 'ndim', 1) == 1:
+        return _convert_listlike(arg, unit=unit, errors=errors)
+    elif getattr(arg, 'ndim', 1) > 1:
+        raise TypeError('arg must be a string, timedelta, list, tuple, 1-d array, or Series')
+    if isinstance(arg, str) and unit is not None:
+        raise ValueError('unit must not be specified if the input is/contains a str')
+    return _coerce_scalar_to_timedelta_type(arg, unit=unit, errors=errors)
+
+def _coerce_scalar_to_timedelta_type(r, unit: UnitChoices | None='ns', errors: DateTimeErrorChoices='raise') -> Timedelta | NaTType:
+    result: Timedelta | NaTType
+    try:
+        result = Timedelta(r, unit)
+    except ValueError:
+        if errors == 'raise':
+            raise
+        result = NaT
+    return result
+
+def _convert_listlike(arg, unit: UnitChoices | None=None, errors: DateTimeErrorChoices='raise', name: Hashable | None=None):
+    arg_dtype = getattr(arg, 'dtype', None)
+    if isinstance(arg, (list, tuple)) or arg_dtype is None:
+        arg = np.array(arg, dtype=object)
+    elif isinstance(arg_dtype, ArrowDtype) and arg_dtype.kind == 'm':
+        return arg
+    td64arr = sequence_to_td64ns(arg, unit=unit, errors=errors, copy=False)[0]
+    from pandas import TimedeltaIndex
+    value = TimedeltaIndex(td64arr, name=name)
+    return value
+
+# File: pandas-main/pandas/core/tools/times.py
+from __future__ import annotations
+from datetime import datetime, time
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs.lib import is_list_like
+from pandas.core.dtypes.generic import ABCIndex, ABCSeries
+from pandas.core.dtypes.missing import notna
+if TYPE_CHECKING:
+    from pandas._typing import DateTimeErrorChoices
+
+def to_time(arg, format: str | None=None, infer_time_format: bool=False, errors: DateTimeErrorChoices='raise'):
+    if errors not in ('raise', 'coerce'):
+        raise ValueError("errors must be one of 'raise', or 'coerce'.")
+
+    def _convert_listlike(arg, format):
+        if isinstance(arg, (list, tuple)):
+            arg = np.array(arg, dtype='O')
+        elif getattr(arg, 'ndim', 1) > 1:
+            raise TypeError('arg must be a string, datetime, list, tuple, 1-d array, or Series')
+        arg = np.asarray(arg, dtype='O')
+        if infer_time_format and format is None:
+            format = _guess_time_format_for_array(arg)
+        times: list[time | None] = []
+        if format is not None:
+            for element in arg:
+                try:
+                    times.append(datetime.strptime(element, format).time())
+                except (ValueError, TypeError) as err:
+                    if errors == 'raise':
+                        msg = f'Cannot convert {element} to a time with given format {format}'
+                        raise ValueError(msg) from err
+                    times.append(None)
+        else:
+            formats = _time_formats[:]
+            format_found = False
+            for element in arg:
+                time_object = None
+                try:
+                    time_object = time.fromisoformat(element)
+                except (ValueError, TypeError):
+                    for time_format in formats:
+                        try:
+                            time_object = datetime.strptime(element, time_format).time()
+                            if not format_found:
+                                fmt = formats.pop(formats.index(time_format))
+                                formats.insert(0, fmt)
+                                format_found = True
+                            break
+                        except (ValueError, TypeError):
+                            continue
+                if time_object is not None:
+                    times.append(time_object)
+                elif errors == 'raise':
+                    raise ValueError(f'Cannot convert arg {arg} to a time')
+                else:
+                    times.append(None)
+        return times
+    if arg is None:
+        return arg
+    elif isinstance(arg, time):
+        return arg
+    elif isinstance(arg, ABCSeries):
+        values = _convert_listlike(arg._values, format)
+        return arg._constructor(values, index=arg.index, name=arg.name)
+    elif isinstance(arg, ABCIndex):
+        return _convert_listlike(arg, format)
+    elif is_list_like(arg):
+        return _convert_listlike(arg, format)
+    return _convert_listlike(np.array([arg]), format)[0]
+_time_formats = ['%H:%M', '%H%M', '%I:%M%p', '%I%M%p', '%H:%M:%S', '%H%M%S', '%I:%M:%S%p', '%I%M%S%p']
+
+def _guess_time_format_for_array(arr):
+    non_nan_elements = notna(arr).nonzero()[0]
+    if len(non_nan_elements):
+        element = arr[non_nan_elements[0]]
+        for time_format in _time_formats:
+            try:
+                datetime.strptime(element, time_format)
+                return time_format
+            except ValueError:
+                pass
+    return None
+
+# File: pandas-main/pandas/core/util/hashing.py
+""""""
+from __future__ import annotations
+import itertools
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs.hashing import hash_object_array
+from pandas.core.dtypes.common import is_list_like
+from pandas.core.dtypes.dtypes import CategoricalDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCExtensionArray, ABCIndex, ABCMultiIndex, ABCSeries
+if TYPE_CHECKING:
+    from collections.abc import Hashable, Iterable, Iterator
+    from pandas._typing import ArrayLike, npt
+    from pandas import DataFrame, Index, MultiIndex, Series
+_default_hash_key = '0123456789123456'
+
+def combine_hash_arrays(arrays: Iterator[np.ndarray], num_items: int) -> npt.NDArray[np.uint64]:
+    try:
+        first = next(arrays)
+    except StopIteration:
+        return np.array([], dtype=np.uint64)
+    arrays = itertools.chain([first], arrays)
+    mult = np.uint64(1000003)
+    out = np.zeros_like(first) + np.uint64(3430008)
+    last_i = 0
+    for (i, a) in enumerate(arrays):
+        inverse_i = num_items - i
+        out ^= a
+        out *= mult
+        mult += np.uint64(82520 + inverse_i + inverse_i)
+        last_i = i
+    assert last_i + 1 == num_items, 'Fed in wrong num_items'
+    out += np.uint64(97531)
+    return out
+
+def hash_pandas_object(obj: Index | DataFrame | Series, index: bool=True, encoding: str='utf8', hash_key: str | None=_default_hash_key, categorize: bool=True) -> Series:
+    from pandas import Series
+    if hash_key is None:
+        hash_key = _default_hash_key
+    if isinstance(obj, ABCMultiIndex):
+        return Series(hash_tuples(obj, encoding, hash_key), dtype='uint64', copy=False)
+    elif isinstance(obj, ABCIndex):
+        h = hash_array(obj._values, encoding, hash_key, categorize).astype('uint64', copy=False)
+        ser = Series(h, index=obj, dtype='uint64', copy=False)
+    elif isinstance(obj, ABCSeries):
+        h = hash_array(obj._values, encoding, hash_key, categorize).astype('uint64', copy=False)
+        if index:
+            index_iter = (hash_pandas_object(obj.index, index=False, encoding=encoding, hash_key=hash_key, categorize=categorize)._values for _ in [None])
+            arrays = itertools.chain([h], index_iter)
+            h = combine_hash_arrays(arrays, 2)
+        ser = Series(h, index=obj.index, dtype='uint64', copy=False)
+    elif isinstance(obj, ABCDataFrame):
+        hashes = (hash_array(series._values, encoding, hash_key, categorize) for (_, series) in obj.items())
+        num_items = len(obj.columns)
+        if index:
+            index_hash_generator = (hash_pandas_object(obj.index, index=False, encoding=encoding, hash_key=hash_key, categorize=categorize)._values for _ in [None])
+            num_items += 1
+            _hashes = itertools.chain(hashes, index_hash_generator)
+            hashes = (x for x in _hashes)
+        h = combine_hash_arrays(hashes, num_items)
+        ser = Series(h, index=obj.index, dtype='uint64', copy=False)
+    else:
+        raise TypeError(f'Unexpected type for hashing {type(obj)}')
+    return ser
+
+def hash_tuples(vals: MultiIndex | Iterable[tuple[Hashable, ...]], encoding: str='utf8', hash_key: str=_default_hash_key) -> npt.NDArray[np.uint64]:
+    if not is_list_like(vals):
+        raise TypeError('must be convertible to a list-of-tuples')
+    from pandas import Categorical, MultiIndex
+    if not isinstance(vals, ABCMultiIndex):
+        mi = MultiIndex.from_tuples(vals)
+    else:
+        mi = vals
+    cat_vals = [Categorical._simple_new(mi.codes[level], CategoricalDtype(categories=mi.levels[level], ordered=False)) for level in range(mi.nlevels)]
+    hashes = (cat._hash_pandas_object(encoding=encoding, hash_key=hash_key, categorize=False) for cat in cat_vals)
+    h = combine_hash_arrays(hashes, len(cat_vals))
+    return h
+
+def hash_array(vals: ArrayLike, encoding: str='utf8', hash_key: str=_default_hash_key, categorize: bool=True) -> npt.NDArray[np.uint64]:
+    if not hasattr(vals, 'dtype'):
+        raise TypeError('must pass a ndarray-like')
+    if isinstance(vals, ABCExtensionArray):
+        return vals._hash_pandas_object(encoding=encoding, hash_key=hash_key, categorize=categorize)
+    if not isinstance(vals, np.ndarray):
+        raise TypeError(f'hash_array requires np.ndarray or ExtensionArray, not {type(vals).__name__}. Use hash_pandas_object instead.')
+    return _hash_ndarray(vals, encoding, hash_key, categorize)
+
+def _hash_ndarray(vals: np.ndarray, encoding: str='utf8', hash_key: str=_default_hash_key, categorize: bool=True) -> npt.NDArray[np.uint64]:
+    dtype = vals.dtype
+    if np.issubdtype(dtype, np.complex128):
+        hash_real = _hash_ndarray(vals.real, encoding, hash_key, categorize)
+        hash_imag = _hash_ndarray(vals.imag, encoding, hash_key, categorize)
+        return hash_real + 23 * hash_imag
+    if dtype == bool:
+        vals = vals.astype('u8')
+    elif issubclass(dtype.type, (np.datetime64, np.timedelta64)):
+        vals = vals.view('i8').astype('u8', copy=False)
+    elif issubclass(dtype.type, np.number) and dtype.itemsize <= 8:
+        vals = vals.view(f'u{vals.dtype.itemsize}').astype('u8')
+    else:
+        if categorize:
+            from pandas import Categorical, Index, factorize
+            (codes, categories) = factorize(vals, sort=False)
+            dtype = CategoricalDtype(categories=Index(categories), ordered=False)
+            cat = Categorical._simple_new(codes, dtype)
+            return cat._hash_pandas_object(encoding=encoding, hash_key=hash_key, categorize=False)
+        try:
+            vals = hash_object_array(vals, hash_key, encoding)
+        except TypeError:
+            vals = hash_object_array(vals.astype(str).astype(object), hash_key, encoding)
+    vals ^= vals >> 30
+    vals *= np.uint64(13787848793156543929)
+    vals ^= vals >> 27
+    vals *= np.uint64(10723151780598845931)
+    vals ^= vals >> 31
+    return vals
+
+# File: pandas-main/pandas/core/util/numba_.py
+""""""
+from __future__ import annotations
+import inspect
+import types
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas.compat._optional import import_optional_dependency
+from pandas.errors import NumbaUtilError
+if TYPE_CHECKING:
+    from collections.abc import Callable
+GLOBAL_USE_NUMBA: bool = False
+
+def maybe_use_numba(engine: str | None) -> bool:
+    return engine == 'numba' or (engine is None and GLOBAL_USE_NUMBA)
+
+def set_use_numba(enable: bool=False) -> None:
+    global GLOBAL_USE_NUMBA
+    if enable:
+        import_optional_dependency('numba')
+    GLOBAL_USE_NUMBA = enable
+
+def get_jit_arguments(engine_kwargs: dict[str, bool] | None=None, kwargs: dict | None=None) -> dict[str, bool]:
+    if engine_kwargs is None:
+        engine_kwargs = {}
+    nopython = engine_kwargs.get('nopython', True)
+    if kwargs:
+        raise NumbaUtilError('numba does not support keyword-only argumentshttps://github.com/numba/numba/issues/2916, https://github.com/numba/numba/issues/6846')
+    nogil = engine_kwargs.get('nogil', False)
+    parallel = engine_kwargs.get('parallel', False)
+    return {'nopython': nopython, 'nogil': nogil, 'parallel': parallel}
+
+def jit_user_function(func: Callable) -> Callable:
+    if TYPE_CHECKING:
+        import numba
+    else:
+        numba = import_optional_dependency('numba')
+    if numba.extending.is_jitted(func):
+        numba_func = func
+    elif getattr(np, func.__name__, False) is func or isinstance(func, types.BuiltinFunctionType):
+        numba_func = func
+    else:
+        numba_func = numba.extending.register_jitable(func)
+    return numba_func
+_sentinel = object()
+
+def prepare_function_arguments(func: Callable, args: tuple, kwargs: dict) -> tuple[tuple, dict]:
+    if not kwargs:
+        return (args, kwargs)
+    signature = inspect.signature(func)
+    arguments = signature.bind(_sentinel, *args, **kwargs)
+    arguments.apply_defaults()
+    args = arguments.args
+    kwargs = arguments.kwargs
+    assert args[0] is _sentinel
+    args = args[1:]
+    return (args, kwargs)
+
+# File: pandas-main/pandas/core/window/__init__.py
+from pandas.core.window.ewm import ExponentialMovingWindow, ExponentialMovingWindowGroupby
+from pandas.core.window.expanding import Expanding, ExpandingGroupby
+from pandas.core.window.rolling import Rolling, RollingGroupby, Window
+__all__ = ['Expanding', 'ExpandingGroupby', 'ExponentialMovingWindow', 'ExponentialMovingWindowGroupby', 'Rolling', 'RollingGroupby', 'Window']
+
+# File: pandas-main/pandas/core/window/common.py
+""""""
+from __future__ import annotations
+from collections import defaultdict
+from typing import cast
+import numpy as np
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.indexes.api import MultiIndex
+
+def flex_binary_moment(arg1, arg2, f, pairwise: bool=False):
+    if isinstance(arg1, ABCSeries) and isinstance(arg2, ABCSeries):
+        (X, Y) = prep_binary(arg1, arg2)
+        return f(X, Y)
+    elif isinstance(arg1, ABCDataFrame):
+        from pandas import DataFrame
+
+        def dataframe_from_int_dict(data, frame_template) -> DataFrame:
+            result = DataFrame(data, index=frame_template.index)
+            if len(result.columns) > 0:
+                result.columns = frame_template.columns[result.columns]
+            else:
+                result.columns = frame_template.columns.copy()
+            return result
+        results = {}
+        if isinstance(arg2, ABCDataFrame):
+            if pairwise is False:
+                if arg1 is arg2:
+                    for i in range(len(arg1.columns)):
+                        results[i] = f(arg1.iloc[:, i], arg2.iloc[:, i])
+                    return dataframe_from_int_dict(results, arg1)
+                else:
+                    if not arg1.columns.is_unique:
+                        raise ValueError("'arg1' columns are not unique")
+                    if not arg2.columns.is_unique:
+                        raise ValueError("'arg2' columns are not unique")
+                    (X, Y) = arg1.align(arg2, join='outer')
+                    (X, Y) = prep_binary(X, Y)
+                    res_columns = arg1.columns.union(arg2.columns)
+                    for col in res_columns:
+                        if col in X and col in Y:
+                            results[col] = f(X[col], Y[col])
+                    return DataFrame(results, index=X.index, columns=res_columns)
+            elif pairwise is True:
+                results = defaultdict(dict)
+                for i in range(len(arg1.columns)):
+                    for j in range(len(arg2.columns)):
+                        if j < i and arg2 is arg1:
+                            results[i][j] = results[j][i]
+                        else:
+                            results[i][j] = f(*prep_binary(arg1.iloc[:, i], arg2.iloc[:, j]))
+                from pandas import concat
+                result_index = arg1.index.union(arg2.index)
+                if len(result_index):
+                    result = concat([concat([results[i][j] for j in range(len(arg2.columns))], ignore_index=True) for i in range(len(arg1.columns))], ignore_index=True, axis=1)
+                    result.columns = arg1.columns
+                    if arg2.columns.nlevels > 1:
+                        arg2.columns = cast(MultiIndex, arg2.columns)
+                        result_level = np.tile(result_index, len(result) // len(result_index))
+                        arg2_levels = (np.repeat(arg2.columns.get_level_values(i), len(result) // len(arg2.columns)) for i in range(arg2.columns.nlevels))
+                        result_names = list(arg2.columns.names) + [result_index.name]
+                        result.index = MultiIndex.from_arrays([*arg2_levels, result_level], names=result_names)
+                        num_levels = len(result.index.levels)
+                        new_order = [num_levels - 1] + list(range(num_levels - 1))
+                        result = result.reorder_levels(new_order).sort_index()
+                    else:
+                        result.index = MultiIndex.from_product([range(len(arg2.columns)), range(len(result_index))])
+                        result = result.swaplevel(1, 0).sort_index()
+                        result.index = MultiIndex.from_product([result_index] + [arg2.columns])
+                else:
+                    result = DataFrame(index=MultiIndex(levels=[arg1.index, arg2.columns], codes=[[], []]), columns=arg2.columns, dtype='float64')
+                result.columns = result.columns.set_names(arg1.columns.names)
+                result.index = result.index.set_names(result_index.names + arg2.columns.names)
+                return result
+        else:
+            results = {i: f(*prep_binary(arg1.iloc[:, i], arg2)) for i in range(len(arg1.columns))}
+            return dataframe_from_int_dict(results, arg1)
+    else:
+        return flex_binary_moment(arg2, arg1, f)
+
+def zsqrt(x):
+    with np.errstate(all='ignore'):
+        result = np.sqrt(x)
+        mask = x < 0
+    if isinstance(x, ABCDataFrame):
+        if mask._values.any():
+            result[mask] = 0
+    elif mask.any():
+        result[mask] = 0
+    return result
+
+def prep_binary(arg1, arg2):
+    X = arg1 + 0 * arg2
+    Y = arg2 + 0 * arg1
+    return (X, Y)
+
+# File: pandas-main/pandas/core/window/doc.py
+""""""
+from __future__ import annotations
+from textwrap import dedent
+from pandas.core.shared_docs import _shared_docs
+_shared_docs = dict(**_shared_docs)
+
+def create_section_header(header: str) -> str:
+    return f"{header}\n{'-' * len(header)}\n"
+template_header = '\nCalculate the {window_method} {aggregation_description}.\n\n'
+template_returns = dedent('\n    Series or DataFrame\n        Return type is the same as the original object with ``np.float64`` dtype.\n\n    ').replace('\n', '', 1)
+template_see_also = dedent('\n    Series.{window_method} : Calling {window_method} with Series data.\n    DataFrame.{window_method} : Calling {window_method} with DataFrames.\n    Series.{agg_method} : Aggregating {agg_method} for Series.\n    DataFrame.{agg_method} : Aggregating {agg_method} for DataFrame.\n\n    ').replace('\n', '', 1)
+kwargs_numeric_only = dedent('\n    numeric_only : bool, default False\n        Include only float, int, boolean columns.\n\n        .. versionadded:: 1.5.0\n\n    ').replace('\n', '', 1)
+kwargs_scipy = dedent('\n    **kwargs\n        Keyword arguments to configure the ``SciPy`` weighted window type.\n\n    ').replace('\n', '', 1)
+window_apply_parameters = dedent("\n    func : function\n        Must produce a single value from an ndarray input if ``raw=True``\n        or a single value from a Series if ``raw=False``. Can also accept a\n        Numba JIT function with ``engine='numba'`` specified.\n\n    raw : bool, default False\n        * ``False`` : passes each row or column as a Series to the\n          function.\n        * ``True`` : the passed function will receive ndarray\n          objects instead.\n          If you are just applying a NumPy reduction function this will\n          achieve much better performance.\n\n    engine : str, default None\n        * ``'cython'`` : Runs rolling apply through C-extensions from cython.\n        * ``'numba'`` : Runs rolling apply through JIT compiled code from numba.\n          Only available when ``raw`` is set to ``True``.\n        * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``\n\n    engine_kwargs : dict, default None\n        * For ``'cython'`` engine, there are no accepted ``engine_kwargs``\n        * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``\n          and ``parallel`` dictionary keys. The values must either be ``True`` or\n          ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is\n          ``{{'nopython': True, 'nogil': False, 'parallel': False}}`` and will be\n          applied to both the ``func`` and the ``apply`` rolling aggregation.\n\n    args : tuple, default None\n        Positional arguments to be passed into func.\n\n    kwargs : dict, default None\n        Keyword arguments to be passed into func.\n\n    ").replace('\n', '', 1)
+numba_notes = 'See :ref:`window.numba_engine` and :ref:`enhancingperf.numba` for extended documentation and performance considerations for the Numba engine.\n\n'
+
+def window_agg_numba_parameters(version: str='1.3') -> str:
+    return dedent("\n    engine : str, default None\n        * ``'cython'`` : Runs the operation through C-extensions from cython.\n        * ``'numba'`` : Runs the operation through JIT compiled code from numba.\n        * ``None`` : Defaults to ``'cython'`` or globally setting ``compute.use_numba``\n\n          .. versionadded:: {version}.0\n\n    engine_kwargs : dict, default None\n        * For ``'cython'`` engine, there are no accepted ``engine_kwargs``\n        * For ``'numba'`` engine, the engine can accept ``nopython``, ``nogil``\n          and ``parallel`` dictionary keys. The values must either be ``True`` or\n          ``False``. The default ``engine_kwargs`` for the ``'numba'`` engine is\n          ``{{'nopython': True, 'nogil': False, 'parallel': False}}``\n\n          .. versionadded:: {version}.0\n\n    ").replace('\n', '', 1).replace('{version}', version)
+
+# File: pandas-main/pandas/core/window/ewm.py
+from __future__ import annotations
+import datetime
+from functools import partial
+from textwrap import dedent
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs.tslibs import Timedelta
+import pandas._libs.window.aggregations as window_aggregations
+from pandas.util._decorators import doc
+from pandas.core.dtypes.common import is_datetime64_dtype, is_numeric_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+from pandas.core.dtypes.generic import ABCSeries
+from pandas.core.dtypes.missing import isna
+from pandas.core import common
+from pandas.core.arrays.datetimelike import dtype_to_unit
+from pandas.core.indexers.objects import BaseIndexer, ExponentialMovingWindowIndexer, GroupbyIndexer
+from pandas.core.util.numba_ import get_jit_arguments, maybe_use_numba
+from pandas.core.window.common import zsqrt
+from pandas.core.window.doc import _shared_docs, create_section_header, kwargs_numeric_only, numba_notes, template_header, template_returns, template_see_also, window_agg_numba_parameters
+from pandas.core.window.numba_ import generate_numba_ewm_func, generate_numba_ewm_table_func
+from pandas.core.window.online import EWMMeanState, generate_online_numba_ewma_func
+from pandas.core.window.rolling import BaseWindow, BaseWindowGroupby
+if TYPE_CHECKING:
+    from pandas._typing import TimedeltaConvertibleTypes, npt
+    from pandas import DataFrame, Series
+    from pandas.core.generic import NDFrame
+
+def get_center_of_mass(comass: float | None, span: float | None, halflife: float | None, alpha: float | None) -> float:
+    valid_count = common.count_not_none(comass, span, halflife, alpha)
+    if valid_count > 1:
+        raise ValueError('comass, span, halflife, and alpha are mutually exclusive')
+    if comass is not None:
+        if comass < 0:
+            raise ValueError('comass must satisfy: comass >= 0')
+    elif span is not None:
+        if span < 1:
+            raise ValueError('span must satisfy: span >= 1')
+        comass = (span - 1) / 2
+    elif halflife is not None:
+        if halflife <= 0:
+            raise ValueError('halflife must satisfy: halflife > 0')
+        decay = 1 - np.exp(np.log(0.5) / halflife)
+        comass = 1 / decay - 1
+    elif alpha is not None:
+        if alpha <= 0 or alpha > 1:
+            raise ValueError('alpha must satisfy: 0 < alpha <= 1')
+        comass = (1 - alpha) / alpha
+    else:
+        raise ValueError('Must pass one of comass, span, halflife, or alpha')
+    return float(comass)
+
+def _calculate_deltas(times: np.ndarray | NDFrame, halflife: float | TimedeltaConvertibleTypes | None) -> npt.NDArray[np.float64]:
+    unit = dtype_to_unit(times.dtype)
+    if isinstance(times, ABCSeries):
+        times = times._values
+    _times = np.asarray(times.view(np.int64), dtype=np.float64)
+    _halflife = float(Timedelta(halflife).as_unit(unit)._value)
+    return np.diff(_times) / _halflife
+
+class ExponentialMovingWindow(BaseWindow):
+    _attributes = ['com', 'span', 'halflife', 'alpha', 'min_periods', 'adjust', 'ignore_na', 'times', 'method']
+
+    def __init__(self, obj: NDFrame, com: float | None=None, span: float | None=None, halflife: float | TimedeltaConvertibleTypes | None=None, alpha: float | None=None, min_periods: int | None=0, adjust: bool=True, ignore_na: bool=False, times: np.ndarray | NDFrame | None=None, method: str='single', *, selection=None) -> None:
+        super().__init__(obj=obj, min_periods=1 if min_periods is None else max(int(min_periods), 1), on=None, center=False, closed=None, method=method, selection=selection)
+        self.com = com
+        self.span = span
+        self.halflife = halflife
+        self.alpha = alpha
+        self.adjust = adjust
+        self.ignore_na = ignore_na
+        self.times = times
+        if self.times is not None:
+            times_dtype = getattr(self.times, 'dtype', None)
+            if not (is_datetime64_dtype(times_dtype) or isinstance(times_dtype, DatetimeTZDtype)):
+                raise ValueError('times must be datetime64 dtype.')
+            if len(self.times) != len(obj):
+                raise ValueError('times must be the same length as the object.')
+            if not isinstance(self.halflife, (str, datetime.timedelta, np.timedelta64)):
+                raise ValueError('halflife must be a timedelta convertible object')
+            if isna(self.times).any():
+                raise ValueError('Cannot convert NaT values to integer')
+            self._deltas = _calculate_deltas(self.times, self.halflife)
+            if common.count_not_none(self.com, self.span, self.alpha) > 0:
+                if not self.adjust:
+                    raise NotImplementedError('None of com, span, or alpha can be specified if times is provided and adjust=False')
+                self._com = get_center_of_mass(self.com, self.span, None, self.alpha)
+            else:
+                self._com = 1.0
+        else:
+            if self.halflife is not None and isinstance(self.halflife, (str, datetime.timedelta, np.timedelta64)):
+                raise ValueError('halflife can only be a timedelta convertible argument if times is not None.')
+            self._deltas = np.ones(max(self.obj.shape[0] - 1, 0), dtype=np.float64)
+            self._com = get_center_of_mass(self.com, self.span, self.halflife, self.alpha)
+
+    def _check_window_bounds(self, start: np.ndarray, end: np.ndarray, num_vals: int) -> None:
+        pass
+
+    def _get_window_indexer(self) -> BaseIndexer:
+        return ExponentialMovingWindowIndexer()
+
+    def online(self, engine: str='numba', engine_kwargs=None) -> OnlineExponentialMovingWindow:
+        return OnlineExponentialMovingWindow(obj=self.obj, com=self.com, span=self.span, halflife=self.halflife, alpha=self.alpha, min_periods=self.min_periods, adjust=self.adjust, ignore_na=self.ignore_na, times=self.times, engine=engine, engine_kwargs=engine_kwargs, selection=self._selection)
+
+    @doc(_shared_docs['aggregate'], see_also=dedent('\n        See Also\n        --------\n        pandas.DataFrame.rolling.aggregate\n        '), examples=dedent('\n        Examples\n        --------\n        >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})\n        >>> df\n           A  B  C\n        0  1  4  7\n        1  2  5  8\n        2  3  6  9\n\n        >>> df.ewm(alpha=0.5).mean()\n                  A         B         C\n        0  1.000000  4.000000  7.000000\n        1  1.666667  4.666667  7.666667\n        2  2.428571  5.428571  8.428571\n        '), klass='Series/Dataframe', axis='')
+    def aggregate(self, func, *args, **kwargs):
+        return super().aggregate(func, *args, **kwargs)
+    agg = aggregate
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, window_agg_numba_parameters(), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent('        >>> ser = pd.Series([1, 2, 3, 4])\n        >>> ser.ewm(alpha=.2).mean()\n        0    1.000000\n        1    1.555556\n        2    2.147541\n        3    2.775068\n        dtype: float64\n        '), window_method='ewm', aggregation_description='(exponential weighted moment) mean', agg_method='mean')
+    def mean(self, numeric_only: bool=False, engine=None, engine_kwargs=None):
+        if maybe_use_numba(engine):
+            if self.method == 'single':
+                func = generate_numba_ewm_func
+            else:
+                func = generate_numba_ewm_table_func
+            ewm_func = func(**get_jit_arguments(engine_kwargs), com=self._com, adjust=self.adjust, ignore_na=self.ignore_na, deltas=tuple(self._deltas), normalize=True)
+            return self._apply(ewm_func, name='mean')
+        elif engine in ('cython', None):
+            if engine_kwargs is not None:
+                raise ValueError('cython engine does not accept engine_kwargs')
+            deltas = None if self.times is None else self._deltas
+            window_func = partial(window_aggregations.ewm, com=self._com, adjust=self.adjust, ignore_na=self.ignore_na, deltas=deltas, normalize=True)
+            return self._apply(window_func, name='mean', numeric_only=numeric_only)
+        else:
+            raise ValueError("engine must be either 'numba' or 'cython'")
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, window_agg_numba_parameters(), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent('        >>> ser = pd.Series([1, 2, 3, 4])\n        >>> ser.ewm(alpha=.2).sum()\n        0    1.000\n        1    2.800\n        2    5.240\n        3    8.192\n        dtype: float64\n        '), window_method='ewm', aggregation_description='(exponential weighted moment) sum', agg_method='sum')
+    def sum(self, numeric_only: bool=False, engine=None, engine_kwargs=None):
+        if not self.adjust:
+            raise NotImplementedError('sum is not implemented with adjust=False')
+        if self.times is not None:
+            raise NotImplementedError('sum is not implemented with times')
+        if maybe_use_numba(engine):
+            if self.method == 'single':
+                func = generate_numba_ewm_func
+            else:
+                func = generate_numba_ewm_table_func
+            ewm_func = func(**get_jit_arguments(engine_kwargs), com=self._com, adjust=self.adjust, ignore_na=self.ignore_na, deltas=tuple(self._deltas), normalize=False)
+            return self._apply(ewm_func, name='sum')
+        elif engine in ('cython', None):
+            if engine_kwargs is not None:
+                raise ValueError('cython engine does not accept engine_kwargs')
+            deltas = None if self.times is None else self._deltas
+            window_func = partial(window_aggregations.ewm, com=self._com, adjust=self.adjust, ignore_na=self.ignore_na, deltas=deltas, normalize=False)
+            return self._apply(window_func, name='sum', numeric_only=numeric_only)
+        else:
+            raise ValueError("engine must be either 'numba' or 'cython'")
+
+    @doc(template_header, create_section_header('Parameters'), dedent('        bias : bool, default False\n            Use a standard estimation bias correction.\n        '), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent('        >>> ser = pd.Series([1, 2, 3, 4])\n        >>> ser.ewm(alpha=.2).std()\n        0         NaN\n        1    0.707107\n        2    0.995893\n        3    1.277320\n        dtype: float64\n        '), window_method='ewm', aggregation_description='(exponential weighted moment) standard deviation', agg_method='std')
+    def std(self, bias: bool=False, numeric_only: bool=False):
+        if numeric_only and self._selected_obj.ndim == 1 and (not is_numeric_dtype(self._selected_obj.dtype)):
+            raise NotImplementedError(f'{type(self).__name__}.std does not implement numeric_only')
+        if self.times is not None:
+            raise NotImplementedError('std is not implemented with times')
+        return zsqrt(self.var(bias=bias, numeric_only=numeric_only))
+
+    @doc(template_header, create_section_header('Parameters'), dedent('        bias : bool, default False\n            Use a standard estimation bias correction.\n        '), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent('        >>> ser = pd.Series([1, 2, 3, 4])\n        >>> ser.ewm(alpha=.2).var()\n        0         NaN\n        1    0.500000\n        2    0.991803\n        3    1.631547\n        dtype: float64\n        '), window_method='ewm', aggregation_description='(exponential weighted moment) variance', agg_method='var')
+    def var(self, bias: bool=False, numeric_only: bool=False):
+        if self.times is not None:
+            raise NotImplementedError('var is not implemented with times')
+        window_func = window_aggregations.ewmcov
+        wfunc = partial(window_func, com=self._com, adjust=self.adjust, ignore_na=self.ignore_na, bias=bias)
+
+        def var_func(values, begin, end, min_periods):
+            return wfunc(values, begin, end, min_periods, values)
+        return self._apply(var_func, name='var', numeric_only=numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('        other : Series or DataFrame , optional\n            If not supplied then will default to self and produce pairwise\n            output.\n        pairwise : bool, default None\n            If False then only matching columns between self and other will be\n            used and the output will be a DataFrame.\n            If True then all pairwise combinations will be calculated and the\n            output will be a MultiIndex DataFrame in the case of DataFrame\n            inputs. In the case of missing elements, only complete pairwise\n            observations will be used.\n        bias : bool, default False\n            Use a standard estimation bias correction.\n        '), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent('        >>> ser1 = pd.Series([1, 2, 3, 4])\n        >>> ser2 = pd.Series([10, 11, 13, 16])\n        >>> ser1.ewm(alpha=.2).cov(ser2)\n        0         NaN\n        1    0.500000\n        2    1.524590\n        3    3.408836\n        dtype: float64\n        '), window_method='ewm', aggregation_description='(exponential weighted moment) sample covariance', agg_method='cov')
+    def cov(self, other: DataFrame | Series | None=None, pairwise: bool | None=None, bias: bool=False, numeric_only: bool=False):
+        if self.times is not None:
+            raise NotImplementedError('cov is not implemented with times')
+        from pandas import Series
+        self._validate_numeric_only('cov', numeric_only)
+
+        def cov_func(x, y):
+            x_array = self._prep_values(x)
+            y_array = self._prep_values(y)
+            window_indexer = self._get_window_indexer()
+            min_periods = self.min_periods if self.min_periods is not None else window_indexer.window_size
+            (start, end) = window_indexer.get_window_bounds(num_values=len(x_array), min_periods=min_periods, center=self.center, closed=self.closed, step=self.step)
+            result = window_aggregations.ewmcov(x_array, start, end, self.min_periods, y_array, self._com, self.adjust, self.ignore_na, bias)
+            return Series(result, index=x.index, name=x.name, copy=False)
+        return self._apply_pairwise(self._selected_obj, other, pairwise, cov_func, numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('        other : Series or DataFrame, optional\n            If not supplied then will default to self and produce pairwise\n            output.\n        pairwise : bool, default None\n            If False then only matching columns between self and other will be\n            used and the output will be a DataFrame.\n            If True then all pairwise combinations will be calculated and the\n            output will be a MultiIndex DataFrame in the case of DataFrame\n            inputs. In the case of missing elements, only complete pairwise\n            observations will be used.\n        '), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent('        >>> ser1 = pd.Series([1, 2, 3, 4])\n        >>> ser2 = pd.Series([10, 11, 13, 16])\n        >>> ser1.ewm(alpha=.2).corr(ser2)\n        0         NaN\n        1    1.000000\n        2    0.982821\n        3    0.977802\n        dtype: float64\n        '), window_method='ewm', aggregation_description='(exponential weighted moment) sample correlation', agg_method='corr')
+    def corr(self, other: DataFrame | Series | None=None, pairwise: bool | None=None, numeric_only: bool=False):
+        if self.times is not None:
+            raise NotImplementedError('corr is not implemented with times')
+        from pandas import Series
+        self._validate_numeric_only('corr', numeric_only)
+
+        def cov_func(x, y):
+            x_array = self._prep_values(x)
+            y_array = self._prep_values(y)
+            window_indexer = self._get_window_indexer()
+            min_periods = self.min_periods if self.min_periods is not None else window_indexer.window_size
+            (start, end) = window_indexer.get_window_bounds(num_values=len(x_array), min_periods=min_periods, center=self.center, closed=self.closed, step=self.step)
+
+            def _cov(X, Y):
+                return window_aggregations.ewmcov(X, start, end, min_periods, Y, self._com, self.adjust, self.ignore_na, True)
+            with np.errstate(all='ignore'):
+                cov = _cov(x_array, y_array)
+                x_var = _cov(x_array, x_array)
+                y_var = _cov(y_array, y_array)
+                result = cov / zsqrt(x_var * y_var)
+            return Series(result, index=x.index, name=x.name, copy=False)
+        return self._apply_pairwise(self._selected_obj, other, pairwise, cov_func, numeric_only)
+
+class ExponentialMovingWindowGroupby(BaseWindowGroupby, ExponentialMovingWindow):
+    _attributes = ExponentialMovingWindow._attributes + BaseWindowGroupby._attributes
+
+    def __init__(self, obj, *args, _grouper=None, **kwargs) -> None:
+        super().__init__(obj, *args, _grouper=_grouper, **kwargs)
+        if not obj.empty and self.times is not None:
+            groupby_order = np.concatenate(list(self._grouper.indices.values()))
+            self._deltas = _calculate_deltas(self.times.take(groupby_order), self.halflife)
+
+    def _get_window_indexer(self) -> GroupbyIndexer:
+        window_indexer = GroupbyIndexer(groupby_indices=self._grouper.indices, window_indexer=ExponentialMovingWindowIndexer)
+        return window_indexer
+
+class OnlineExponentialMovingWindow(ExponentialMovingWindow):
+
+    def __init__(self, obj: NDFrame, com: float | None=None, span: float | None=None, halflife: float | TimedeltaConvertibleTypes | None=None, alpha: float | None=None, min_periods: int | None=0, adjust: bool=True, ignore_na: bool=False, times: np.ndarray | NDFrame | None=None, engine: str='numba', engine_kwargs: dict[str, bool] | None=None, *, selection=None) -> None:
+        if times is not None:
+            raise NotImplementedError('times is not implemented with online operations.')
+        super().__init__(obj=obj, com=com, span=span, halflife=halflife, alpha=alpha, min_periods=min_periods, adjust=adjust, ignore_na=ignore_na, times=times, selection=selection)
+        self._mean = EWMMeanState(self._com, self.adjust, self.ignore_na, obj.shape)
+        if maybe_use_numba(engine):
+            self.engine = engine
+            self.engine_kwargs = engine_kwargs
+        else:
+            raise ValueError("'numba' is the only supported engine")
+
+    def reset(self) -> None:
+        self._mean.reset()
+
+    def aggregate(self, func, *args, **kwargs):
+        raise NotImplementedError('aggregate is not implemented.')
+
+    def std(self, bias: bool=False, *args, **kwargs):
+        raise NotImplementedError('std is not implemented.')
+
+    def corr(self, other: DataFrame | Series | None=None, pairwise: bool | None=None, numeric_only: bool=False):
+        raise NotImplementedError('corr is not implemented.')
+
+    def cov(self, other: DataFrame | Series | None=None, pairwise: bool | None=None, bias: bool=False, numeric_only: bool=False):
+        raise NotImplementedError('cov is not implemented.')
+
+    def var(self, bias: bool=False, numeric_only: bool=False):
+        raise NotImplementedError('var is not implemented.')
+
+    def mean(self, *args, update=None, update_times=None, **kwargs):
+        result_kwargs = {}
+        is_frame = self._selected_obj.ndim == 2
+        if update_times is not None:
+            raise NotImplementedError('update_times is not implemented.')
+        update_deltas = np.ones(max(self._selected_obj.shape[-1] - 1, 0), dtype=np.float64)
+        if update is not None:
+            if self._mean.last_ewm is None:
+                raise ValueError('Must call mean with update=None first before passing update')
+            result_from = 1
+            result_kwargs['index'] = update.index
+            if is_frame:
+                last_value = self._mean.last_ewm[np.newaxis, :]
+                result_kwargs['columns'] = update.columns
+            else:
+                last_value = self._mean.last_ewm
+                result_kwargs['name'] = update.name
+            np_array = np.concatenate((last_value, update.to_numpy()))
+        else:
+            result_from = 0
+            result_kwargs['index'] = self._selected_obj.index
+            if is_frame:
+                result_kwargs['columns'] = self._selected_obj.columns
+            else:
+                result_kwargs['name'] = self._selected_obj.name
+            np_array = self._selected_obj.astype(np.float64).to_numpy()
+        ewma_func = generate_online_numba_ewma_func(**get_jit_arguments(self.engine_kwargs))
+        result = self._mean.run_ewm(np_array if is_frame else np_array[:, np.newaxis], update_deltas, self.min_periods, ewma_func)
+        if not is_frame:
+            result = result.squeeze()
+        result = result[result_from:]
+        result = self._selected_obj._constructor(result, **result_kwargs)
+        return result
+
+# File: pandas-main/pandas/core/window/expanding.py
+from __future__ import annotations
+from textwrap import dedent
+from typing import TYPE_CHECKING, Any, Literal
+from pandas.util._decorators import doc
+from pandas.core.indexers.objects import BaseIndexer, ExpandingIndexer, GroupbyIndexer
+from pandas.core.window.doc import _shared_docs, create_section_header, kwargs_numeric_only, numba_notes, template_header, template_returns, template_see_also, window_agg_numba_parameters, window_apply_parameters
+from pandas.core.window.rolling import BaseWindowGroupby, RollingAndExpandingMixin
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import QuantileInterpolation, WindowingRankType
+    from pandas import DataFrame, Series
+    from pandas.core.generic import NDFrame
+
+class Expanding(RollingAndExpandingMixin):
+    _attributes: list[str] = ['min_periods', 'method']
+
+    def __init__(self, obj: NDFrame, min_periods: int=1, method: str='single', selection=None) -> None:
+        super().__init__(obj=obj, min_periods=min_periods, method=method, selection=selection)
+
+    def _get_window_indexer(self) -> BaseIndexer:
+        return ExpandingIndexer()
+
+    @doc(_shared_docs['aggregate'], see_also=dedent('\n        See Also\n        --------\n        DataFrame.aggregate : Similar DataFrame method.\n        Series.aggregate : Similar Series method.\n        '), examples=dedent('\n        Examples\n        --------\n        >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})\n        >>> df\n           A  B  C\n        0  1  4  7\n        1  2  5  8\n        2  3  6  9\n\n        >>> df.ewm(alpha=0.5).mean()\n                  A         B         C\n        0  1.000000  4.000000  7.000000\n        1  1.666667  4.666667  7.666667\n        2  2.428571  5.428571  8.428571\n        '), klass='Series/Dataframe', axis='')
+    def aggregate(self, func, *args, **kwargs):
+        return super().aggregate(func, *args, **kwargs)
+    agg = aggregate
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent("        >>> ser = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])\n        >>> ser.expanding().count()\n        a    1.0\n        b    2.0\n        c    3.0\n        d    4.0\n        dtype: float64\n        "), window_method='expanding', aggregation_description='count of non NaN observations', agg_method='count')
+    def count(self, numeric_only: bool=False):
+        return super().count(numeric_only=numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), window_apply_parameters, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent("        >>> ser = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])\n        >>> ser.expanding().apply(lambda s: s.max() - 2 * s.min())\n        a   -1.0\n        b    0.0\n        c    1.0\n        d    2.0\n        dtype: float64\n        "), window_method='expanding', aggregation_description='custom aggregation function', agg_method='apply')
+    def apply(self, func: Callable[..., Any], raw: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None, args: tuple[Any, ...] | None=None, kwargs: dict[str, Any] | None=None):
+        return super().apply(func, raw=raw, engine=engine, engine_kwargs=engine_kwargs, args=args, kwargs=kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, window_agg_numba_parameters(), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent("        >>> ser = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])\n        >>> ser.expanding().sum()\n        a     1.0\n        b     3.0\n        c     6.0\n        d    10.0\n        dtype: float64\n        "), window_method='expanding', aggregation_description='sum', agg_method='sum')
+    def sum(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().sum(numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, window_agg_numba_parameters(), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent("        >>> ser = pd.Series([3, 2, 1, 4], index=['a', 'b', 'c', 'd'])\n        >>> ser.expanding().max()\n        a    3.0\n        b    3.0\n        c    3.0\n        d    4.0\n        dtype: float64\n        "), window_method='expanding', aggregation_description='maximum', agg_method='max')
+    def max(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().max(numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, window_agg_numba_parameters(), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent("        >>> ser = pd.Series([2, 3, 4, 1], index=['a', 'b', 'c', 'd'])\n        >>> ser.expanding().min()\n        a    2.0\n        b    2.0\n        c    2.0\n        d    1.0\n        dtype: float64\n        "), window_method='expanding', aggregation_description='minimum', agg_method='min')
+    def min(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().min(numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, window_agg_numba_parameters(), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent("        >>> ser = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])\n        >>> ser.expanding().mean()\n        a    1.0\n        b    1.5\n        c    2.0\n        d    2.5\n        dtype: float64\n        "), window_method='expanding', aggregation_description='mean', agg_method='mean')
+    def mean(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().mean(numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, window_agg_numba_parameters(), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent("        >>> ser = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])\n        >>> ser.expanding().median()\n        a    1.0\n        b    1.5\n        c    2.0\n        d    2.5\n        dtype: float64\n        "), window_method='expanding', aggregation_description='median', agg_method='median')
+    def median(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().median(numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n\n        ').replace('\n', '', 1), kwargs_numeric_only, window_agg_numba_parameters('1.4'), create_section_header('Returns'), template_returns, create_section_header('See Also'), 'numpy.std : Equivalent method for NumPy array.\n', template_see_also, create_section_header('Notes'), dedent('\n        The default ``ddof`` of 1 used in :meth:`Series.std` is different\n        than the default ``ddof`` of 0 in :func:`numpy.std`.\n\n        A minimum of one period is required for the rolling calculation.\n\n        ').replace('\n', '', 1), create_section_header('Examples'), dedent('\n        >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])\n\n        >>> s.expanding(3).std()\n        0         NaN\n        1         NaN\n        2    0.577350\n        3    0.957427\n        4    0.894427\n        5    0.836660\n        6    0.786796\n        dtype: float64\n        ').replace('\n', '', 1), window_method='expanding', aggregation_description='standard deviation', agg_method='std')
+    def std(self, ddof: int=1, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().std(ddof=ddof, numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n\n        ').replace('\n', '', 1), kwargs_numeric_only, window_agg_numba_parameters('1.4'), create_section_header('Returns'), template_returns, create_section_header('See Also'), 'numpy.var : Equivalent method for NumPy array.\n', template_see_also, create_section_header('Notes'), dedent('\n        The default ``ddof`` of 1 used in :meth:`Series.var` is different\n        than the default ``ddof`` of 0 in :func:`numpy.var`.\n\n        A minimum of one period is required for the rolling calculation.\n\n        ').replace('\n', '', 1), create_section_header('Examples'), dedent('\n        >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])\n\n        >>> s.expanding(3).var()\n        0         NaN\n        1         NaN\n        2    0.333333\n        3    0.916667\n        4    0.800000\n        5    0.700000\n        6    0.619048\n        dtype: float64\n        ').replace('\n', '', 1), window_method='expanding', aggregation_description='variance', agg_method='var')
+    def var(self, ddof: int=1, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().var(ddof=ddof, numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n\n        ').replace('\n', '', 1), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), 'A minimum of one period is required for the calculation.\n\n', create_section_header('Examples'), dedent('\n        >>> s = pd.Series([0, 1, 2, 3])\n\n        >>> s.expanding().sem()\n        0         NaN\n        1    0.707107\n        2    0.707107\n        3    0.745356\n        dtype: float64\n        ').replace('\n', '', 1), window_method='expanding', aggregation_description='standard error of mean', agg_method='sem')
+    def sem(self, ddof: int=1, numeric_only: bool=False):
+        return super().sem(ddof=ddof, numeric_only=numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), 'scipy.stats.skew : Third moment of a probability density.\n', template_see_also, create_section_header('Notes'), 'A minimum of three periods is required for the rolling calculation.\n\n', create_section_header('Examples'), dedent("        >>> ser = pd.Series([-1, 0, 2, -1, 2], index=['a', 'b', 'c', 'd', 'e'])\n        >>> ser.expanding().skew()\n        a         NaN\n        b         NaN\n        c    0.935220\n        d    1.414214\n        e    0.315356\n        dtype: float64\n        "), window_method='expanding', aggregation_description='unbiased skewness', agg_method='skew')
+    def skew(self, numeric_only: bool=False):
+        return super().skew(numeric_only=numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), 'scipy.stats.kurtosis : Reference SciPy method.\n', template_see_also, create_section_header('Notes'), 'A minimum of four periods is required for the calculation.\n\n', create_section_header('Examples'), dedent('\n        The example below will show a rolling calculation with a window size of\n        four matching the equivalent function call using `scipy.stats`.\n\n        >>> arr = [1, 2, 3, 4, 999]\n        >>> import scipy.stats\n        >>> print(f"{{scipy.stats.kurtosis(arr[:-1], bias=False):.6f}}")\n        -1.200000\n        >>> print(f"{{scipy.stats.kurtosis(arr, bias=False):.6f}}")\n        4.999874\n        >>> s = pd.Series(arr)\n        >>> s.expanding(4).kurt()\n        0         NaN\n        1         NaN\n        2         NaN\n        3   -1.200000\n        4    4.999874\n        dtype: float64\n        ').replace('\n', '', 1), window_method='expanding', aggregation_description="Fisher's definition of kurtosis without bias", agg_method='kurt')
+    def kurt(self, numeric_only: bool=False):
+        return super().kurt(numeric_only=numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), dedent("\n        q : float\n            Quantile to compute. 0 <= quantile <= 1.\n\n            .. deprecated:: 2.1.0\n                This was renamed from 'quantile' to 'q' in version 2.1.0.\n        interpolation : {{'linear', 'lower', 'higher', 'midpoint', 'nearest'}}\n            This optional parameter specifies the interpolation method to use,\n            when the desired quantile lies between two data points `i` and `j`:\n\n                * linear: `i + (j - i) * fraction`, where `fraction` is the\n                  fractional part of the index surrounded by `i` and `j`.\n                * lower: `i`.\n                * higher: `j`.\n                * nearest: `i` or `j` whichever is nearest.\n                * midpoint: (`i` + `j`) / 2.\n        ").replace('\n', '', 1), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent("        >>> ser = pd.Series([1, 2, 3, 4, 5, 6], index=['a', 'b', 'c', 'd', 'e', 'f'])\n        >>> ser.expanding(min_periods=4).quantile(.25)\n        a     NaN\n        b     NaN\n        c     NaN\n        d    1.75\n        e    2.00\n        f    2.25\n        dtype: float64\n        "), window_method='expanding', aggregation_description='quantile', agg_method='quantile')
+    def quantile(self, q: float, interpolation: QuantileInterpolation='linear', numeric_only: bool=False):
+        return super().quantile(q=q, interpolation=interpolation, numeric_only=numeric_only)
+
+    @doc(template_header, '.. versionadded:: 1.4.0 \n\n', create_section_header('Parameters'), dedent("\n        method : {{'average', 'min', 'max'}}, default 'average'\n            How to rank the group of records that have the same value (i.e. ties):\n\n            * average: average rank of the group\n            * min: lowest rank in the group\n            * max: highest rank in the group\n\n        ascending : bool, default True\n            Whether or not the elements should be ranked in ascending order.\n        pct : bool, default False\n            Whether or not to display the returned rankings in percentile\n            form.\n        ").replace('\n', '', 1), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent('\n        >>> s = pd.Series([1, 4, 2, 3, 5, 3])\n        >>> s.expanding().rank()\n        0    1.0\n        1    2.0\n        2    2.0\n        3    3.0\n        4    5.0\n        5    3.5\n        dtype: float64\n\n        >>> s.expanding().rank(method="max")\n        0    1.0\n        1    2.0\n        2    2.0\n        3    3.0\n        4    5.0\n        5    4.0\n        dtype: float64\n\n        >>> s.expanding().rank(method="min")\n        0    1.0\n        1    2.0\n        2    2.0\n        3    3.0\n        4    5.0\n        5    3.0\n        dtype: float64\n        ').replace('\n', '', 1), window_method='expanding', aggregation_description='rank', agg_method='rank')
+    def rank(self, method: WindowingRankType='average', ascending: bool=True, pct: bool=False, numeric_only: bool=False):
+        return super().rank(method=method, ascending=ascending, pct=pct, numeric_only=numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        other : Series or DataFrame, optional\n            If not supplied then will default to self and produce pairwise\n            output.\n        pairwise : bool, default None\n            If False then only matching columns between self and other will be\n            used and the output will be a DataFrame.\n            If True then all pairwise combinations will be calculated and the\n            output will be a MultiIndexed DataFrame in the case of DataFrame\n            inputs. In the case of missing elements, only complete pairwise\n            observations will be used.\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n        ').replace('\n', '', 1), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent("        >>> ser1 = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])\n        >>> ser2 = pd.Series([10, 11, 13, 16], index=['a', 'b', 'c', 'd'])\n        >>> ser1.expanding().cov(ser2)\n        a         NaN\n        b    0.500000\n        c    1.500000\n        d    3.333333\n        dtype: float64\n        "), window_method='expanding', aggregation_description='sample covariance', agg_method='cov')
+    def cov(self, other: DataFrame | Series | None=None, pairwise: bool | None=None, ddof: int=1, numeric_only: bool=False):
+        return super().cov(other=other, pairwise=pairwise, ddof=ddof, numeric_only=numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        other : Series or DataFrame, optional\n            If not supplied then will default to self and produce pairwise\n            output.\n        pairwise : bool, default None\n            If False then only matching columns between self and other will be\n            used and the output will be a DataFrame.\n            If True then all pairwise combinations will be calculated and the\n            output will be a MultiIndexed DataFrame in the case of DataFrame\n            inputs. In the case of missing elements, only complete pairwise\n            observations will be used.\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n\n        ').replace('\n', '', 1), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), dedent("\n        cov : Similar method to calculate covariance.\n        numpy.corrcoef : NumPy Pearson's correlation calculation.\n        ").replace('\n', '', 1), template_see_also, create_section_header('Notes'), dedent("\n        This function uses Pearson's definition of correlation\n        (https://en.wikipedia.org/wiki/Pearson_correlation_coefficient).\n\n        When `other` is not specified, the output will be self correlation (e.g.\n        all 1's), except for :class:`~pandas.DataFrame` inputs with `pairwise`\n        set to `True`.\n\n        Function will return ``NaN`` for correlations of equal valued sequences;\n        this is the result of a 0/0 division error.\n\n        When `pairwise` is set to `False`, only matching columns between `self` and\n        `other` will be used.\n\n        When `pairwise` is set to `True`, the output will be a MultiIndex DataFrame\n        with the original index on the first level, and the `other` DataFrame\n        columns on the second level.\n\n        In the case of missing elements, only complete pairwise observations\n        will be used.\n\n        "), create_section_header('Examples'), dedent("        >>> ser1 = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])\n        >>> ser2 = pd.Series([10, 11, 13, 16], index=['a', 'b', 'c', 'd'])\n        >>> ser1.expanding().corr(ser2)\n        a         NaN\n        b    1.000000\n        c    0.981981\n        d    0.975900\n        dtype: float64\n        "), window_method='expanding', aggregation_description='correlation', agg_method='corr')
+    def corr(self, other: DataFrame | Series | None=None, pairwise: bool | None=None, ddof: int=1, numeric_only: bool=False):
+        return super().corr(other=other, pairwise=pairwise, ddof=ddof, numeric_only=numeric_only)
+
+class ExpandingGroupby(BaseWindowGroupby, Expanding):
+    _attributes = Expanding._attributes + BaseWindowGroupby._attributes
+
+    def _get_window_indexer(self) -> GroupbyIndexer:
+        window_indexer = GroupbyIndexer(groupby_indices=self._grouper.indices, window_indexer=ExpandingIndexer)
+        return window_indexer
+
+# File: pandas-main/pandas/core/window/numba_.py
+from __future__ import annotations
+import functools
+from typing import TYPE_CHECKING, Any
+import numpy as np
+from pandas.compat._optional import import_optional_dependency
+from pandas.core.util.numba_ import jit_user_function
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pandas._typing import Scalar
+
+@functools.cache
+def generate_numba_apply_func(func: Callable[..., Scalar], nopython: bool, nogil: bool, parallel: bool):
+    numba_func = jit_user_function(func)
+    if TYPE_CHECKING:
+        import numba
+    else:
+        numba = import_optional_dependency('numba')
+
+    @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+    def roll_apply(values: np.ndarray, begin: np.ndarray, end: np.ndarray, minimum_periods: int, *args: Any) -> np.ndarray:
+        result = np.empty(len(begin))
+        for i in numba.prange(len(result)):
+            start = begin[i]
+            stop = end[i]
+            window = values[start:stop]
+            count_nan = np.sum(np.isnan(window))
+            if len(window) - count_nan >= minimum_periods:
+                result[i] = numba_func(window, *args)
+            else:
+                result[i] = np.nan
+        return result
+    return roll_apply
+
+@functools.cache
+def generate_numba_ewm_func(nopython: bool, nogil: bool, parallel: bool, com: float, adjust: bool, ignore_na: bool, deltas: tuple, normalize: bool):
+    if TYPE_CHECKING:
+        import numba
+    else:
+        numba = import_optional_dependency('numba')
+
+    @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+    def ewm(values: np.ndarray, begin: np.ndarray, end: np.ndarray, minimum_periods: int) -> np.ndarray:
+        result = np.empty(len(values))
+        alpha = 1.0 / (1.0 + com)
+        old_wt_factor = 1.0 - alpha
+        new_wt = 1.0 if adjust else alpha
+        for i in numba.prange(len(begin)):
+            start = begin[i]
+            stop = end[i]
+            window = values[start:stop]
+            sub_result = np.empty(len(window))
+            weighted = window[0]
+            nobs = int(not np.isnan(weighted))
+            sub_result[0] = weighted if nobs >= minimum_periods else np.nan
+            old_wt = 1.0
+            for j in range(1, len(window)):
+                cur = window[j]
+                is_observation = not np.isnan(cur)
+                nobs += is_observation
+                if not np.isnan(weighted):
+                    if is_observation or not ignore_na:
+                        if normalize:
+                            old_wt *= old_wt_factor ** deltas[start + j - 1]
+                            if not adjust and com == 1:
+                                new_wt = 1.0 - old_wt
+                        else:
+                            weighted = old_wt_factor * weighted
+                        if is_observation:
+                            if normalize:
+                                if weighted != cur:
+                                    weighted = old_wt * weighted + new_wt * cur
+                                    if normalize:
+                                        weighted = weighted / (old_wt + new_wt)
+                                if adjust:
+                                    old_wt += new_wt
+                                else:
+                                    old_wt = 1.0
+                            else:
+                                weighted += cur
+                elif is_observation:
+                    weighted = cur
+                sub_result[j] = weighted if nobs >= minimum_periods else np.nan
+            result[start:stop] = sub_result
+        return result
+    return ewm
+
+@functools.cache
+def generate_numba_table_func(func: Callable[..., np.ndarray], nopython: bool, nogil: bool, parallel: bool):
+    numba_func = jit_user_function(func)
+    if TYPE_CHECKING:
+        import numba
+    else:
+        numba = import_optional_dependency('numba')
+
+    @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+    def roll_table(values: np.ndarray, begin: np.ndarray, end: np.ndarray, minimum_periods: int, *args: Any):
+        result = np.empty((len(begin), values.shape[1]))
+        min_periods_mask = np.empty(result.shape)
+        for i in numba.prange(len(result)):
+            start = begin[i]
+            stop = end[i]
+            window = values[start:stop]
+            count_nan = np.sum(np.isnan(window), axis=0)
+            nan_mask = len(window) - count_nan >= minimum_periods
+            if nan_mask.any():
+                result[i, :] = numba_func(window, *args)
+            min_periods_mask[i, :] = nan_mask
+        result = np.where(min_periods_mask, result, np.nan)
+        return result
+    return roll_table
+
+@functools.cache
+def generate_manual_numpy_nan_agg_with_axis(nan_func):
+    if TYPE_CHECKING:
+        import numba
+    else:
+        numba = import_optional_dependency('numba')
+
+    @numba.jit(nopython=True, nogil=True, parallel=True)
+    def nan_agg_with_axis(table):
+        result = np.empty(table.shape[1])
+        for i in numba.prange(table.shape[1]):
+            partition = table[:, i]
+            result[i] = nan_func(partition)
+        return result
+    return nan_agg_with_axis
+
+@functools.cache
+def generate_numba_ewm_table_func(nopython: bool, nogil: bool, parallel: bool, com: float, adjust: bool, ignore_na: bool, deltas: tuple, normalize: bool):
+    if TYPE_CHECKING:
+        import numba
+    else:
+        numba = import_optional_dependency('numba')
+
+    @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+    def ewm_table(values: np.ndarray, begin: np.ndarray, end: np.ndarray, minimum_periods: int) -> np.ndarray:
+        alpha = 1.0 / (1.0 + com)
+        old_wt_factor = 1.0 - alpha
+        new_wt = 1.0 if adjust else alpha
+        old_wt = np.ones(values.shape[1])
+        result = np.empty(values.shape)
+        weighted = values[0].copy()
+        nobs = (~np.isnan(weighted)).astype(np.int64)
+        result[0] = np.where(nobs >= minimum_periods, weighted, np.nan)
+        for i in range(1, len(values)):
+            cur = values[i]
+            is_observations = ~np.isnan(cur)
+            nobs += is_observations.astype(np.int64)
+            for j in numba.prange(len(cur)):
+                if not np.isnan(weighted[j]):
+                    if is_observations[j] or not ignore_na:
+                        if normalize:
+                            old_wt[j] *= old_wt_factor ** deltas[i - 1]
+                            if not adjust and com == 1:
+                                new_wt = 1.0 - old_wt[j]
+                        else:
+                            weighted[j] = old_wt_factor * weighted[j]
+                        if is_observations[j]:
+                            if normalize:
+                                if weighted[j] != cur[j]:
+                                    weighted[j] = old_wt[j] * weighted[j] + new_wt * cur[j]
+                                    if normalize:
+                                        weighted[j] = weighted[j] / (old_wt[j] + new_wt)
+                                if adjust:
+                                    old_wt[j] += new_wt
+                                else:
+                                    old_wt[j] = 1.0
+                            else:
+                                weighted[j] += cur[j]
+                elif is_observations[j]:
+                    weighted[j] = cur[j]
+            result[i] = np.where(nobs >= minimum_periods, weighted, np.nan)
+        return result
+    return ewm_table
+
+# File: pandas-main/pandas/core/window/online.py
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas.compat._optional import import_optional_dependency
+
+def generate_online_numba_ewma_func(nopython: bool, nogil: bool, parallel: bool):
+    if TYPE_CHECKING:
+        import numba
+    else:
+        numba = import_optional_dependency('numba')
+
+    @numba.jit(nopython=nopython, nogil=nogil, parallel=parallel)
+    def online_ewma(values: np.ndarray, deltas: np.ndarray, minimum_periods: int, old_wt_factor: float, new_wt: float, old_wt: np.ndarray, adjust: bool, ignore_na: bool):
+        result = np.empty(values.shape)
+        weighted_avg = values[0].copy()
+        nobs = (~np.isnan(weighted_avg)).astype(np.int64)
+        result[0] = np.where(nobs >= minimum_periods, weighted_avg, np.nan)
+        for i in range(1, len(values)):
+            cur = values[i]
+            is_observations = ~np.isnan(cur)
+            nobs += is_observations.astype(np.int64)
+            for j in numba.prange(len(cur)):
+                if not np.isnan(weighted_avg[j]):
+                    if is_observations[j] or not ignore_na:
+                        old_wt[j] *= old_wt_factor ** deltas[j - 1]
+                        if is_observations[j]:
+                            if weighted_avg[j] != cur[j]:
+                                weighted_avg[j] = (old_wt[j] * weighted_avg[j] + new_wt * cur[j]) / (old_wt[j] + new_wt)
+                            if adjust:
+                                old_wt[j] += new_wt
+                            else:
+                                old_wt[j] = 1.0
+                elif is_observations[j]:
+                    weighted_avg[j] = cur[j]
+            result[i] = np.where(nobs >= minimum_periods, weighted_avg, np.nan)
+        return (result, old_wt)
+    return online_ewma
+
+class EWMMeanState:
+
+    def __init__(self, com, adjust, ignore_na, shape) -> None:
+        alpha = 1.0 / (1.0 + com)
+        self.shape = shape
+        self.adjust = adjust
+        self.ignore_na = ignore_na
+        self.new_wt = 1.0 if adjust else alpha
+        self.old_wt_factor = 1.0 - alpha
+        self.old_wt = np.ones(self.shape[-1])
+        self.last_ewm = None
+
+    def run_ewm(self, weighted_avg, deltas, min_periods, ewm_func):
+        (result, old_wt) = ewm_func(weighted_avg, deltas, min_periods, self.old_wt_factor, self.new_wt, self.old_wt, self.adjust, self.ignore_na)
+        self.old_wt = old_wt
+        self.last_ewm = result[-1]
+        return result
+
+    def reset(self) -> None:
+        self.old_wt = np.ones(self.shape[-1])
+        self.last_ewm = None
+
+# File: pandas-main/pandas/core/window/rolling.py
+""""""
+from __future__ import annotations
+import copy
+from datetime import timedelta
+from functools import partial
+import inspect
+from textwrap import dedent
+from typing import TYPE_CHECKING, Any, Literal
+import numpy as np
+from pandas._libs.tslibs import BaseOffset, Timedelta, to_offset
+import pandas._libs.window.aggregations as window_aggregations
+from pandas.compat._optional import import_optional_dependency
+from pandas.errors import DataError
+from pandas.util._decorators import doc
+from pandas.core.dtypes.common import ensure_float64, is_bool, is_integer, is_numeric_dtype, needs_i8_conversion
+from pandas.core.dtypes.dtypes import ArrowDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.dtypes.missing import notna
+from pandas.core._numba import executor
+from pandas.core.algorithms import factorize
+from pandas.core.apply import ResamplerWindowApply
+from pandas.core.arrays import ExtensionArray
+from pandas.core.base import SelectionMixin
+import pandas.core.common as com
+from pandas.core.indexers.objects import BaseIndexer, FixedWindowIndexer, GroupbyIndexer, VariableWindowIndexer
+from pandas.core.indexes.api import DatetimeIndex, Index, MultiIndex, PeriodIndex, TimedeltaIndex
+from pandas.core.reshape.concat import concat
+from pandas.core.util.numba_ import get_jit_arguments, maybe_use_numba
+from pandas.core.window.common import flex_binary_moment, zsqrt
+from pandas.core.window.doc import _shared_docs, create_section_header, kwargs_numeric_only, kwargs_scipy, numba_notes, template_header, template_returns, template_see_also, window_agg_numba_parameters, window_apply_parameters
+from pandas.core.window.numba_ import generate_manual_numpy_nan_agg_with_axis, generate_numba_apply_func, generate_numba_table_func
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from collections.abc import Hashable, Iterator, Sized
+    from pandas._typing import ArrayLike, NDFrameT, QuantileInterpolation, WindowingRankType, npt
+    from pandas import DataFrame, Series
+    from pandas.core.generic import NDFrame
+    from pandas.core.groupby.ops import BaseGrouper
+from pandas.core.arrays.datetimelike import dtype_to_unit
+
+class BaseWindow(SelectionMixin):
+    _attributes: list[str] = []
+    exclusions: frozenset[Hashable] = frozenset()
+    _on: Index
+
+    def __init__(self, obj: NDFrame, window=None, min_periods: int | None=None, center: bool | None=False, win_type: str | None=None, on: str | Index | None=None, closed: str | None=None, step: int | None=None, method: str='single', *, selection=None) -> None:
+        self.obj = obj
+        self.on = on
+        self.closed = closed
+        self.step = step
+        self.window = window
+        self.min_periods = min_periods
+        self.center = center
+        self.win_type = win_type
+        self.method = method
+        self._win_freq_i8: int | None = None
+        if self.on is None:
+            self._on = self.obj.index
+        elif isinstance(self.on, Index):
+            self._on = self.on
+        elif isinstance(self.obj, ABCDataFrame) and self.on in self.obj.columns:
+            self._on = Index(self.obj[self.on])
+        else:
+            raise ValueError(f'invalid on specified as {self.on}, must be a column (of DataFrame), an Index or None')
+        self._selection = selection
+        self._validate()
+
+    def _validate(self) -> None:
+        if self.center is not None and (not is_bool(self.center)):
+            raise ValueError('center must be a boolean')
+        if self.min_periods is not None:
+            if not is_integer(self.min_periods):
+                raise ValueError('min_periods must be an integer')
+            if self.min_periods < 0:
+                raise ValueError('min_periods must be >= 0')
+            if is_integer(self.window) and self.min_periods > self.window:
+                raise ValueError(f'min_periods {self.min_periods} must be <= window {self.window}')
+        if self.closed is not None and self.closed not in ['right', 'both', 'left', 'neither']:
+            raise ValueError("closed must be 'right', 'left', 'both' or 'neither'")
+        if not isinstance(self.obj, (ABCSeries, ABCDataFrame)):
+            raise TypeError(f'invalid type: {type(self)}')
+        if isinstance(self.window, BaseIndexer):
+            get_window_bounds_signature = inspect.signature(self.window.get_window_bounds).parameters.keys()
+            expected_signature = inspect.signature(BaseIndexer().get_window_bounds).parameters.keys()
+            if get_window_bounds_signature != expected_signature:
+                raise ValueError(f'{type(self.window).__name__} does not implement the correct signature for get_window_bounds')
+        if self.method not in ['table', 'single']:
+            raise ValueError("method must be 'table' or 'single")
+        if self.step is not None:
+            if not is_integer(self.step):
+                raise ValueError('step must be an integer')
+            if self.step < 0:
+                raise ValueError('step must be >= 0')
+
+    def _check_window_bounds(self, start: np.ndarray, end: np.ndarray, num_vals: int) -> None:
+        if len(start) != len(end):
+            raise ValueError(f'start ({len(start)}) and end ({len(end)}) bounds must be the same length')
+        if len(start) != (num_vals + (self.step or 1) - 1) // (self.step or 1):
+            raise ValueError(f'start and end bounds ({len(start)}) must be the same length as the object ({num_vals}) divided by the step ({self.step}) if given and rounded up')
+
+    def _slice_axis_for_step(self, index: Index, result: Sized | None=None) -> Index:
+        return index if result is None or len(result) == len(index) else index[::self.step]
+
+    def _validate_numeric_only(self, name: str, numeric_only: bool) -> None:
+        if self._selected_obj.ndim == 1 and numeric_only and (not is_numeric_dtype(self._selected_obj.dtype)):
+            raise NotImplementedError(f'{type(self).__name__}.{name} does not implement numeric_only')
+
+    def _make_numeric_only(self, obj: NDFrameT) -> NDFrameT:
+        result = obj.select_dtypes(include=['number'], exclude=['timedelta'])
+        return result
+
+    def _create_data(self, obj: NDFrameT, numeric_only: bool=False) -> NDFrameT:
+        if self.on is not None and (not isinstance(self.on, Index)) and (obj.ndim == 2):
+            obj = obj.reindex(columns=obj.columns.difference([self.on]))
+        if obj.ndim > 1 and numeric_only:
+            obj = self._make_numeric_only(obj)
+        return obj
+
+    def _gotitem(self, key, ndim, subset=None):
+        if subset is None:
+            subset = self.obj
+        kwargs = {attr: getattr(self, attr) for attr in self._attributes}
+        selection = self._infer_selection(key, subset)
+        new_win = type(self)(subset, selection=selection, **kwargs)
+        return new_win
+
+    def __getattr__(self, attr: str):
+        if attr in self._internal_names_set:
+            return object.__getattribute__(self, attr)
+        if attr in self.obj:
+            return self[attr]
+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{attr}'")
+
+    def _dir_additions(self):
+        return self.obj._dir_additions()
+
+    def __repr__(self) -> str:
+        attrs_list = (f'{attr_name}={getattr(self, attr_name)}' for attr_name in self._attributes if getattr(self, attr_name, None) is not None and attr_name[0] != '_')
+        attrs = ','.join(attrs_list)
+        return f'{type(self).__name__} [{attrs}]'
+
+    def __iter__(self) -> Iterator:
+        obj = self._selected_obj.set_axis(self._on)
+        obj = self._create_data(obj)
+        indexer = self._get_window_indexer()
+        (start, end) = indexer.get_window_bounds(num_values=len(obj), min_periods=self.min_periods, center=self.center, closed=self.closed, step=self.step)
+        self._check_window_bounds(start, end, len(obj))
+        for (s, e) in zip(start, end):
+            result = obj.iloc[slice(s, e)]
+            yield result
+
+    def _prep_values(self, values: ArrayLike) -> np.ndarray:
+        if needs_i8_conversion(values.dtype):
+            raise NotImplementedError(f'ops for {type(self).__name__} for this dtype {values.dtype} are not implemented')
+        try:
+            if isinstance(values, ExtensionArray):
+                values = values.to_numpy(np.float64, na_value=np.nan)
+            else:
+                values = ensure_float64(values)
+        except (ValueError, TypeError) as err:
+            raise TypeError(f'cannot handle this type -> {values.dtype}') from err
+        inf = np.isinf(values)
+        if inf.any():
+            values = np.where(inf, np.nan, values)
+        return values
+
+    def _insert_on_column(self, result: DataFrame, obj: DataFrame) -> None:
+        from pandas import Series
+        if self.on is not None and (not self._on.equals(obj.index)):
+            name = self._on.name
+            extra_col = Series(self._on, index=self.obj.index, name=name, copy=False)
+            if name in result.columns:
+                result[name] = extra_col
+            elif name in result.index.names:
+                pass
+            elif name in self._selected_obj.columns:
+                old_cols = self._selected_obj.columns
+                new_cols = result.columns
+                old_loc = old_cols.get_loc(name)
+                overlap = new_cols.intersection(old_cols[:old_loc])
+                new_loc = len(overlap)
+                result.insert(new_loc, name, extra_col)
+            else:
+                result[name] = extra_col
+
+    @property
+    def _index_array(self) -> npt.NDArray[np.int64] | None:
+        if isinstance(self._on, (PeriodIndex, DatetimeIndex, TimedeltaIndex)):
+            return self._on.asi8
+        elif isinstance(self._on.dtype, ArrowDtype) and self._on.dtype.kind in 'mM':
+            return self._on.to_numpy(dtype=np.int64)
+        return None
+
+    def _resolve_output(self, out: DataFrame, obj: DataFrame) -> DataFrame:
+        if out.shape[1] == 0 and obj.shape[1] > 0:
+            raise DataError('No numeric types to aggregate')
+        if out.shape[1] == 0:
+            return obj.astype('float64')
+        self._insert_on_column(out, obj)
+        return out
+
+    def _get_window_indexer(self) -> BaseIndexer:
+        if isinstance(self.window, BaseIndexer):
+            return self.window
+        if self._win_freq_i8 is not None:
+            return VariableWindowIndexer(index_array=self._index_array, window_size=self._win_freq_i8, center=self.center)
+        return FixedWindowIndexer(window_size=self.window)
+
+    def _apply_series(self, homogeneous_func: Callable[..., ArrayLike], name: str | None=None) -> Series:
+        obj = self._create_data(self._selected_obj)
+        if name == 'count':
+            obj = notna(obj).astype(int)
+        try:
+            values = self._prep_values(obj._values)
+        except (TypeError, NotImplementedError) as err:
+            raise DataError('No numeric types to aggregate') from err
+        result = homogeneous_func(values)
+        index = self._slice_axis_for_step(obj.index, result)
+        return obj._constructor(result, index=index, name=obj.name)
+
+    def _apply_columnwise(self, homogeneous_func: Callable[..., ArrayLike], name: str, numeric_only: bool=False) -> DataFrame | Series:
+        self._validate_numeric_only(name, numeric_only)
+        if self._selected_obj.ndim == 1:
+            return self._apply_series(homogeneous_func, name)
+        obj = self._create_data(self._selected_obj, numeric_only)
+        if name == 'count':
+            obj = notna(obj).astype(int)
+            obj._mgr = obj._mgr.consolidate()
+        taker = []
+        res_values = []
+        for (i, arr) in enumerate(obj._iter_column_arrays()):
+            try:
+                arr = self._prep_values(arr)
+            except (TypeError, NotImplementedError) as err:
+                raise DataError(f'Cannot aggregate non-numeric type: {arr.dtype}') from err
+            res = homogeneous_func(arr)
+            res_values.append(res)
+            taker.append(i)
+        index = self._slice_axis_for_step(obj.index, res_values[0] if len(res_values) > 0 else None)
+        df = type(obj)._from_arrays(res_values, index=index, columns=obj.columns.take(taker), verify_integrity=False)
+        return self._resolve_output(df, obj)
+
+    def _apply_tablewise(self, homogeneous_func: Callable[..., ArrayLike], name: str | None=None, numeric_only: bool=False) -> DataFrame | Series:
+        if self._selected_obj.ndim == 1:
+            raise ValueError("method='table' not applicable for Series objects.")
+        obj = self._create_data(self._selected_obj, numeric_only)
+        values = self._prep_values(obj.to_numpy())
+        result = homogeneous_func(values)
+        index = self._slice_axis_for_step(obj.index, result)
+        columns = obj.columns if result.shape[1] == len(obj.columns) else obj.columns[::self.step]
+        out = obj._constructor(result, index=index, columns=columns)
+        return self._resolve_output(out, obj)
+
+    def _apply_pairwise(self, target: DataFrame | Series, other: DataFrame | Series | None, pairwise: bool | None, func: Callable[[DataFrame | Series, DataFrame | Series], DataFrame | Series], numeric_only: bool) -> DataFrame | Series:
+        target = self._create_data(target, numeric_only)
+        if other is None:
+            other = target
+            pairwise = True if pairwise is None else pairwise
+        elif not isinstance(other, (ABCDataFrame, ABCSeries)):
+            raise ValueError('other must be a DataFrame or Series')
+        elif other.ndim == 2 and numeric_only:
+            other = self._make_numeric_only(other)
+        return flex_binary_moment(target, other, func, pairwise=bool(pairwise))
+
+    def _apply(self, func: Callable[..., Any], name: str, numeric_only: bool=False, numba_args: tuple[Any, ...]=(), **kwargs):
+        window_indexer = self._get_window_indexer()
+        min_periods = self.min_periods if self.min_periods is not None else window_indexer.window_size
+
+        def homogeneous_func(values: np.ndarray):
+            if values.size == 0:
+                return values.copy()
+
+            def calc(x):
+                (start, end) = window_indexer.get_window_bounds(num_values=len(x), min_periods=min_periods, center=self.center, closed=self.closed, step=self.step)
+                self._check_window_bounds(start, end, len(x))
+                return func(x, start, end, min_periods, *numba_args)
+            with np.errstate(all='ignore'):
+                result = calc(values)
+            return result
+        if self.method == 'single':
+            return self._apply_columnwise(homogeneous_func, name, numeric_only)
+        else:
+            return self._apply_tablewise(homogeneous_func, name, numeric_only)
+
+    def _numba_apply(self, func: Callable[..., Any], engine_kwargs: dict[str, bool] | None=None, **func_kwargs):
+        window_indexer = self._get_window_indexer()
+        min_periods = self.min_periods if self.min_periods is not None else window_indexer.window_size
+        obj = self._create_data(self._selected_obj)
+        values = self._prep_values(obj.to_numpy())
+        if values.ndim == 1:
+            values = values.reshape(-1, 1)
+        (start, end) = window_indexer.get_window_bounds(num_values=len(values), min_periods=min_periods, center=self.center, closed=self.closed, step=self.step)
+        self._check_window_bounds(start, end, len(values))
+        dtype_mapping = executor.float_dtype_mapping
+        aggregator = executor.generate_shared_aggregator(func, dtype_mapping, is_grouped_kernel=False, **get_jit_arguments(engine_kwargs))
+        result = aggregator(values.T, start=start, end=end, min_periods=min_periods, **func_kwargs).T
+        index = self._slice_axis_for_step(obj.index, result)
+        if obj.ndim == 1:
+            result = result.squeeze()
+            out = obj._constructor(result, index=index, name=obj.name)
+            return out
+        else:
+            columns = self._slice_axis_for_step(obj.columns, result.T)
+            out = obj._constructor(result, index=index, columns=columns)
+            return self._resolve_output(out, obj)
+
+    def aggregate(self, func, *args, **kwargs):
+        result = ResamplerWindowApply(self, func, args=args, kwargs=kwargs).agg()
+        if result is None:
+            return self.apply(func, raw=False, args=args, kwargs=kwargs)
+        return result
+    agg = aggregate
+
+class BaseWindowGroupby(BaseWindow):
+    _grouper: BaseGrouper
+    _as_index: bool
+    _attributes: list[str] = ['_grouper']
+
+    def __init__(self, obj: DataFrame | Series, *args, _grouper: BaseGrouper, _as_index: bool=True, **kwargs) -> None:
+        from pandas.core.groupby.ops import BaseGrouper
+        if not isinstance(_grouper, BaseGrouper):
+            raise ValueError('Must pass a BaseGrouper object.')
+        self._grouper = _grouper
+        self._as_index = _as_index
+        obj = obj.drop(columns=self._grouper.names, errors='ignore')
+        if kwargs.get('step') is not None:
+            raise NotImplementedError('step not implemented for groupby')
+        super().__init__(obj, *args, **kwargs)
+
+    def _apply(self, func: Callable[..., Any], name: str, numeric_only: bool=False, numba_args: tuple[Any, ...]=(), **kwargs) -> DataFrame | Series:
+        result = super()._apply(func, name, numeric_only, numba_args, **kwargs)
+        grouped_object_index = self.obj.index
+        grouped_index_name = [*grouped_object_index.names]
+        groupby_keys = copy.copy(self._grouper.names)
+        result_index_names = groupby_keys + grouped_index_name
+        drop_columns = [key for key in self._grouper.names if key not in self.obj.index.names or key is None]
+        if len(drop_columns) != len(groupby_keys):
+            result = result.drop(columns=drop_columns, errors='ignore')
+        codes = self._grouper.codes
+        levels = copy.copy(self._grouper.levels)
+        group_indices = self._grouper.indices.values()
+        if group_indices:
+            indexer = np.concatenate(list(group_indices))
+        else:
+            indexer = np.array([], dtype=np.intp)
+        codes = [c.take(indexer) for c in codes]
+        if grouped_object_index is not None:
+            idx = grouped_object_index.take(indexer)
+            if not isinstance(idx, MultiIndex):
+                idx = MultiIndex.from_arrays([idx])
+            codes.extend(list(idx.codes))
+            levels.extend(list(idx.levels))
+        result_index = MultiIndex(levels, codes, names=result_index_names, verify_integrity=False)
+        result.index = result_index
+        if not self._as_index:
+            result = result.reset_index(level=list(range(len(groupby_keys))))
+        return result
+
+    def _apply_pairwise(self, target: DataFrame | Series, other: DataFrame | Series | None, pairwise: bool | None, func: Callable[[DataFrame | Series, DataFrame | Series], DataFrame | Series], numeric_only: bool) -> DataFrame | Series:
+        target = target.drop(columns=self._grouper.names, errors='ignore')
+        result = super()._apply_pairwise(target, other, pairwise, func, numeric_only)
+        if other is not None and (not all((len(group) == len(other) for group in self._grouper.indices.values()))):
+            old_result_len = len(result)
+            result = concat([result.take(gb_indices).reindex(result.index) for gb_indices in self._grouper.indices.values()])
+            gb_pairs = (com.maybe_make_list(pair) for pair in self._grouper.indices.keys())
+            groupby_codes = []
+            groupby_levels = []
+            for gb_level_pair in map(list, zip(*gb_pairs)):
+                labels = np.repeat(np.array(gb_level_pair), old_result_len)
+                (codes, levels) = factorize(labels)
+                groupby_codes.append(codes)
+                groupby_levels.append(levels)
+        else:
+            groupby_codes = self._grouper.codes
+            groupby_levels = self._grouper.levels
+            group_indices = self._grouper.indices.values()
+            if group_indices:
+                indexer = np.concatenate(list(group_indices))
+            else:
+                indexer = np.array([], dtype=np.intp)
+            if target.ndim == 1:
+                repeat_by = 1
+            else:
+                repeat_by = len(target.columns)
+            groupby_codes = [np.repeat(c.take(indexer), repeat_by) for c in groupby_codes]
+        if isinstance(result.index, MultiIndex):
+            result_codes = list(result.index.codes)
+            result_levels = list(result.index.levels)
+            result_names = list(result.index.names)
+        else:
+            (idx_codes, idx_levels) = factorize(result.index)
+            result_codes = [idx_codes]
+            result_levels = [idx_levels]
+            result_names = [result.index.name]
+        result_codes = groupby_codes + result_codes
+        result_levels = groupby_levels + result_levels
+        result_names = self._grouper.names + result_names
+        result_index = MultiIndex(result_levels, result_codes, names=result_names, verify_integrity=False)
+        result.index = result_index
+        return result
+
+    def _create_data(self, obj: NDFrameT, numeric_only: bool=False) -> NDFrameT:
+        if not obj.empty:
+            groupby_order = np.concatenate(list(self._grouper.indices.values())).astype(np.int64)
+            obj = obj.take(groupby_order)
+        return super()._create_data(obj, numeric_only)
+
+    def _gotitem(self, key, ndim, subset=None):
+        if self.on is not None:
+            subset = self.obj.set_index(self._on)
+        return super()._gotitem(key, ndim, subset=subset)
+
+class Window(BaseWindow):
+    _attributes = ['window', 'min_periods', 'center', 'win_type', 'on', 'closed', 'step', 'method']
+
+    def _validate(self) -> None:
+        super()._validate()
+        if not isinstance(self.win_type, str):
+            raise ValueError(f'Invalid win_type {self.win_type}')
+        signal = import_optional_dependency('scipy.signal.windows', extra='Scipy is required to generate window weight.')
+        self._scipy_weight_generator = getattr(signal, self.win_type, None)
+        if self._scipy_weight_generator is None:
+            raise ValueError(f'Invalid win_type {self.win_type}')
+        if isinstance(self.window, BaseIndexer):
+            raise NotImplementedError('BaseIndexer subclasses not implemented with win_types.')
+        if not is_integer(self.window) or self.window < 0:
+            raise ValueError('window must be an integer 0 or greater')
+        if self.method != 'single':
+            raise NotImplementedError("'single' is the only supported method type.")
+
+    def _center_window(self, result: np.ndarray, offset: int) -> np.ndarray:
+        if offset > 0:
+            lead_indexer = [slice(offset, None)]
+            result = np.copy(result[tuple(lead_indexer)])
+        return result
+
+    def _apply(self, func: Callable[[np.ndarray, int, int], np.ndarray], name: str, numeric_only: bool=False, numba_args: tuple[Any, ...]=(), **kwargs):
+        window = self._scipy_weight_generator(self.window, **kwargs)
+        offset = (len(window) - 1) // 2 if self.center else 0
+
+        def homogeneous_func(values: np.ndarray):
+            if values.size == 0:
+                return values.copy()
+
+            def calc(x):
+                additional_nans = np.full(offset, np.nan)
+                x = np.concatenate((x, additional_nans))
+                return func(x, window, self.min_periods if self.min_periods is not None else len(window))
+            with np.errstate(all='ignore'):
+                result = np.asarray(calc(values))
+            if self.center:
+                result = self._center_window(result, offset)
+            return result
+        return self._apply_columnwise(homogeneous_func, name, numeric_only)[::self.step]
+
+    @doc(_shared_docs['aggregate'], see_also=dedent('\n        See Also\n        --------\n        DataFrame.aggregate : Similar DataFrame method.\n        Series.aggregate : Similar Series method.\n        '), examples=dedent('\n        Examples\n        --------\n        >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})\n        >>> df\n           A  B  C\n        0  1  4  7\n        1  2  5  8\n        2  3  6  9\n\n        >>> df.rolling(2, win_type="boxcar").agg("mean")\n             A    B    C\n        0  NaN  NaN  NaN\n        1  1.5  4.5  7.5\n        2  2.5  5.5  8.5\n        '), klass='Series/DataFrame', axis='')
+    def aggregate(self, func, *args, **kwargs):
+        result = ResamplerWindowApply(self, func, args=args, kwargs=kwargs).agg()
+        if result is None:
+            result = func(self)
+        return result
+    agg = aggregate
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, kwargs_scipy, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent("        >>> ser = pd.Series([0, 1, 5, 2, 8])\n\n        To get an instance of :class:`~pandas.core.window.rolling.Window` we need\n        to pass the parameter `win_type`.\n\n        >>> type(ser.rolling(2, win_type='gaussian'))\n        <class 'pandas.core.window.rolling.Window'>\n\n        In order to use the `SciPy` Gaussian window we need to provide the parameters\n        `M` and `std`. The parameter `M` corresponds to 2 in our example.\n        We pass the second parameter `std` as a parameter of the following method\n        (`sum` in this case):\n\n        >>> ser.rolling(2, win_type='gaussian').sum(std=3)\n        0         NaN\n        1    0.986207\n        2    5.917243\n        3    6.903450\n        4    9.862071\n        dtype: float64\n        "), window_method='rolling', aggregation_description='weighted window sum', agg_method='sum')
+    def sum(self, numeric_only: bool=False, **kwargs):
+        window_func = window_aggregations.roll_weighted_sum
+        return self._apply(window_func, name='sum', numeric_only=numeric_only, **kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, kwargs_scipy, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent("        >>> ser = pd.Series([0, 1, 5, 2, 8])\n\n        To get an instance of :class:`~pandas.core.window.rolling.Window` we need\n        to pass the parameter `win_type`.\n\n        >>> type(ser.rolling(2, win_type='gaussian'))\n        <class 'pandas.core.window.rolling.Window'>\n\n        In order to use the `SciPy` Gaussian window we need to provide the parameters\n        `M` and `std`. The parameter `M` corresponds to 2 in our example.\n        We pass the second parameter `std` as a parameter of the following method:\n\n        >>> ser.rolling(2, win_type='gaussian').mean(std=3)\n        0    NaN\n        1    0.5\n        2    3.0\n        3    3.5\n        4    5.0\n        dtype: float64\n        "), window_method='rolling', aggregation_description='weighted window mean', agg_method='mean')
+    def mean(self, numeric_only: bool=False, **kwargs):
+        window_func = window_aggregations.roll_weighted_mean
+        return self._apply(window_func, name='mean', numeric_only=numeric_only, **kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n        ').replace('\n', '', 1), kwargs_numeric_only, kwargs_scipy, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent("        >>> ser = pd.Series([0, 1, 5, 2, 8])\n\n        To get an instance of :class:`~pandas.core.window.rolling.Window` we need\n        to pass the parameter `win_type`.\n\n        >>> type(ser.rolling(2, win_type='gaussian'))\n        <class 'pandas.core.window.rolling.Window'>\n\n        In order to use the `SciPy` Gaussian window we need to provide the parameters\n        `M` and `std`. The parameter `M` corresponds to 2 in our example.\n        We pass the second parameter `std` as a parameter of the following method:\n\n        >>> ser.rolling(2, win_type='gaussian').var(std=3)\n        0     NaN\n        1     0.5\n        2     8.0\n        3     4.5\n        4    18.0\n        dtype: float64\n        "), window_method='rolling', aggregation_description='weighted window variance', agg_method='var')
+    def var(self, ddof: int=1, numeric_only: bool=False, **kwargs):
+        window_func = partial(window_aggregations.roll_weighted_var, ddof=ddof)
+        kwargs.pop('name', None)
+        return self._apply(window_func, name='var', numeric_only=numeric_only, **kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n        ').replace('\n', '', 1), kwargs_numeric_only, kwargs_scipy, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent("        >>> ser = pd.Series([0, 1, 5, 2, 8])\n\n        To get an instance of :class:`~pandas.core.window.rolling.Window` we need\n        to pass the parameter `win_type`.\n\n        >>> type(ser.rolling(2, win_type='gaussian'))\n        <class 'pandas.core.window.rolling.Window'>\n\n        In order to use the `SciPy` Gaussian window we need to provide the parameters\n        `M` and `std`. The parameter `M` corresponds to 2 in our example.\n        We pass the second parameter `std` as a parameter of the following method:\n\n        >>> ser.rolling(2, win_type='gaussian').std(std=3)\n        0         NaN\n        1    0.707107\n        2    2.828427\n        3    2.121320\n        4    4.242641\n        dtype: float64\n        "), window_method='rolling', aggregation_description='weighted window standard deviation', agg_method='std')
+    def std(self, ddof: int=1, numeric_only: bool=False, **kwargs):
+        return zsqrt(self.var(ddof=ddof, name='std', numeric_only=numeric_only, **kwargs))
+
+class RollingAndExpandingMixin(BaseWindow):
+
+    def count(self, numeric_only: bool=False):
+        window_func = window_aggregations.roll_sum
+        return self._apply(window_func, name='count', numeric_only=numeric_only)
+
+    def apply(self, func: Callable[..., Any], raw: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None, args: tuple[Any, ...] | None=None, kwargs: dict[str, Any] | None=None):
+        if args is None:
+            args = ()
+        if kwargs is None:
+            kwargs = {}
+        if not is_bool(raw):
+            raise ValueError('raw parameter must be `True` or `False`')
+        numba_args: tuple[Any, ...] = ()
+        if maybe_use_numba(engine):
+            if raw is False:
+                raise ValueError('raw must be `True` when using the numba engine')
+            numba_args = args
+            if self.method == 'single':
+                apply_func = generate_numba_apply_func(func, **get_jit_arguments(engine_kwargs, kwargs))
+            else:
+                apply_func = generate_numba_table_func(func, **get_jit_arguments(engine_kwargs, kwargs))
+        elif engine in ('cython', None):
+            if engine_kwargs is not None:
+                raise ValueError('cython engine does not accept engine_kwargs')
+            apply_func = self._generate_cython_apply_func(args, kwargs, raw, func)
+        else:
+            raise ValueError("engine must be either 'numba' or 'cython'")
+        return self._apply(apply_func, name='apply', numba_args=numba_args)
+
+    def _generate_cython_apply_func(self, args: tuple[Any, ...], kwargs: dict[str, Any], raw: bool | np.bool_, function: Callable[..., Any]) -> Callable[[np.ndarray, np.ndarray, np.ndarray, int], np.ndarray]:
+        from pandas import Series
+        window_func = partial(window_aggregations.roll_apply, args=args, kwargs=kwargs, raw=raw, function=function)
+
+        def apply_func(values, begin, end, min_periods, raw=raw):
+            if not raw:
+                values = Series(values, index=self._on, copy=False)
+            return window_func(values, begin, end, min_periods)
+        return apply_func
+
+    def sum(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        if maybe_use_numba(engine):
+            if self.method == 'table':
+                func = generate_manual_numpy_nan_agg_with_axis(np.nansum)
+                return self.apply(func, raw=True, engine=engine, engine_kwargs=engine_kwargs)
+            else:
+                from pandas.core._numba.kernels import sliding_sum
+                return self._numba_apply(sliding_sum, engine_kwargs)
+        window_func = window_aggregations.roll_sum
+        return self._apply(window_func, name='sum', numeric_only=numeric_only)
+
+    def max(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        if maybe_use_numba(engine):
+            if self.method == 'table':
+                func = generate_manual_numpy_nan_agg_with_axis(np.nanmax)
+                return self.apply(func, raw=True, engine=engine, engine_kwargs=engine_kwargs)
+            else:
+                from pandas.core._numba.kernels import sliding_min_max
+                return self._numba_apply(sliding_min_max, engine_kwargs, is_max=True)
+        window_func = window_aggregations.roll_max
+        return self._apply(window_func, name='max', numeric_only=numeric_only)
+
+    def min(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        if maybe_use_numba(engine):
+            if self.method == 'table':
+                func = generate_manual_numpy_nan_agg_with_axis(np.nanmin)
+                return self.apply(func, raw=True, engine=engine, engine_kwargs=engine_kwargs)
+            else:
+                from pandas.core._numba.kernels import sliding_min_max
+                return self._numba_apply(sliding_min_max, engine_kwargs, is_max=False)
+        window_func = window_aggregations.roll_min
+        return self._apply(window_func, name='min', numeric_only=numeric_only)
+
+    def mean(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        if maybe_use_numba(engine):
+            if self.method == 'table':
+                func = generate_manual_numpy_nan_agg_with_axis(np.nanmean)
+                return self.apply(func, raw=True, engine=engine, engine_kwargs=engine_kwargs)
+            else:
+                from pandas.core._numba.kernels import sliding_mean
+                return self._numba_apply(sliding_mean, engine_kwargs)
+        window_func = window_aggregations.roll_mean
+        return self._apply(window_func, name='mean', numeric_only=numeric_only)
+
+    def median(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        if maybe_use_numba(engine):
+            if self.method == 'table':
+                func = generate_manual_numpy_nan_agg_with_axis(np.nanmedian)
+            else:
+                func = np.nanmedian
+            return self.apply(func, raw=True, engine=engine, engine_kwargs=engine_kwargs)
+        window_func = window_aggregations.roll_median_c
+        return self._apply(window_func, name='median', numeric_only=numeric_only)
+
+    def std(self, ddof: int=1, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        if maybe_use_numba(engine):
+            if self.method == 'table':
+                raise NotImplementedError("std not supported with method='table'")
+            from pandas.core._numba.kernels import sliding_var
+            return zsqrt(self._numba_apply(sliding_var, engine_kwargs, ddof=ddof))
+        window_func = window_aggregations.roll_var
+
+        def zsqrt_func(values, begin, end, min_periods):
+            return zsqrt(window_func(values, begin, end, min_periods, ddof=ddof))
+        return self._apply(zsqrt_func, name='std', numeric_only=numeric_only)
+
+    def var(self, ddof: int=1, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        if maybe_use_numba(engine):
+            if self.method == 'table':
+                raise NotImplementedError("var not supported with method='table'")
+            from pandas.core._numba.kernels import sliding_var
+            return self._numba_apply(sliding_var, engine_kwargs, ddof=ddof)
+        window_func = partial(window_aggregations.roll_var, ddof=ddof)
+        return self._apply(window_func, name='var', numeric_only=numeric_only)
+
+    def skew(self, numeric_only: bool=False):
+        window_func = window_aggregations.roll_skew
+        return self._apply(window_func, name='skew', numeric_only=numeric_only)
+
+    def sem(self, ddof: int=1, numeric_only: bool=False):
+        self._validate_numeric_only('sem', numeric_only)
+        return self.std(numeric_only=numeric_only) / (self.count(numeric_only=numeric_only) - ddof).pow(0.5)
+
+    def kurt(self, numeric_only: bool=False):
+        window_func = window_aggregations.roll_kurt
+        return self._apply(window_func, name='kurt', numeric_only=numeric_only)
+
+    def quantile(self, q: float, interpolation: QuantileInterpolation='linear', numeric_only: bool=False):
+        if q == 1.0:
+            window_func = window_aggregations.roll_max
+        elif q == 0.0:
+            window_func = window_aggregations.roll_min
+        else:
+            window_func = partial(window_aggregations.roll_quantile, quantile=q, interpolation=interpolation)
+        return self._apply(window_func, name='quantile', numeric_only=numeric_only)
+
+    def rank(self, method: WindowingRankType='average', ascending: bool=True, pct: bool=False, numeric_only: bool=False):
+        window_func = partial(window_aggregations.roll_rank, method=method, ascending=ascending, percentile=pct)
+        return self._apply(window_func, name='rank', numeric_only=numeric_only)
+
+    def cov(self, other: DataFrame | Series | None=None, pairwise: bool | None=None, ddof: int=1, numeric_only: bool=False):
+        if self.step is not None:
+            raise NotImplementedError('step not implemented for cov')
+        self._validate_numeric_only('cov', numeric_only)
+        from pandas import Series
+
+        def cov_func(x, y):
+            x_array = self._prep_values(x)
+            y_array = self._prep_values(y)
+            window_indexer = self._get_window_indexer()
+            min_periods = self.min_periods if self.min_periods is not None else window_indexer.window_size
+            (start, end) = window_indexer.get_window_bounds(num_values=len(x_array), min_periods=min_periods, center=self.center, closed=self.closed, step=self.step)
+            self._check_window_bounds(start, end, len(x_array))
+            with np.errstate(all='ignore'):
+                mean_x_y = window_aggregations.roll_mean(x_array * y_array, start, end, min_periods)
+                mean_x = window_aggregations.roll_mean(x_array, start, end, min_periods)
+                mean_y = window_aggregations.roll_mean(y_array, start, end, min_periods)
+                count_x_y = window_aggregations.roll_sum(notna(x_array + y_array).astype(np.float64), start, end, 0)
+                result = (mean_x_y - mean_x * mean_y) * (count_x_y / (count_x_y - ddof))
+            return Series(result, index=x.index, name=x.name, copy=False)
+        return self._apply_pairwise(self._selected_obj, other, pairwise, cov_func, numeric_only)
+
+    def corr(self, other: DataFrame | Series | None=None, pairwise: bool | None=None, ddof: int=1, numeric_only: bool=False):
+        if self.step is not None:
+            raise NotImplementedError('step not implemented for corr')
+        self._validate_numeric_only('corr', numeric_only)
+        from pandas import Series
+
+        def corr_func(x, y):
+            x_array = self._prep_values(x)
+            y_array = self._prep_values(y)
+            window_indexer = self._get_window_indexer()
+            min_periods = self.min_periods if self.min_periods is not None else window_indexer.window_size
+            (start, end) = window_indexer.get_window_bounds(num_values=len(x_array), min_periods=min_periods, center=self.center, closed=self.closed, step=self.step)
+            self._check_window_bounds(start, end, len(x_array))
+            with np.errstate(all='ignore'):
+                mean_x_y = window_aggregations.roll_mean(x_array * y_array, start, end, min_periods)
+                mean_x = window_aggregations.roll_mean(x_array, start, end, min_periods)
+                mean_y = window_aggregations.roll_mean(y_array, start, end, min_periods)
+                count_x_y = window_aggregations.roll_sum(notna(x_array + y_array).astype(np.float64), start, end, 0)
+                x_var = window_aggregations.roll_var(x_array, start, end, min_periods, ddof)
+                y_var = window_aggregations.roll_var(y_array, start, end, min_periods, ddof)
+                numerator = (mean_x_y - mean_x * mean_y) * (count_x_y / (count_x_y - ddof))
+                denominator = (x_var * y_var) ** 0.5
+                result = numerator / denominator
+            return Series(result, index=x.index, name=x.name, copy=False)
+        return self._apply_pairwise(self._selected_obj, other, pairwise, corr_func, numeric_only)
+
+class Rolling(RollingAndExpandingMixin):
+    _attributes: list[str] = ['window', 'min_periods', 'center', 'win_type', 'on', 'closed', 'step', 'method']
+
+    def _validate(self) -> None:
+        super()._validate()
+        if (self.obj.empty or isinstance(self._on, (DatetimeIndex, TimedeltaIndex, PeriodIndex)) or (isinstance(self._on.dtype, ArrowDtype) and self._on.dtype.kind in 'mM')) and isinstance(self.window, (str, BaseOffset, timedelta)):
+            self._validate_datetimelike_monotonic()
+            try:
+                freq = to_offset(self.window)
+            except (TypeError, ValueError) as err:
+                raise ValueError(f'passed window {self.window} is not compatible with a datetimelike index') from err
+            if isinstance(self._on, PeriodIndex):
+                self._win_freq_i8 = freq.nanos / (self._on.freq.nanos / self._on.freq.n)
+            else:
+                try:
+                    unit = dtype_to_unit(self._on.dtype)
+                except TypeError:
+                    unit = 'ns'
+                self._win_freq_i8 = Timedelta(freq.nanos).as_unit(unit)._value
+            if self.min_periods is None:
+                self.min_periods = 1
+            if self.step is not None:
+                raise NotImplementedError('step is not supported with frequency windows')
+        elif isinstance(self.window, BaseIndexer):
+            pass
+        elif not is_integer(self.window) or self.window < 0:
+            raise ValueError('window must be an integer 0 or greater')
+
+    def _validate_datetimelike_monotonic(self) -> None:
+        if self._on.hasnans:
+            self._raise_monotonic_error('values must not have NaT')
+        if not (self._on.is_monotonic_increasing or self._on.is_monotonic_decreasing):
+            self._raise_monotonic_error('values must be monotonic')
+
+    def _raise_monotonic_error(self, msg: str):
+        on = self.on
+        if on is None:
+            on = 'index'
+        raise ValueError(f'{on} {msg}')
+
+    @doc(_shared_docs['aggregate'], see_also=dedent('\n        See Also\n        --------\n        Series.rolling : Calling object with Series data.\n        DataFrame.rolling : Calling object with DataFrame data.\n        '), examples=dedent('\n        Examples\n        --------\n        >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]})\n        >>> df\n           A  B  C\n        0  1  4  7\n        1  2  5  8\n        2  3  6  9\n\n        >>> df.rolling(2).sum()\n             A     B     C\n        0  NaN   NaN   NaN\n        1  3.0   9.0  15.0\n        2  5.0  11.0  17.0\n\n        >>> df.rolling(2).agg({"A": "sum", "B": "min"})\n             A    B\n        0  NaN  NaN\n        1  3.0  4.0\n        2  5.0  5.0\n        '), klass='Series/Dataframe', axis='')
+    def aggregate(self, func, *args, **kwargs):
+        return super().aggregate(func, *args, **kwargs)
+    agg = aggregate
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent('\n        >>> s = pd.Series([2, 3, np.nan, 10])\n        >>> s.rolling(2).count()\n        0    NaN\n        1    2.0\n        2    1.0\n        3    1.0\n        dtype: float64\n        >>> s.rolling(3).count()\n        0    NaN\n        1    NaN\n        2    2.0\n        3    2.0\n        dtype: float64\n        >>> s.rolling(4).count()\n        0    NaN\n        1    NaN\n        2    NaN\n        3    3.0\n        dtype: float64\n        ').replace('\n', '', 1), window_method='rolling', aggregation_description='count of non NaN observations', agg_method='count')
+    def count(self, numeric_only: bool=False):
+        return super().count(numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), window_apply_parameters, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent('        >>> ser = pd.Series([1, 6, 5, 4])\n        >>> ser.rolling(2).apply(lambda s: s.sum() - s.min())\n        0    NaN\n        1    6.0\n        2    6.0\n        3    5.0\n        dtype: float64\n        '), window_method='rolling', aggregation_description='custom aggregation function', agg_method='apply')
+    def apply(self, func: Callable[..., Any], raw: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None, args: tuple[Any, ...] | None=None, kwargs: dict[str, Any] | None=None):
+        return super().apply(func, raw=raw, engine=engine, engine_kwargs=engine_kwargs, args=args, kwargs=kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, window_agg_numba_parameters(), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent('\n        >>> s = pd.Series([1, 2, 3, 4, 5])\n        >>> s\n        0    1\n        1    2\n        2    3\n        3    4\n        4    5\n        dtype: int64\n\n        >>> s.rolling(3).sum()\n        0     NaN\n        1     NaN\n        2     6.0\n        3     9.0\n        4    12.0\n        dtype: float64\n\n        >>> s.rolling(3, center=True).sum()\n        0     NaN\n        1     6.0\n        2     9.0\n        3    12.0\n        4     NaN\n        dtype: float64\n\n        For DataFrame, each sum is computed column-wise.\n\n        >>> df = pd.DataFrame({{"A": s, "B": s ** 2}})\n        >>> df\n           A   B\n        0  1   1\n        1  2   4\n        2  3   9\n        3  4  16\n        4  5  25\n\n        >>> df.rolling(3).sum()\n              A     B\n        0   NaN   NaN\n        1   NaN   NaN\n        2   6.0  14.0\n        3   9.0  29.0\n        4  12.0  50.0\n        ').replace('\n', '', 1), window_method='rolling', aggregation_description='sum', agg_method='sum')
+    def sum(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().sum(numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, dedent('\n            *args : iterable, optional\n                Positional arguments passed into ``func``.\n\n            ').replace('\n', '', 1), window_agg_numba_parameters(), dedent('\n            **kwargs : mapping, optional\n                A dictionary of keyword arguments passed into ``func``.\n\n            ').replace('\n', '', 1), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent('        >>> ser = pd.Series([1, 2, 3, 4])\n        >>> ser.rolling(2).max()\n        0    NaN\n        1    2.0\n        2    3.0\n        3    4.0\n        dtype: float64\n        '), window_method='rolling', aggregation_description='maximum', agg_method='max')
+    def max(self, numeric_only: bool=False, *args, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None, **kwargs):
+        return super().max(numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, window_agg_numba_parameters(), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent('\n        Performing a rolling minimum with a window size of 3.\n\n        >>> s = pd.Series([4, 3, 5, 2, 6])\n        >>> s.rolling(3).min()\n        0    NaN\n        1    NaN\n        2    3.0\n        3    2.0\n        4    2.0\n        dtype: float64\n        ').replace('\n', '', 1), window_method='rolling', aggregation_description='minimum', agg_method='min')
+    def min(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().min(numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, window_agg_numba_parameters(), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent('\n        The below examples will show rolling mean calculations with window sizes of\n        two and three, respectively.\n\n        >>> s = pd.Series([1, 2, 3, 4])\n        >>> s.rolling(2).mean()\n        0    NaN\n        1    1.5\n        2    2.5\n        3    3.5\n        dtype: float64\n\n        >>> s.rolling(3).mean()\n        0    NaN\n        1    NaN\n        2    2.0\n        3    3.0\n        dtype: float64\n        ').replace('\n', '', 1), window_method='rolling', aggregation_description='mean', agg_method='mean')
+    def mean(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().mean(numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, window_agg_numba_parameters(), create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), numba_notes, create_section_header('Examples'), dedent('\n        Compute the rolling median of a series with a window size of 3.\n\n        >>> s = pd.Series([0, 1, 2, 3, 4])\n        >>> s.rolling(3).median()\n        0    NaN\n        1    NaN\n        2    1.0\n        3    2.0\n        4    3.0\n        dtype: float64\n        ').replace('\n', '', 1), window_method='rolling', aggregation_description='median', agg_method='median')
+    def median(self, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().median(numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n        ').replace('\n', '', 1), kwargs_numeric_only, window_agg_numba_parameters('1.4'), create_section_header('Returns'), template_returns, create_section_header('See Also'), 'numpy.std : Equivalent method for NumPy array.\n', template_see_also, create_section_header('Notes'), dedent('\n        The default ``ddof`` of 1 used in :meth:`Series.std` is different\n        than the default ``ddof`` of 0 in :func:`numpy.std`.\n\n        A minimum of one period is required for the rolling calculation.\n\n        ').replace('\n', '', 1), create_section_header('Examples'), dedent('\n        >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])\n        >>> s.rolling(3).std()\n        0         NaN\n        1         NaN\n        2    0.577350\n        3    1.000000\n        4    1.000000\n        5    1.154701\n        6    0.000000\n        dtype: float64\n        ').replace('\n', '', 1), window_method='rolling', aggregation_description='standard deviation', agg_method='std')
+    def std(self, ddof: int=1, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().std(ddof=ddof, numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n        ').replace('\n', '', 1), kwargs_numeric_only, window_agg_numba_parameters('1.4'), create_section_header('Returns'), template_returns, create_section_header('See Also'), 'numpy.var : Equivalent method for NumPy array.\n', template_see_also, create_section_header('Notes'), dedent('\n        The default ``ddof`` of 1 used in :meth:`Series.var` is different\n        than the default ``ddof`` of 0 in :func:`numpy.var`.\n\n        A minimum of one period is required for the rolling calculation.\n\n        ').replace('\n', '', 1), create_section_header('Examples'), dedent('\n        >>> s = pd.Series([5, 5, 6, 7, 5, 5, 5])\n        >>> s.rolling(3).var()\n        0         NaN\n        1         NaN\n        2    0.333333\n        3    1.000000\n        4    1.000000\n        5    1.333333\n        6    0.000000\n        dtype: float64\n        ').replace('\n', '', 1), window_method='rolling', aggregation_description='variance', agg_method='var')
+    def var(self, ddof: int=1, numeric_only: bool=False, engine: Literal['cython', 'numba'] | None=None, engine_kwargs: dict[str, bool] | None=None):
+        return super().var(ddof=ddof, numeric_only=numeric_only, engine=engine, engine_kwargs=engine_kwargs)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), 'scipy.stats.skew : Third moment of a probability density.\n', template_see_also, create_section_header('Notes'), dedent('\n        A minimum of three periods is required for the rolling calculation.\n\n        '), create_section_header('Examples'), dedent('        >>> ser = pd.Series([1, 5, 2, 7, 15, 6])\n        >>> ser.rolling(3).skew().round(6)\n        0         NaN\n        1         NaN\n        2    1.293343\n        3   -0.585583\n        4    0.670284\n        5    1.652317\n        dtype: float64\n        '), window_method='rolling', aggregation_description='unbiased skewness', agg_method='skew')
+    def skew(self, numeric_only: bool=False):
+        return super().skew(numeric_only=numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n        ').replace('\n', '', 1), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Notes'), 'A minimum of one period is required for the calculation.\n\n', create_section_header('Examples'), dedent('\n        >>> s = pd.Series([0, 1, 2, 3])\n        >>> s.rolling(2, min_periods=1).sem()\n        0         NaN\n        1    0.707107\n        2    0.707107\n        3    0.707107\n        dtype: float64\n        ').replace('\n', '', 1), window_method='rolling', aggregation_description='standard error of mean', agg_method='sem')
+    def sem(self, ddof: int=1, numeric_only: bool=False):
+        self._validate_numeric_only('sem', numeric_only)
+        return self.std(numeric_only=numeric_only) / (self.count(numeric_only) - ddof).pow(0.5)
+
+    @doc(template_header, create_section_header('Parameters'), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), 'scipy.stats.kurtosis : Reference SciPy method.\n', template_see_also, create_section_header('Notes'), 'A minimum of four periods is required for the calculation.\n\n', create_section_header('Examples'), dedent('\n        The example below will show a rolling calculation with a window size of\n        four matching the equivalent function call using `scipy.stats`.\n\n        >>> arr = [1, 2, 3, 4, 999]\n        >>> import scipy.stats\n        >>> print(f"{{scipy.stats.kurtosis(arr[:-1], bias=False):.6f}}")\n        -1.200000\n        >>> print(f"{{scipy.stats.kurtosis(arr[1:], bias=False):.6f}}")\n        3.999946\n        >>> s = pd.Series(arr)\n        >>> s.rolling(4).kurt()\n        0         NaN\n        1         NaN\n        2         NaN\n        3   -1.200000\n        4    3.999946\n        dtype: float64\n        ').replace('\n', '', 1), window_method='rolling', aggregation_description="Fisher's definition of kurtosis without bias", agg_method='kurt')
+    def kurt(self, numeric_only: bool=False):
+        return super().kurt(numeric_only=numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), dedent("\n        q : float\n            Quantile to compute. 0 <= quantile <= 1.\n\n            .. deprecated:: 2.1.0\n                This was renamed from 'quantile' to 'q' in version 2.1.0.\n        interpolation : {{'linear', 'lower', 'higher', 'midpoint', 'nearest'}}\n            This optional parameter specifies the interpolation method to use,\n            when the desired quantile lies between two data points `i` and `j`:\n\n                * linear: `i + (j - i) * fraction`, where `fraction` is the\n                  fractional part of the index surrounded by `i` and `j`.\n                * lower: `i`.\n                * higher: `j`.\n                * nearest: `i` or `j` whichever is nearest.\n                * midpoint: (`i` + `j`) / 2.\n        ").replace('\n', '', 1), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent("\n        >>> s = pd.Series([1, 2, 3, 4])\n        >>> s.rolling(2).quantile(.4, interpolation='lower')\n        0    NaN\n        1    1.0\n        2    2.0\n        3    3.0\n        dtype: float64\n\n        >>> s.rolling(2).quantile(.4, interpolation='midpoint')\n        0    NaN\n        1    1.5\n        2    2.5\n        3    3.5\n        dtype: float64\n        ").replace('\n', '', 1), window_method='rolling', aggregation_description='quantile', agg_method='quantile')
+    def quantile(self, q: float, interpolation: QuantileInterpolation='linear', numeric_only: bool=False):
+        return super().quantile(q=q, interpolation=interpolation, numeric_only=numeric_only)
+
+    @doc(template_header, '.. versionadded:: 1.4.0 \n\n', create_section_header('Parameters'), dedent("\n        method : {{'average', 'min', 'max'}}, default 'average'\n            How to rank the group of records that have the same value (i.e. ties):\n\n            * average: average rank of the group\n            * min: lowest rank in the group\n            * max: highest rank in the group\n\n        ascending : bool, default True\n            Whether or not the elements should be ranked in ascending order.\n        pct : bool, default False\n            Whether or not to display the returned rankings in percentile\n            form.\n        ").replace('\n', '', 1), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent('\n        >>> s = pd.Series([1, 4, 2, 3, 5, 3])\n        >>> s.rolling(3).rank()\n        0    NaN\n        1    NaN\n        2    2.0\n        3    2.0\n        4    3.0\n        5    1.5\n        dtype: float64\n\n        >>> s.rolling(3).rank(method="max")\n        0    NaN\n        1    NaN\n        2    2.0\n        3    2.0\n        4    3.0\n        5    2.0\n        dtype: float64\n\n        >>> s.rolling(3).rank(method="min")\n        0    NaN\n        1    NaN\n        2    2.0\n        3    2.0\n        4    3.0\n        5    1.0\n        dtype: float64\n        ').replace('\n', '', 1), window_method='rolling', aggregation_description='rank', agg_method='rank')
+    def rank(self, method: WindowingRankType='average', ascending: bool=True, pct: bool=False, numeric_only: bool=False):
+        return super().rank(method=method, ascending=ascending, pct=pct, numeric_only=numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        other : Series or DataFrame, optional\n            If not supplied then will default to self and produce pairwise\n            output.\n        pairwise : bool, default None\n            If False then only matching columns between self and other will be\n            used and the output will be a DataFrame.\n            If True then all pairwise combinations will be calculated and the\n            output will be a MultiIndexed DataFrame in the case of DataFrame\n            inputs. In the case of missing elements, only complete pairwise\n            observations will be used.\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n        ').replace('\n', '', 1), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), template_see_also, create_section_header('Examples'), dedent('        >>> ser1 = pd.Series([1, 2, 3, 4])\n        >>> ser2 = pd.Series([1, 4, 5, 8])\n        >>> ser1.rolling(2).cov(ser2)\n        0    NaN\n        1    1.5\n        2    0.5\n        3    1.5\n        dtype: float64\n        '), window_method='rolling', aggregation_description='sample covariance', agg_method='cov')
+    def cov(self, other: DataFrame | Series | None=None, pairwise: bool | None=None, ddof: int=1, numeric_only: bool=False):
+        return super().cov(other=other, pairwise=pairwise, ddof=ddof, numeric_only=numeric_only)
+
+    @doc(template_header, create_section_header('Parameters'), dedent('\n        other : Series or DataFrame, optional\n            If not supplied then will default to self and produce pairwise\n            output.\n        pairwise : bool, default None\n            If False then only matching columns between self and other will be\n            used and the output will be a DataFrame.\n            If True then all pairwise combinations will be calculated and the\n            output will be a MultiIndexed DataFrame in the case of DataFrame\n            inputs. In the case of missing elements, only complete pairwise\n            observations will be used.\n        ddof : int, default 1\n            Delta Degrees of Freedom.  The divisor used in calculations\n            is ``N - ddof``, where ``N`` represents the number of elements.\n        ').replace('\n', '', 1), kwargs_numeric_only, create_section_header('Returns'), template_returns, create_section_header('See Also'), dedent("\n        cov : Similar method to calculate covariance.\n        numpy.corrcoef : NumPy Pearson's correlation calculation.\n        ").replace('\n', '', 1), template_see_also, create_section_header('Notes'), dedent("\n        This function uses Pearson's definition of correlation\n        (https://en.wikipedia.org/wiki/Pearson_correlation_coefficient).\n\n        When `other` is not specified, the output will be self correlation (e.g.\n        all 1's), except for :class:`~pandas.DataFrame` inputs with `pairwise`\n        set to `True`.\n\n        Function will return ``NaN`` for correlations of equal valued sequences;\n        this is the result of a 0/0 division error.\n\n        When `pairwise` is set to `False`, only matching columns between `self` and\n        `other` will be used.\n\n        When `pairwise` is set to `True`, the output will be a MultiIndex DataFrame\n        with the original index on the first level, and the `other` DataFrame\n        columns on the second level.\n\n        In the case of missing elements, only complete pairwise observations\n        will be used.\n\n        ").replace('\n', '', 1), create_section_header('Examples'), dedent("\n        The below example shows a rolling calculation with a window size of\n        four matching the equivalent function call using :meth:`numpy.corrcoef`.\n\n        >>> v1 = [3, 3, 3, 5, 8]\n        >>> v2 = [3, 4, 4, 4, 8]\n        >>> np.corrcoef(v1[:-1], v2[:-1])\n        array([[1.        , 0.33333333],\n               [0.33333333, 1.        ]])\n        >>> np.corrcoef(v1[1:], v2[1:])\n        array([[1.       , 0.9169493],\n               [0.9169493, 1.       ]])\n        >>> s1 = pd.Series(v1)\n        >>> s2 = pd.Series(v2)\n        >>> s1.rolling(4).corr(s2)\n        0         NaN\n        1         NaN\n        2         NaN\n        3    0.333333\n        4    0.916949\n        dtype: float64\n\n        The below example shows a similar rolling calculation on a\n        DataFrame using the pairwise option.\n\n        >>> matrix = np.array([[51., 35.],\n        ...                    [49., 30.],\n        ...                    [47., 32.],\n        ...                    [46., 31.],\n        ...                    [50., 36.]])\n        >>> np.corrcoef(matrix[:-1, 0], matrix[:-1, 1])\n        array([[1.       , 0.6263001],\n               [0.6263001, 1.       ]])\n        >>> np.corrcoef(matrix[1:, 0], matrix[1:, 1])\n        array([[1.        , 0.55536811],\n               [0.55536811, 1.        ]])\n        >>> df = pd.DataFrame(matrix, columns=['X', 'Y'])\n        >>> df\n              X     Y\n        0  51.0  35.0\n        1  49.0  30.0\n        2  47.0  32.0\n        3  46.0  31.0\n        4  50.0  36.0\n        >>> df.rolling(4).corr(pairwise=True)\n                    X         Y\n        0 X       NaN       NaN\n          Y       NaN       NaN\n        1 X       NaN       NaN\n          Y       NaN       NaN\n        2 X       NaN       NaN\n          Y       NaN       NaN\n        3 X  1.000000  0.626300\n          Y  0.626300  1.000000\n        4 X  1.000000  0.555368\n          Y  0.555368  1.000000\n        ").replace('\n', '', 1), window_method='rolling', aggregation_description='correlation', agg_method='corr')
+    def corr(self, other: DataFrame | Series | None=None, pairwise: bool | None=None, ddof: int=1, numeric_only: bool=False):
+        return super().corr(other=other, pairwise=pairwise, ddof=ddof, numeric_only=numeric_only)
+Rolling.__doc__ = Window.__doc__
+
+class RollingGroupby(BaseWindowGroupby, Rolling):
+    _attributes = Rolling._attributes + BaseWindowGroupby._attributes
+
+    def _get_window_indexer(self) -> GroupbyIndexer:
+        rolling_indexer: type[BaseIndexer]
+        indexer_kwargs: dict[str, Any] | None = None
+        index_array = self._index_array
+        if isinstance(self.window, BaseIndexer):
+            rolling_indexer = type(self.window)
+            indexer_kwargs = self.window.__dict__.copy()
+            assert isinstance(indexer_kwargs, dict)
+            indexer_kwargs.pop('index_array', None)
+            window = self.window
+        elif self._win_freq_i8 is not None:
+            rolling_indexer = VariableWindowIndexer
+            window = self._win_freq_i8
+        else:
+            rolling_indexer = FixedWindowIndexer
+            window = self.window
+        window_indexer = GroupbyIndexer(index_array=index_array, window_size=window, groupby_indices=self._grouper.indices, window_indexer=rolling_indexer, indexer_kwargs=indexer_kwargs)
+        return window_indexer
+
+    def _validate_datetimelike_monotonic(self) -> None:
+        if self._on.hasnans:
+            self._raise_monotonic_error('values must not have NaT')
+        for group_indices in self._grouper.indices.values():
+            group_on = self._on.take(group_indices)
+            if not (group_on.is_monotonic_increasing or group_on.is_monotonic_decreasing):
+                on = 'index' if self.on is None else self.on
+                raise ValueError(f'Each group within {on} must be monotonic. Sort the values in {on} first.')
+
+# File: pandas-main/pandas/errors/__init__.py
+""""""
+from __future__ import annotations
+import ctypes
+from pandas._config.config import OptionError
+from pandas._libs.tslibs import OutOfBoundsDatetime, OutOfBoundsTimedelta
+from pandas.util.version import InvalidVersion
+
+class IntCastingNaNError(ValueError):
+
+class NullFrequencyError(ValueError):
+
+class PerformanceWarning(Warning):
+
+class UnsupportedFunctionCall(ValueError):
+
+class UnsortedIndexError(KeyError):
+
+class ParserError(ValueError):
+
+class DtypeWarning(Warning):
+
+class EmptyDataError(ValueError):
+
+class ParserWarning(Warning):
+
+class MergeError(ValueError):
+
+class AbstractMethodError(NotImplementedError):
+
+    def __init__(self, class_instance, methodtype: str='method') -> None:
+        types = {'method', 'classmethod', 'staticmethod', 'property'}
+        if methodtype not in types:
+            raise ValueError(f'methodtype must be one of {methodtype}, got {types} instead.')
+        self.methodtype = methodtype
+        self.class_instance = class_instance
+
+    def __str__(self) -> str:
+        if self.methodtype == 'classmethod':
+            name = self.class_instance.__name__
+        else:
+            name = type(self.class_instance).__name__
+        return f'This {self.methodtype} must be defined in the concrete class {name}'
+
+class NumbaUtilError(Exception):
+
+class DuplicateLabelError(ValueError):
+
+class InvalidIndexError(Exception):
+
+class DataError(Exception):
+
+class SpecificationError(Exception):
+
+class ChainedAssignmentError(Warning):
+
+class NumExprClobberingError(NameError):
+
+class UndefinedVariableError(NameError):
+
+    def __init__(self, name: str, is_local: bool | None=None) -> None:
+        base_msg = f'{name!r} is not defined'
+        if is_local:
+            msg = f'local variable {base_msg}'
+        else:
+            msg = f'name {base_msg}'
+        super().__init__(msg)
+
+class IndexingError(Exception):
+
+class PyperclipException(RuntimeError):
+
+class PyperclipWindowsException(PyperclipException):
+
+    def __init__(self, message: str) -> None:
+        message += f' ({ctypes.WinError()})'
+        super().__init__(message)
+
+class CSSWarning(UserWarning):
+
+class PossibleDataLossError(Exception):
+
+class ClosedFileError(Exception):
+
+class IncompatibilityWarning(Warning):
+
+class AttributeConflictWarning(Warning):
+
+class DatabaseError(OSError):
+
+class PossiblePrecisionLoss(Warning):
+
+class ValueLabelTypeMismatch(Warning):
+
+class InvalidColumnName(Warning):
+
+class CategoricalConversionWarning(Warning):
+
+class LossySetitemError(Exception):
+
+class NoBufferPresent(Exception):
+
+class InvalidComparison(Exception):
+__all__ = ['AbstractMethodError', 'AttributeConflictWarning', 'CategoricalConversionWarning', 'ChainedAssignmentError', 'ClosedFileError', 'CSSWarning', 'DatabaseError', 'DataError', 'DtypeWarning', 'DuplicateLabelError', 'EmptyDataError', 'IncompatibilityWarning', 'IntCastingNaNError', 'InvalidColumnName', 'InvalidComparison', 'InvalidIndexError', 'InvalidVersion', 'IndexingError', 'LossySetitemError', 'MergeError', 'NoBufferPresent', 'NullFrequencyError', 'NumbaUtilError', 'NumExprClobberingError', 'OptionError', 'OutOfBoundsDatetime', 'OutOfBoundsTimedelta', 'ParserError', 'ParserWarning', 'PerformanceWarning', 'PossibleDataLossError', 'PossiblePrecisionLoss', 'PyperclipException', 'PyperclipWindowsException', 'SpecificationError', 'UndefinedVariableError', 'UnsortedIndexError', 'UnsupportedFunctionCall', 'ValueLabelTypeMismatch']
+
+# File: pandas-main/pandas/errors/cow.py
+_chained_assignment_msg = "A value is trying to be set on a copy of a DataFrame or Series through chained assignment.\nWhen using the Copy-on-Write mode, such chained assignment never works to update the original DataFrame or Series, because the intermediate object on which we are setting values always behaves as a copy.\n\nTry using '.loc[row_indexer, col_indexer] = value' instead, to perform the assignment in a single step.\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/copy_on_write.html"
+_chained_assignment_method_msg = "A value is trying to be set on a copy of a DataFrame or Series through chained assignment using an inplace method.\nWhen using the Copy-on-Write mode, such inplace method never works to update the original DataFrame or Series, because the intermediate object on which we are setting values always behaves as a copy.\n\nFor example, when doing 'df[col].method(value, inplace=True)', try using 'df.method({col: value}, inplace=True)' instead, to perform the operation inplace on the original object.\n\n"
+
+# File: pandas-main/pandas/io/_util.py
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas.compat._optional import import_optional_dependency
+import pandas as pd
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+def _arrow_dtype_mapping() -> dict:
+    pa = import_optional_dependency('pyarrow')
+    return {pa.int8(): pd.Int8Dtype(), pa.int16(): pd.Int16Dtype(), pa.int32(): pd.Int32Dtype(), pa.int64(): pd.Int64Dtype(), pa.uint8(): pd.UInt8Dtype(), pa.uint16(): pd.UInt16Dtype(), pa.uint32(): pd.UInt32Dtype(), pa.uint64(): pd.UInt64Dtype(), pa.bool_(): pd.BooleanDtype(), pa.string(): pd.StringDtype(), pa.float32(): pd.Float32Dtype(), pa.float64(): pd.Float64Dtype(), pa.string(): pd.StringDtype(), pa.large_string(): pd.StringDtype()}
+
+def arrow_string_types_mapper() -> Callable:
+    pa = import_optional_dependency('pyarrow')
+    return {pa.string(): pd.StringDtype(na_value=np.nan), pa.large_string(): pd.StringDtype(na_value=np.nan)}.get
+
+# File: pandas-main/pandas/io/api.py
+""""""
+from pandas.io.clipboards import read_clipboard
+from pandas.io.excel import ExcelFile, ExcelWriter, read_excel
+from pandas.io.feather_format import read_feather
+from pandas.io.html import read_html
+from pandas.io.json import read_json
+from pandas.io.orc import read_orc
+from pandas.io.parquet import read_parquet
+from pandas.io.parsers import read_csv, read_fwf, read_table
+from pandas.io.pickle import read_pickle, to_pickle
+from pandas.io.pytables import HDFStore, read_hdf
+from pandas.io.sas import read_sas
+from pandas.io.spss import read_spss
+from pandas.io.sql import read_sql, read_sql_query, read_sql_table
+from pandas.io.stata import read_stata
+from pandas.io.xml import read_xml
+__all__ = ['ExcelFile', 'ExcelWriter', 'HDFStore', 'read_clipboard', 'read_csv', 'read_excel', 'read_feather', 'read_fwf', 'read_hdf', 'read_html', 'read_json', 'read_orc', 'read_parquet', 'read_pickle', 'read_sas', 'read_spss', 'read_sql', 'read_sql_query', 'read_sql_table', 'read_stata', 'read_table', 'read_xml', 'to_pickle']
+
+# File: pandas-main/pandas/io/clipboard/__init__.py
+""""""
+__version__ = '1.8.2'
+import contextlib
+import ctypes
+from ctypes import c_size_t, c_wchar, c_wchar_p, get_errno, sizeof
+import os
+import platform
+from shutil import which as _executable_exists
+import subprocess
+import time
+import warnings
+from pandas.errors import PyperclipException, PyperclipWindowsException
+from pandas.util._exceptions import find_stack_level
+HAS_DISPLAY = os.getenv('DISPLAY')
+EXCEPT_MSG = '\n    Pyperclip could not find a copy/paste mechanism for your system.\n    For more information, please visit\n    https://pyperclip.readthedocs.io/en/latest/index.html#not-implemented-error\n    '
+ENCODING = 'utf-8'
+
+class PyperclipTimeoutException(PyperclipException):
+    pass
+
+def _stringifyText(text) -> str:
+    acceptedTypes = (str, int, float, bool)
+    if not isinstance(text, acceptedTypes):
+        raise PyperclipException(f'only str, int, float, and bool values can be copied to the clipboard, not {type(text).__name__}')
+    return str(text)
+
+def init_osx_pbcopy_clipboard():
+
+    def copy_osx_pbcopy(text):
+        text = _stringifyText(text)
+        with subprocess.Popen(['pbcopy', 'w'], stdin=subprocess.PIPE, close_fds=True) as p:
+            p.communicate(input=text.encode(ENCODING))
+
+    def paste_osx_pbcopy():
+        with subprocess.Popen(['pbpaste', 'r'], stdout=subprocess.PIPE, close_fds=True) as p:
+            stdout = p.communicate()[0]
+        return stdout.decode(ENCODING)
+    return (copy_osx_pbcopy, paste_osx_pbcopy)
+
+def init_osx_pyobjc_clipboard():
+
+    def copy_osx_pyobjc(text):
+        text = _stringifyText(text)
+        newStr = Foundation.NSString.stringWithString_(text).nsstring()
+        newData = newStr.dataUsingEncoding_(Foundation.NSUTF8StringEncoding)
+        board = AppKit.NSPasteboard.generalPasteboard()
+        board.declareTypes_owner_([AppKit.NSStringPboardType], None)
+        board.setData_forType_(newData, AppKit.NSStringPboardType)
+
+    def paste_osx_pyobjc():
+        board = AppKit.NSPasteboard.generalPasteboard()
+        content = board.stringForType_(AppKit.NSStringPboardType)
+        return content
+    return (copy_osx_pyobjc, paste_osx_pyobjc)
+
+def init_qt_clipboard():
+    global QApplication
+    try:
+        from qtpy.QtWidgets import QApplication
+    except ImportError:
+        try:
+            from PyQt5.QtWidgets import QApplication
+        except ImportError:
+            from PyQt4.QtGui import QApplication
+    app = QApplication.instance()
+    if app is None:
+        app = QApplication([])
+
+    def copy_qt(text):
+        text = _stringifyText(text)
+        cb = app.clipboard()
+        cb.setText(text)
+
+    def paste_qt() -> str:
+        cb = app.clipboard()
+        return str(cb.text())
+    return (copy_qt, paste_qt)
+
+def init_xclip_clipboard():
+    DEFAULT_SELECTION = 'c'
+    PRIMARY_SELECTION = 'p'
+
+    def copy_xclip(text, primary=False):
+        text = _stringifyText(text)
+        selection = DEFAULT_SELECTION
+        if primary:
+            selection = PRIMARY_SELECTION
+        with subprocess.Popen(['xclip', '-selection', selection], stdin=subprocess.PIPE, close_fds=True) as p:
+            p.communicate(input=text.encode(ENCODING))
+
+    def paste_xclip(primary=False):
+        selection = DEFAULT_SELECTION
+        if primary:
+            selection = PRIMARY_SELECTION
+        with subprocess.Popen(['xclip', '-selection', selection, '-o'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True) as p:
+            stdout = p.communicate()[0]
+        return stdout.decode(ENCODING)
+    return (copy_xclip, paste_xclip)
+
+def init_xsel_clipboard():
+    DEFAULT_SELECTION = '-b'
+    PRIMARY_SELECTION = '-p'
+
+    def copy_xsel(text, primary=False):
+        text = _stringifyText(text)
+        selection_flag = DEFAULT_SELECTION
+        if primary:
+            selection_flag = PRIMARY_SELECTION
+        with subprocess.Popen(['xsel', selection_flag, '-i'], stdin=subprocess.PIPE, close_fds=True) as p:
+            p.communicate(input=text.encode(ENCODING))
+
+    def paste_xsel(primary=False):
+        selection_flag = DEFAULT_SELECTION
+        if primary:
+            selection_flag = PRIMARY_SELECTION
+        with subprocess.Popen(['xsel', selection_flag, '-o'], stdout=subprocess.PIPE, close_fds=True) as p:
+            stdout = p.communicate()[0]
+        return stdout.decode(ENCODING)
+    return (copy_xsel, paste_xsel)
+
+def init_wl_clipboard():
+    PRIMARY_SELECTION = '-p'
+
+    def copy_wl(text, primary=False):
+        text = _stringifyText(text)
+        args = ['wl-copy']
+        if primary:
+            args.append(PRIMARY_SELECTION)
+        if not text:
+            args.append('--clear')
+            subprocess.check_call(args, close_fds=True)
+        else:
+            p = subprocess.Popen(args, stdin=subprocess.PIPE, close_fds=True)
+            p.communicate(input=text.encode(ENCODING))
+
+    def paste_wl(primary=False):
+        args = ['wl-paste', '-n']
+        if primary:
+            args.append(PRIMARY_SELECTION)
+        p = subprocess.Popen(args, stdout=subprocess.PIPE, close_fds=True)
+        (stdout, _stderr) = p.communicate()
+        return stdout.decode(ENCODING)
+    return (copy_wl, paste_wl)
+
+def init_klipper_clipboard():
+
+    def copy_klipper(text):
+        text = _stringifyText(text)
+        with subprocess.Popen(['qdbus', 'org.kde.klipper', '/klipper', 'setClipboardContents', text.encode(ENCODING)], stdin=subprocess.PIPE, close_fds=True) as p:
+            p.communicate(input=None)
+
+    def paste_klipper():
+        with subprocess.Popen(['qdbus', 'org.kde.klipper', '/klipper', 'getClipboardContents'], stdout=subprocess.PIPE, close_fds=True) as p:
+            stdout = p.communicate()[0]
+        clipboardContents = stdout.decode(ENCODING)
+        assert len(clipboardContents) > 0
+        assert clipboardContents.endswith('\n')
+        if clipboardContents.endswith('\n'):
+            clipboardContents = clipboardContents[:-1]
+        return clipboardContents
+    return (copy_klipper, paste_klipper)
+
+def init_dev_clipboard_clipboard():
+
+    def copy_dev_clipboard(text):
+        text = _stringifyText(text)
+        if text == '':
+            warnings.warn('Pyperclip cannot copy a blank string to the clipboard on Cygwin. This is effectively a no-op.', stacklevel=find_stack_level())
+        if '\r' in text:
+            warnings.warn('Pyperclip cannot handle \\r characters on Cygwin.', stacklevel=find_stack_level())
+        with open('/dev/clipboard', 'w', encoding='utf-8') as fd:
+            fd.write(text)
+
+    def paste_dev_clipboard() -> str:
+        with open('/dev/clipboard', encoding='utf-8') as fd:
+            content = fd.read()
+        return content
+    return (copy_dev_clipboard, paste_dev_clipboard)
+
+def init_no_clipboard():
+
+    class ClipboardUnavailable:
+
+        def __call__(self, *args, **kwargs):
+            raise PyperclipException(EXCEPT_MSG)
+
+        def __bool__(self) -> bool:
+            return False
+    return (ClipboardUnavailable(), ClipboardUnavailable())
+
+class CheckedCall:
+
+    def __init__(self, f) -> None:
+        super().__setattr__('f', f)
+
+    def __call__(self, *args):
+        ret = self.f(*args)
+        if not ret and get_errno():
+            raise PyperclipWindowsException('Error calling ' + self.f.__name__)
+        return ret
+
+    def __setattr__(self, key, value):
+        setattr(self.f, key, value)
+
+def init_windows_clipboard():
+    global HGLOBAL, LPVOID, DWORD, LPCSTR, INT
+    global HWND, HINSTANCE, HMENU, BOOL, UINT, HANDLE
+    from ctypes.wintypes import BOOL, DWORD, HANDLE, HGLOBAL, HINSTANCE, HMENU, HWND, INT, LPCSTR, LPVOID, UINT
+    windll = ctypes.windll
+    msvcrt = ctypes.CDLL('msvcrt')
+    safeCreateWindowExA = CheckedCall(windll.user32.CreateWindowExA)
+    safeCreateWindowExA.argtypes = [DWORD, LPCSTR, LPCSTR, DWORD, INT, INT, INT, INT, HWND, HMENU, HINSTANCE, LPVOID]
+    safeCreateWindowExA.restype = HWND
+    safeDestroyWindow = CheckedCall(windll.user32.DestroyWindow)
+    safeDestroyWindow.argtypes = [HWND]
+    safeDestroyWindow.restype = BOOL
+    OpenClipboard = windll.user32.OpenClipboard
+    OpenClipboard.argtypes = [HWND]
+    OpenClipboard.restype = BOOL
+    safeCloseClipboard = CheckedCall(windll.user32.CloseClipboard)
+    safeCloseClipboard.argtypes = []
+    safeCloseClipboard.restype = BOOL
+    safeEmptyClipboard = CheckedCall(windll.user32.EmptyClipboard)
+    safeEmptyClipboard.argtypes = []
+    safeEmptyClipboard.restype = BOOL
+    safeGetClipboardData = CheckedCall(windll.user32.GetClipboardData)
+    safeGetClipboardData.argtypes = [UINT]
+    safeGetClipboardData.restype = HANDLE
+    safeSetClipboardData = CheckedCall(windll.user32.SetClipboardData)
+    safeSetClipboardData.argtypes = [UINT, HANDLE]
+    safeSetClipboardData.restype = HANDLE
+    safeGlobalAlloc = CheckedCall(windll.kernel32.GlobalAlloc)
+    safeGlobalAlloc.argtypes = [UINT, c_size_t]
+    safeGlobalAlloc.restype = HGLOBAL
+    safeGlobalLock = CheckedCall(windll.kernel32.GlobalLock)
+    safeGlobalLock.argtypes = [HGLOBAL]
+    safeGlobalLock.restype = LPVOID
+    safeGlobalUnlock = CheckedCall(windll.kernel32.GlobalUnlock)
+    safeGlobalUnlock.argtypes = [HGLOBAL]
+    safeGlobalUnlock.restype = BOOL
+    wcslen = CheckedCall(msvcrt.wcslen)
+    wcslen.argtypes = [c_wchar_p]
+    wcslen.restype = UINT
+    GMEM_MOVEABLE = 2
+    CF_UNICODETEXT = 13
+
+    @contextlib.contextmanager
+    def window():
+        hwnd = safeCreateWindowExA(0, b'STATIC', None, 0, 0, 0, 0, 0, None, None, None, None)
+        try:
+            yield hwnd
+        finally:
+            safeDestroyWindow(hwnd)
+
+    @contextlib.contextmanager
+    def clipboard(hwnd):
+        t = time.time() + 0.5
+        success = False
+        while time.time() < t:
+            success = OpenClipboard(hwnd)
+            if success:
+                break
+            time.sleep(0.01)
+        if not success:
+            raise PyperclipWindowsException('Error calling OpenClipboard')
+        try:
+            yield
+        finally:
+            safeCloseClipboard()
+
+    def copy_windows(text):
+        text = _stringifyText(text)
+        with window() as hwnd:
+            with clipboard(hwnd):
+                safeEmptyClipboard()
+                if text:
+                    count = wcslen(text) + 1
+                    handle = safeGlobalAlloc(GMEM_MOVEABLE, count * sizeof(c_wchar))
+                    locked_handle = safeGlobalLock(handle)
+                    ctypes.memmove(c_wchar_p(locked_handle), c_wchar_p(text), count * sizeof(c_wchar))
+                    safeGlobalUnlock(handle)
+                    safeSetClipboardData(CF_UNICODETEXT, handle)
+
+    def paste_windows():
+        with clipboard(None):
+            handle = safeGetClipboardData(CF_UNICODETEXT)
+            if not handle:
+                return ''
+            return c_wchar_p(handle).value
+    return (copy_windows, paste_windows)
+
+def init_wsl_clipboard():
+
+    def copy_wsl(text):
+        text = _stringifyText(text)
+        with subprocess.Popen(['clip.exe'], stdin=subprocess.PIPE, close_fds=True) as p:
+            p.communicate(input=text.encode(ENCODING))
+
+    def paste_wsl():
+        with subprocess.Popen(['powershell.exe', '-command', 'Get-Clipboard'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True) as p:
+            stdout = p.communicate()[0]
+        return stdout[:-2].decode(ENCODING)
+    return (copy_wsl, paste_wsl)
+
+def determine_clipboard():
+    global Foundation, AppKit, qtpy, PyQt4, PyQt5
+    if 'cygwin' in platform.system().lower():
+        if os.path.exists('/dev/clipboard'):
+            warnings.warn("Pyperclip's support for Cygwin is not perfect, see https://github.com/asweigart/pyperclip/issues/55", stacklevel=find_stack_level())
+            return init_dev_clipboard_clipboard()
+    elif os.name == 'nt' or platform.system() == 'Windows':
+        return init_windows_clipboard()
+    if platform.system() == 'Linux':
+        if _executable_exists('wslconfig.exe'):
+            return init_wsl_clipboard()
+    if os.name == 'mac' or platform.system() == 'Darwin':
+        try:
+            import AppKit
+            import Foundation
+        except ImportError:
+            return init_osx_pbcopy_clipboard()
+        else:
+            return init_osx_pyobjc_clipboard()
+    if HAS_DISPLAY:
+        if os.environ.get('WAYLAND_DISPLAY') and _executable_exists('wl-copy'):
+            return init_wl_clipboard()
+        if _executable_exists('xsel'):
+            return init_xsel_clipboard()
+        if _executable_exists('xclip'):
+            return init_xclip_clipboard()
+        if _executable_exists('klipper') and _executable_exists('qdbus'):
+            return init_klipper_clipboard()
+        try:
+            import qtpy
+        except ImportError:
+            try:
+                import PyQt5
+            except ImportError:
+                try:
+                    import PyQt4
+                except ImportError:
+                    pass
+                else:
+                    return init_qt_clipboard()
+            else:
+                return init_qt_clipboard()
+        else:
+            return init_qt_clipboard()
+    return init_no_clipboard()
+
+def set_clipboard(clipboard):
+    global copy, paste
+    clipboard_types = {'pbcopy': init_osx_pbcopy_clipboard, 'pyobjc': init_osx_pyobjc_clipboard, 'qt': init_qt_clipboard, 'xclip': init_xclip_clipboard, 'xsel': init_xsel_clipboard, 'wl-clipboard': init_wl_clipboard, 'klipper': init_klipper_clipboard, 'windows': init_windows_clipboard, 'no': init_no_clipboard}
+    if clipboard not in clipboard_types:
+        allowed_clipboard_types = [repr(_) for _ in clipboard_types]
+        raise ValueError(f"Argument must be one of {', '.join(allowed_clipboard_types)}")
+    (copy, paste) = clipboard_types[clipboard]()
+
+def lazy_load_stub_copy(text):
+    global copy, paste
+    (copy, paste) = determine_clipboard()
+    return copy(text)
+
+def lazy_load_stub_paste():
+    global copy, paste
+    (copy, paste) = determine_clipboard()
+    return paste()
+
+def is_available() -> bool:
+    return copy != lazy_load_stub_copy and paste != lazy_load_stub_paste
+(copy, paste) = (lazy_load_stub_copy, lazy_load_stub_paste)
+
+def waitForPaste(timeout=None):
+    startTime = time.time()
+    while True:
+        clipboardText = paste()
+        if clipboardText != '':
+            return clipboardText
+        time.sleep(0.01)
+        if timeout is not None and time.time() > startTime + timeout:
+            raise PyperclipTimeoutException('waitForPaste() timed out after ' + str(timeout) + ' seconds.')
+
+def waitForNewPaste(timeout=None):
+    startTime = time.time()
+    originalText = paste()
+    while True:
+        currentText = paste()
+        if currentText != originalText:
+            return currentText
+        time.sleep(0.01)
+        if timeout is not None and time.time() > startTime + timeout:
+            raise PyperclipTimeoutException('waitForNewPaste() timed out after ' + str(timeout) + ' seconds.')
+__all__ = ['copy', 'paste', 'waitForPaste', 'waitForNewPaste', 'set_clipboard', 'determine_clipboard']
+clipboard_get = paste
+clipboard_set = copy
+
+# File: pandas-main/pandas/io/clipboards.py
+""""""
+from __future__ import annotations
+from io import StringIO
+from typing import TYPE_CHECKING
+import warnings
+from pandas._libs import lib
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import check_dtype_backend
+from pandas.core.dtypes.generic import ABCDataFrame
+from pandas import get_option, option_context
+if TYPE_CHECKING:
+    from pandas._typing import DtypeBackend
+
+def read_clipboard(sep: str='\\s+', dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, **kwargs):
+    encoding = kwargs.pop('encoding', 'utf-8')
+    if encoding is not None and encoding.lower().replace('-', '') != 'utf8':
+        raise NotImplementedError('reading from clipboard only supports utf-8 encoding')
+    check_dtype_backend(dtype_backend)
+    from pandas.io.clipboard import clipboard_get
+    from pandas.io.parsers import read_csv
+    text = clipboard_get()
+    try:
+        text = text.decode(kwargs.get('encoding') or get_option('display.encoding'))
+    except AttributeError:
+        pass
+    lines = text[:10000].split('\n')[:-1][:10]
+    counts = {x.lstrip(' ').count('\t') for x in lines}
+    if len(lines) > 1 and len(counts) == 1 and (counts.pop() != 0):
+        sep = '\t'
+        index_length = len(lines[0]) - len(lines[0].lstrip(' \t'))
+        if index_length != 0:
+            kwargs.setdefault('index_col', list(range(index_length)))
+    elif not isinstance(sep, str):
+        raise ValueError(f'sep={sep!r} must be a string')
+    if len(sep) > 1 and kwargs.get('engine') is None:
+        kwargs['engine'] = 'python'
+    elif len(sep) > 1 and kwargs.get('engine') == 'c':
+        warnings.warn('read_clipboard with regex separator does not work properly with c engine.', stacklevel=find_stack_level())
+    return read_csv(StringIO(text), sep=sep, dtype_backend=dtype_backend, **kwargs)
+
+def to_clipboard(obj, excel: bool | None=True, sep: str | None=None, **kwargs) -> None:
+    encoding = kwargs.pop('encoding', 'utf-8')
+    if encoding is not None and encoding.lower().replace('-', '') != 'utf8':
+        raise ValueError('clipboard only supports utf-8 encoding')
+    from pandas.io.clipboard import clipboard_set
+    if excel is None:
+        excel = True
+    if excel:
+        try:
+            if sep is None:
+                sep = '\t'
+            buf = StringIO()
+            obj.to_csv(buf, sep=sep, encoding='utf-8', **kwargs)
+            text = buf.getvalue()
+            clipboard_set(text)
+            return
+        except TypeError:
+            warnings.warn('to_clipboard in excel mode requires a single character separator.', stacklevel=find_stack_level())
+    elif sep is not None:
+        warnings.warn('to_clipboard with excel=False ignores the sep argument.', stacklevel=find_stack_level())
+    if isinstance(obj, ABCDataFrame):
+        with option_context('display.max_colwidth', None):
+            objstr = obj.to_string(**kwargs)
+    else:
+        objstr = str(obj)
+    clipboard_set(objstr)
+
+# File: pandas-main/pandas/io/common.py
+""""""
+from __future__ import annotations
+from abc import ABC, abstractmethod
+import codecs
+from collections import defaultdict
+from collections.abc import Hashable, Mapping, Sequence
+import dataclasses
+import functools
+import gzip
+from io import BufferedIOBase, BytesIO, RawIOBase, StringIO, TextIOBase, TextIOWrapper
+import mmap
+import os
+from pathlib import Path
+import re
+import tarfile
+from typing import IO, TYPE_CHECKING, Any, AnyStr, DefaultDict, Generic, Literal, TypeVar, cast, overload
+from urllib.parse import urljoin, urlparse as parse_url, uses_netloc, uses_params, uses_relative
+import warnings
+import zipfile
+from pandas._typing import BaseBuffer, ReadCsvBuffer
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import is_bool, is_file_like, is_integer, is_list_like
+from pandas.core.dtypes.generic import ABCMultiIndex
+from pandas.core.shared_docs import _shared_docs
+_VALID_URLS = set(uses_relative + uses_netloc + uses_params)
+_VALID_URLS.discard('')
+_RFC_3986_PATTERN = re.compile('^[A-Za-z][A-Za-z0-9+\\-+.]*://')
+BaseBufferT = TypeVar('BaseBufferT', bound=BaseBuffer)
+if TYPE_CHECKING:
+    from types import TracebackType
+    from pandas._typing import CompressionDict, CompressionOptions, FilePath, ReadBuffer, StorageOptions, WriteBuffer
+    from pandas import MultiIndex
+
+@dataclasses.dataclass
+class IOArgs:
+    filepath_or_buffer: str | BaseBuffer
+    encoding: str
+    mode: str
+    compression: CompressionDict
+    should_close: bool = False
+
+@dataclasses.dataclass
+class IOHandles(Generic[AnyStr]):
+    handle: IO[AnyStr]
+    compression: CompressionDict
+    created_handles: list[IO[bytes] | IO[str]] = dataclasses.field(default_factory=list)
+    is_wrapped: bool = False
+
+    def close(self) -> None:
+        if self.is_wrapped:
+            assert isinstance(self.handle, TextIOWrapper)
+            self.handle.flush()
+            self.handle.detach()
+            self.created_handles.remove(self.handle)
+        for handle in self.created_handles:
+            handle.close()
+        self.created_handles = []
+        self.is_wrapped = False
+
+    def __enter__(self) -> IOHandles[AnyStr]:
+        return self
+
+    def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
+        self.close()
+
+def is_url(url: object) -> bool:
+    if not isinstance(url, str):
+        return False
+    return parse_url(url).scheme in _VALID_URLS
+
+@overload
+def _expand_user(filepath_or_buffer: str) -> str:
+    ...
+
+@overload
+def _expand_user(filepath_or_buffer: BaseBufferT) -> BaseBufferT:
+    ...
+
+def _expand_user(filepath_or_buffer: str | BaseBufferT) -> str | BaseBufferT:
+    if isinstance(filepath_or_buffer, str):
+        return os.path.expanduser(filepath_or_buffer)
+    return filepath_or_buffer
+
+def validate_header_arg(header: object) -> None:
+    if header is None:
+        return
+    if is_integer(header):
+        header = cast(int, header)
+        if header < 0:
+            raise ValueError('Passing negative integer to header is invalid. For no header, use header=None instead')
+        return
+    if is_list_like(header, allow_sets=False):
+        header = cast(Sequence, header)
+        if not all(map(is_integer, header)):
+            raise ValueError('header must be integer or list of integers')
+        if any((i < 0 for i in header)):
+            raise ValueError('cannot specify multi-index header with negative integers')
+        return
+    if is_bool(header):
+        raise TypeError('Passing a bool to header is invalid. Use header=None for no header or header=int or list-like of ints to specify the row(s) making up the column names')
+    raise ValueError('header must be integer or list of integers')
+
+@overload
+def stringify_path(filepath_or_buffer: FilePath, convert_file_like: bool=...) -> str:
+    ...
+
+@overload
+def stringify_path(filepath_or_buffer: BaseBufferT, convert_file_like: bool=...) -> BaseBufferT:
+    ...
+
+def stringify_path(filepath_or_buffer: FilePath | BaseBufferT, convert_file_like: bool=False) -> str | BaseBufferT:
+    if not convert_file_like and is_file_like(filepath_or_buffer):
+        return cast(BaseBufferT, filepath_or_buffer)
+    if isinstance(filepath_or_buffer, os.PathLike):
+        filepath_or_buffer = filepath_or_buffer.__fspath__()
+    return _expand_user(filepath_or_buffer)
+
+def urlopen(*args: Any, **kwargs: Any) -> Any:
+    import urllib.request
+    return urllib.request.urlopen(*args, **kwargs)
+
+def is_fsspec_url(url: FilePath | BaseBuffer) -> bool:
+    return isinstance(url, str) and bool(_RFC_3986_PATTERN.match(url)) and (not url.startswith(('http://', 'https://')))
+
+@doc(storage_options=_shared_docs['storage_options'], compression_options=_shared_docs['compression_options'] % 'filepath_or_buffer')
+def _get_filepath_or_buffer(filepath_or_buffer: FilePath | BaseBuffer, encoding: str='utf-8', compression: CompressionOptions | None=None, mode: str='r', storage_options: StorageOptions | None=None) -> IOArgs:
+    filepath_or_buffer = stringify_path(filepath_or_buffer)
+    (compression_method, compression) = get_compression_method(compression)
+    compression_method = infer_compression(filepath_or_buffer, compression_method)
+    if compression_method and hasattr(filepath_or_buffer, 'write') and ('b' not in mode):
+        warnings.warn('compression has no effect when passing a non-binary object as input.', RuntimeWarning, stacklevel=find_stack_level())
+        compression_method = None
+    compression = dict(compression, method=compression_method)
+    if 'w' in mode and compression_method in ['bz2', 'xz'] and (encoding in ['utf-16', 'utf-32']):
+        warnings.warn(f'{compression} will not write the byte order mark for {encoding}', UnicodeWarning, stacklevel=find_stack_level())
+    if 'a' in mode and compression_method in ['zip', 'tar']:
+        warnings.warn("zip and tar do not support mode 'a' properly. This combination will result in multiple files with same name being added to the archive.", RuntimeWarning, stacklevel=find_stack_level())
+    fsspec_mode = mode
+    if 't' not in fsspec_mode and 'b' not in fsspec_mode:
+        fsspec_mode += 'b'
+    if isinstance(filepath_or_buffer, str) and is_url(filepath_or_buffer):
+        storage_options = storage_options or {}
+        import urllib.request
+        req_info = urllib.request.Request(filepath_or_buffer, headers=storage_options)
+        with urlopen(req_info) as req:
+            content_encoding = req.headers.get('Content-Encoding', None)
+            if content_encoding == 'gzip':
+                compression = {'method': 'gzip'}
+            reader = BytesIO(req.read())
+        return IOArgs(filepath_or_buffer=reader, encoding=encoding, compression=compression, should_close=True, mode=fsspec_mode)
+    if is_fsspec_url(filepath_or_buffer):
+        assert isinstance(filepath_or_buffer, str)
+        if filepath_or_buffer.startswith('s3a://'):
+            filepath_or_buffer = filepath_or_buffer.replace('s3a://', 's3://')
+        if filepath_or_buffer.startswith('s3n://'):
+            filepath_or_buffer = filepath_or_buffer.replace('s3n://', 's3://')
+        fsspec = import_optional_dependency('fsspec')
+        err_types_to_retry_with_anon: list[Any] = []
+        try:
+            import_optional_dependency('botocore')
+            from botocore.exceptions import ClientError, NoCredentialsError
+            err_types_to_retry_with_anon = [ClientError, NoCredentialsError, PermissionError]
+        except ImportError:
+            pass
+        try:
+            file_obj = fsspec.open(filepath_or_buffer, mode=fsspec_mode, **storage_options or {}).open()
+        except tuple(err_types_to_retry_with_anon):
+            if storage_options is None:
+                storage_options = {'anon': True}
+            else:
+                storage_options = dict(storage_options)
+                storage_options['anon'] = True
+            file_obj = fsspec.open(filepath_or_buffer, mode=fsspec_mode, **storage_options or {}).open()
+        return IOArgs(filepath_or_buffer=file_obj, encoding=encoding, compression=compression, should_close=True, mode=fsspec_mode)
+    elif storage_options:
+        raise ValueError('storage_options passed with file object or non-fsspec file path')
+    if isinstance(filepath_or_buffer, (str, bytes, mmap.mmap)):
+        return IOArgs(filepath_or_buffer=_expand_user(filepath_or_buffer), encoding=encoding, compression=compression, should_close=False, mode=mode)
+    if not (hasattr(filepath_or_buffer, 'read') or hasattr(filepath_or_buffer, 'write')):
+        msg = f'Invalid file path or buffer object type: {type(filepath_or_buffer)}'
+        raise ValueError(msg)
+    return IOArgs(filepath_or_buffer=filepath_or_buffer, encoding=encoding, compression=compression, should_close=False, mode=mode)
+
+def file_path_to_url(path: str) -> str:
+    from urllib.request import pathname2url
+    return urljoin('file:', pathname2url(path))
+extension_to_compression = {'.tar': 'tar', '.tar.gz': 'tar', '.tar.bz2': 'tar', '.tar.xz': 'tar', '.gz': 'gzip', '.bz2': 'bz2', '.zip': 'zip', '.xz': 'xz', '.zst': 'zstd'}
+_supported_compressions = set(extension_to_compression.values())
+
+def get_compression_method(compression: CompressionOptions) -> tuple[str | None, CompressionDict]:
+    compression_method: str | None
+    if isinstance(compression, Mapping):
+        compression_args = dict(compression)
+        try:
+            compression_method = compression_args.pop('method')
+        except KeyError as err:
+            raise ValueError("If mapping, compression must have key 'method'") from err
+    else:
+        compression_args = {}
+        compression_method = compression
+    return (compression_method, compression_args)
+
+@doc(compression_options=_shared_docs['compression_options'] % 'filepath_or_buffer')
+def infer_compression(filepath_or_buffer: FilePath | BaseBuffer, compression: str | None) -> str | None:
+    if compression is None:
+        return None
+    if compression == 'infer':
+        filepath_or_buffer = stringify_path(filepath_or_buffer, convert_file_like=True)
+        if not isinstance(filepath_or_buffer, str):
+            return None
+        for (extension, compression) in extension_to_compression.items():
+            if filepath_or_buffer.lower().endswith(extension):
+                return compression
+        return None
+    if compression in _supported_compressions:
+        return compression
+    valid = ['infer', None] + sorted(_supported_compressions)
+    msg = f'Unrecognized compression type: {compression}\nValid compression types are {valid}'
+    raise ValueError(msg)
+
+def check_parent_directory(path: Path | str) -> None:
+    parent = Path(path).parent
+    if not parent.is_dir():
+        raise OSError(f"Cannot save file into a non-existent directory: '{parent}'")
+
+@overload
+def get_handle(path_or_buf: FilePath | BaseBuffer, mode: str, *, encoding: str | None=..., compression: CompressionOptions=..., memory_map: bool=..., is_text: Literal[False], errors: str | None=..., storage_options: StorageOptions=...) -> IOHandles[bytes]:
+    ...
+
+@overload
+def get_handle(path_or_buf: FilePath | BaseBuffer, mode: str, *, encoding: str | None=..., compression: CompressionOptions=..., memory_map: bool=..., is_text: Literal[True]=..., errors: str | None=..., storage_options: StorageOptions=...) -> IOHandles[str]:
+    ...
+
+@overload
+def get_handle(path_or_buf: FilePath | BaseBuffer, mode: str, *, encoding: str | None=..., compression: CompressionOptions=..., memory_map: bool=..., is_text: bool=..., errors: str | None=..., storage_options: StorageOptions=...) -> IOHandles[str] | IOHandles[bytes]:
+    ...
+
+@doc(compression_options=_shared_docs['compression_options'] % 'path_or_buf')
+def get_handle(path_or_buf: FilePath | BaseBuffer, mode: str, *, encoding: str | None=None, compression: CompressionOptions | None=None, memory_map: bool=False, is_text: bool=True, errors: str | None=None, storage_options: StorageOptions | None=None) -> IOHandles[str] | IOHandles[bytes]:
+    encoding = encoding or 'utf-8'
+    errors = errors or 'strict'
+    if _is_binary_mode(path_or_buf, mode) and 'b' not in mode:
+        mode += 'b'
+    codecs.lookup(encoding)
+    if isinstance(errors, str):
+        codecs.lookup_error(errors)
+    ioargs = _get_filepath_or_buffer(path_or_buf, encoding=encoding, compression=compression, mode=mode, storage_options=storage_options)
+    handle = ioargs.filepath_or_buffer
+    handles: list[BaseBuffer]
+    (handle, memory_map, handles) = _maybe_memory_map(handle, memory_map)
+    is_path = isinstance(handle, str)
+    compression_args = dict(ioargs.compression)
+    compression = compression_args.pop('method')
+    if 'r' not in mode and is_path:
+        check_parent_directory(str(handle))
+    if compression:
+        if compression != 'zstd':
+            ioargs.mode = ioargs.mode.replace('t', '')
+        elif compression == 'zstd' and 'b' not in ioargs.mode:
+            ioargs.mode += 'b'
+        if compression == 'gzip':
+            if isinstance(handle, str):
+                handle = gzip.GzipFile(filename=handle, mode=ioargs.mode, **compression_args)
+            else:
+                handle = gzip.GzipFile(fileobj=handle, mode=ioargs.mode, **compression_args)
+        elif compression == 'bz2':
+            import bz2
+            handle = bz2.BZ2File(handle, mode=ioargs.mode, **compression_args)
+        elif compression == 'zip':
+            handle = _BytesZipFile(handle, ioargs.mode, **compression_args)
+            if handle.buffer.mode == 'r':
+                handles.append(handle)
+                zip_names = handle.buffer.namelist()
+                if len(zip_names) == 1:
+                    handle = handle.buffer.open(zip_names.pop())
+                elif not zip_names:
+                    raise ValueError(f'Zero files found in ZIP file {path_or_buf}')
+                else:
+                    raise ValueError(f'Multiple files found in ZIP file. Only one file per ZIP: {zip_names}')
+        elif compression == 'tar':
+            compression_args.setdefault('mode', ioargs.mode)
+            if isinstance(handle, str):
+                handle = _BytesTarFile(name=handle, **compression_args)
+            else:
+                handle = _BytesTarFile(fileobj=handle, **compression_args)
+            assert isinstance(handle, _BytesTarFile)
+            if 'r' in handle.buffer.mode:
+                handles.append(handle)
+                files = handle.buffer.getnames()
+                if len(files) == 1:
+                    file = handle.buffer.extractfile(files[0])
+                    assert file is not None
+                    handle = file
+                elif not files:
+                    raise ValueError(f'Zero files found in TAR archive {path_or_buf}')
+                else:
+                    raise ValueError(f'Multiple files found in TAR archive. Only one file per TAR archive: {files}')
+        elif compression == 'xz':
+            import lzma
+            handle = lzma.LZMAFile(handle, ioargs.mode, **compression_args)
+        elif compression == 'zstd':
+            zstd = import_optional_dependency('zstandard')
+            if 'r' in ioargs.mode:
+                open_args = {'dctx': zstd.ZstdDecompressor(**compression_args)}
+            else:
+                open_args = {'cctx': zstd.ZstdCompressor(**compression_args)}
+            handle = zstd.open(handle, mode=ioargs.mode, **open_args)
+        else:
+            msg = f'Unrecognized compression type: {compression}'
+            raise ValueError(msg)
+        assert not isinstance(handle, str)
+        handles.append(handle)
+    elif isinstance(handle, str):
+        if ioargs.encoding and 'b' not in ioargs.mode:
+            handle = open(handle, ioargs.mode, encoding=ioargs.encoding, errors=errors, newline='')
+        else:
+            handle = open(handle, ioargs.mode)
+        handles.append(handle)
+    is_wrapped = False
+    if not is_text and ioargs.mode == 'rb' and isinstance(handle, TextIOBase):
+        handle = _BytesIOWrapper(handle, encoding=ioargs.encoding)
+    elif is_text and (compression or memory_map or _is_binary_mode(handle, ioargs.mode)):
+        if not hasattr(handle, 'readable') or not hasattr(handle, 'writable') or (not hasattr(handle, 'seekable')):
+            handle = _IOWrapper(handle)
+        handle = TextIOWrapper(handle, encoding=ioargs.encoding, errors=errors, newline='')
+        handles.append(handle)
+        is_wrapped = not (isinstance(ioargs.filepath_or_buffer, str) or ioargs.should_close)
+    if 'r' in ioargs.mode and (not hasattr(handle, 'read')):
+        raise TypeError(f'Expected file path name or file-like object, got {type(ioargs.filepath_or_buffer)} type')
+    handles.reverse()
+    if ioargs.should_close:
+        assert not isinstance(ioargs.filepath_or_buffer, str)
+        handles.append(ioargs.filepath_or_buffer)
+    return IOHandles(handle=handle, created_handles=handles, is_wrapped=is_wrapped, compression=ioargs.compression)
+
+class _BufferedWriter(BytesIO, ABC):
+    buffer = BytesIO()
+
+    @abstractmethod
+    def write_to_buffer(self) -> None:
+        ...
+
+    def close(self) -> None:
+        if self.closed:
+            return
+        if self.getbuffer().nbytes:
+            self.seek(0)
+            with self.buffer:
+                self.write_to_buffer()
+        else:
+            self.buffer.close()
+        super().close()
+
+class _BytesTarFile(_BufferedWriter):
+
+    def __init__(self, name: str | None=None, mode: Literal['r', 'a', 'w', 'x']='r', fileobj: ReadBuffer[bytes] | WriteBuffer[bytes] | None=None, archive_name: str | None=None, **kwargs: Any) -> None:
+        super().__init__()
+        self.archive_name = archive_name
+        self.name = name
+        self.buffer: tarfile.TarFile = tarfile.TarFile.open(name=name, mode=self.extend_mode(mode), fileobj=fileobj, **kwargs)
+
+    def extend_mode(self, mode: str) -> str:
+        mode = mode.replace('b', '')
+        if mode != 'w':
+            return mode
+        if self.name is not None:
+            suffix = Path(self.name).suffix
+            if suffix in ('.gz', '.xz', '.bz2'):
+                mode = f'{mode}:{suffix[1:]}'
+        return mode
+
+    def infer_filename(self) -> str | None:
+        if self.name is None:
+            return None
+        filename = Path(self.name)
+        if filename.suffix == '.tar':
+            return filename.with_suffix('').name
+        elif filename.suffix in ('.tar.gz', '.tar.bz2', '.tar.xz'):
+            return filename.with_suffix('').with_suffix('').name
+        return filename.name
+
+    def write_to_buffer(self) -> None:
+        archive_name = self.archive_name or self.infer_filename() or 'tar'
+        tarinfo = tarfile.TarInfo(name=archive_name)
+        tarinfo.size = len(self.getvalue())
+        self.buffer.addfile(tarinfo, self)
+
+class _BytesZipFile(_BufferedWriter):
+
+    def __init__(self, file: FilePath | ReadBuffer[bytes] | WriteBuffer[bytes], mode: str, archive_name: str | None=None, **kwargs: Any) -> None:
+        super().__init__()
+        mode = mode.replace('b', '')
+        self.archive_name = archive_name
+        kwargs.setdefault('compression', zipfile.ZIP_DEFLATED)
+        self.buffer: zipfile.ZipFile = zipfile.ZipFile(file, mode, **kwargs)
+
+    def infer_filename(self) -> str | None:
+        if isinstance(self.buffer.filename, (os.PathLike, str)):
+            filename = Path(self.buffer.filename)
+            if filename.suffix == '.zip':
+                return filename.with_suffix('').name
+            return filename.name
+        return None
+
+    def write_to_buffer(self) -> None:
+        archive_name = self.archive_name or self.infer_filename() or 'zip'
+        self.buffer.writestr(archive_name, self.getvalue())
+
+class _IOWrapper:
+
+    def __init__(self, buffer: BaseBuffer) -> None:
+        self.buffer = buffer
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.buffer, name)
+
+    def readable(self) -> bool:
+        if hasattr(self.buffer, 'readable'):
+            return self.buffer.readable()
+        return True
+
+    def seekable(self) -> bool:
+        if hasattr(self.buffer, 'seekable'):
+            return self.buffer.seekable()
+        return True
+
+    def writable(self) -> bool:
+        if hasattr(self.buffer, 'writable'):
+            return self.buffer.writable()
+        return True
+
+class _BytesIOWrapper:
+
+    def __init__(self, buffer: StringIO | TextIOBase, encoding: str='utf-8') -> None:
+        self.buffer = buffer
+        self.encoding = encoding
+        self.overflow = b''
+
+    def __getattr__(self, attr: str) -> Any:
+        return getattr(self.buffer, attr)
+
+    def read(self, n: int | None=-1) -> bytes:
+        assert self.buffer is not None
+        bytestring = self.buffer.read(n).encode(self.encoding)
+        combined_bytestring = self.overflow + bytestring
+        if n is None or n < 0 or n >= len(combined_bytestring):
+            self.overflow = b''
+            return combined_bytestring
+        else:
+            to_return = combined_bytestring[:n]
+            self.overflow = combined_bytestring[n:]
+            return to_return
+
+def _maybe_memory_map(handle: str | BaseBuffer, memory_map: bool) -> tuple[str | BaseBuffer, bool, list[BaseBuffer]]:
+    handles: list[BaseBuffer] = []
+    memory_map &= hasattr(handle, 'fileno') or isinstance(handle, str)
+    if not memory_map:
+        return (handle, memory_map, handles)
+    handle = cast(ReadCsvBuffer, handle)
+    if isinstance(handle, str):
+        handle = open(handle, 'rb')
+        handles.append(handle)
+    try:
+        wrapped = _IOWrapper(mmap.mmap(handle.fileno(), 0, access=mmap.ACCESS_READ))
+    finally:
+        for handle in reversed(handles):
+            handle.close()
+    return (wrapped, memory_map, [wrapped])
+
+def file_exists(filepath_or_buffer: FilePath | BaseBuffer) -> bool:
+    exists = False
+    filepath_or_buffer = stringify_path(filepath_or_buffer)
+    if not isinstance(filepath_or_buffer, str):
+        return exists
+    try:
+        exists = os.path.exists(filepath_or_buffer)
+    except (TypeError, ValueError):
+        pass
+    return exists
+
+def _is_binary_mode(handle: FilePath | BaseBuffer, mode: str) -> bool:
+    if 't' in mode or 'b' in mode:
+        return 'b' in mode
+    text_classes = (codecs.StreamWriter, codecs.StreamReader, codecs.StreamReaderWriter)
+    if issubclass(type(handle), text_classes):
+        return False
+    return isinstance(handle, _get_binary_io_classes()) or 'b' in getattr(handle, 'mode', mode)
+
+@functools.lru_cache
+def _get_binary_io_classes() -> tuple[type, ...]:
+    binary_classes: tuple[type, ...] = (BufferedIOBase, RawIOBase)
+    zstd = import_optional_dependency('zstandard', errors='ignore')
+    if zstd is not None:
+        with zstd.ZstdDecompressor().stream_reader(b'') as reader:
+            binary_classes += (type(reader),)
+    return binary_classes
+
+def is_potential_multi_index(columns: Sequence[Hashable] | MultiIndex, index_col: bool | Sequence[int] | None=None) -> bool:
+    if index_col is None or isinstance(index_col, bool):
+        index_columns = set()
+    else:
+        index_columns = set(index_col)
+    return bool(len(columns) and (not isinstance(columns, ABCMultiIndex)) and all((isinstance(c, tuple) for c in columns if c not in index_columns)))
+
+def dedup_names(names: Sequence[Hashable], is_potential_multiindex: bool) -> Sequence[Hashable]:
+    names = list(names)
+    counts: DefaultDict[Hashable, int] = defaultdict(int)
+    for (i, col) in enumerate(names):
+        cur_count = counts[col]
+        while cur_count > 0:
+            counts[col] = cur_count + 1
+            if is_potential_multiindex:
+                assert isinstance(col, tuple)
+                col = col[:-1] + (f'{col[-1]}.{cur_count}',)
+            else:
+                col = f'{col}.{cur_count}'
+            cur_count = counts[col]
+        names[i] = col
+        counts[col] = cur_count + 1
+    return names
+
+# File: pandas-main/pandas/io/excel/__init__.py
+from pandas.io.excel._base import ExcelFile, ExcelWriter, read_excel
+from pandas.io.excel._odswriter import ODSWriter as _ODSWriter
+from pandas.io.excel._openpyxl import OpenpyxlWriter as _OpenpyxlWriter
+from pandas.io.excel._util import register_writer
+from pandas.io.excel._xlsxwriter import XlsxWriter as _XlsxWriter
+__all__ = ['read_excel', 'ExcelWriter', 'ExcelFile']
+register_writer(_OpenpyxlWriter)
+register_writer(_XlsxWriter)
+register_writer(_ODSWriter)
+
+# File: pandas-main/pandas/io/excel/_base.py
+from __future__ import annotations
+from collections.abc import Callable, Hashable, Iterable, Mapping, Sequence
+import datetime
+from functools import partial
+import os
+from textwrap import fill
+from typing import IO, TYPE_CHECKING, Any, Generic, Literal, TypeVar, Union, cast, overload
+import warnings
+import zipfile
+from pandas._config import config
+from pandas._libs import lib
+from pandas._libs.parsers import STR_NA_VALUES
+from pandas.compat._optional import get_version, import_optional_dependency
+from pandas.errors import EmptyDataError
+from pandas.util._decorators import Appender, doc
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import check_dtype_backend
+from pandas.core.dtypes.common import is_bool, is_file_like, is_float, is_integer, is_list_like
+from pandas.core.frame import DataFrame
+from pandas.core.shared_docs import _shared_docs
+from pandas.util.version import Version
+from pandas.io.common import IOHandles, get_handle, stringify_path, validate_header_arg
+from pandas.io.excel._util import fill_mi_header, get_default_engine, get_writer, maybe_convert_usecols, pop_header_name
+from pandas.io.parsers import TextParser
+from pandas.io.parsers.readers import validate_integer
+if TYPE_CHECKING:
+    from types import TracebackType
+    from pandas._typing import DtypeArg, DtypeBackend, ExcelWriterIfSheetExists, FilePath, HashableT, IntStrT, ReadBuffer, Self, SequenceNotStr, StorageOptions, WriteExcelBuffer
+_read_excel_doc = '\nRead an Excel file into a ``pandas`` ``DataFrame``.\n\nSupports `xls`, `xlsx`, `xlsm`, `xlsb`, `odf`, `ods` and `odt` file extensions\nread from a local filesystem or URL. Supports an option to read\na single sheet or a list of sheets.\n\nParameters\n----------\nio : str, ExcelFile, xlrd.Book, path object, or file-like object\n    Any valid string path is acceptable. The string could be a URL. Valid\n    URL schemes include http, ftp, s3, and file. For file URLs, a host is\n    expected. A local file could be: ``file://localhost/path/to/table.xlsx``.\n\n    If you want to pass in a path object, pandas accepts any ``os.PathLike``.\n\n    By file-like object, we refer to objects with a ``read()`` method,\n    such as a file handle (e.g. via builtin ``open`` function)\n    or ``StringIO``.\n\n    .. deprecated:: 2.1.0\n        Passing byte strings is deprecated. To read from a\n        byte string, wrap it in a ``BytesIO`` object.\nsheet_name : str, int, list, or None, default 0\n    Strings are used for sheet names. Integers are used in zero-indexed\n    sheet positions (chart sheets do not count as a sheet position).\n    Lists of strings/integers are used to request multiple sheets.\n    Specify ``None`` to get all worksheets.\n\n    Available cases:\n\n    * Defaults to ``0``: 1st sheet as a `DataFrame`\n    * ``1``: 2nd sheet as a `DataFrame`\n    * ``"Sheet1"``: Load sheet with name "Sheet1"\n    * ``[0, 1, "Sheet5"]``: Load first, second and sheet named "Sheet5"\n      as a dict of `DataFrame`\n    * ``None``: All worksheets.\n\nheader : int, list of int, default 0\n    Row (0-indexed) to use for the column labels of the parsed\n    DataFrame. If a list of integers is passed those row positions will\n    be combined into a ``MultiIndex``. Use None if there is no header.\nnames : array-like, default None\n    List of column names to use. If file contains no header row,\n    then you should explicitly pass header=None.\nindex_col : int, str, list of int, default None\n    Column (0-indexed) to use as the row labels of the DataFrame.\n    Pass None if there is no such column.  If a list is passed,\n    those columns will be combined into a ``MultiIndex``.  If a\n    subset of data is selected with ``usecols``, index_col\n    is based on the subset.\n\n    Missing values will be forward filled to allow roundtripping with\n    ``to_excel`` for ``merged_cells=True``. To avoid forward filling the\n    missing values use ``set_index`` after reading the data instead of\n    ``index_col``.\nusecols : str, list-like, or callable, default None\n    * If None, then parse all columns.\n    * If str, then indicates comma separated list of Excel column letters\n      and column ranges (e.g. "A:E" or "A,C,E:F"). Ranges are inclusive of\n      both sides.\n    * If list of int, then indicates list of column numbers to be parsed\n      (0-indexed).\n    * If list of string, then indicates list of column names to be parsed.\n    * If callable, then evaluate each column name against it and parse the\n      column if the callable returns ``True``.\n\n    Returns a subset of the columns according to behavior above.\ndtype : Type name or dict of column -> type, default None\n    Data type for data or columns. E.g. {{\'a\': np.float64, \'b\': np.int32}}\n    Use ``object`` to preserve data as stored in Excel and not interpret dtype,\n    which will necessarily result in ``object`` dtype.\n    If converters are specified, they will be applied INSTEAD\n    of dtype conversion.\n    If you use ``None``, it will infer the dtype of each column based on the data.\nengine : {{\'openpyxl\', \'calamine\', \'odf\', \'pyxlsb\', \'xlrd\'}}, default None\n    If io is not a buffer or path, this must be set to identify io.\n    Engine compatibility :\n\n    - ``openpyxl`` supports newer Excel file formats.\n    - ``calamine`` supports Excel (.xls, .xlsx, .xlsm, .xlsb)\n      and OpenDocument (.ods) file formats.\n    - ``odf`` supports OpenDocument file formats (.odf, .ods, .odt).\n    - ``pyxlsb`` supports Binary Excel files.\n    - ``xlrd`` supports old-style Excel files (.xls).\n\n    When ``engine=None``, the following logic will be used to determine the engine:\n\n    - If ``path_or_buffer`` is an OpenDocument format (.odf, .ods, .odt),\n      then `odf <https://pypi.org/project/odfpy/>`_ will be used.\n    - Otherwise if ``path_or_buffer`` is an xls format, ``xlrd`` will be used.\n    - Otherwise if ``path_or_buffer`` is in xlsb format, ``pyxlsb`` will be used.\n    - Otherwise ``openpyxl`` will be used.\nconverters : dict, default None\n    Dict of functions for converting values in certain columns. Keys can\n    either be integers or column labels, values are functions that take one\n    input argument, the Excel cell content, and return the transformed\n    content.\ntrue_values : list, default None\n    Values to consider as True.\nfalse_values : list, default None\n    Values to consider as False.\nskiprows : list-like, int, or callable, optional\n    Line numbers to skip (0-indexed) or number of lines to skip (int) at the\n    start of the file. If callable, the callable function will be evaluated\n    against the row indices, returning True if the row should be skipped and\n    False otherwise. An example of a valid callable argument would be ``lambda\n    x: x in [0, 2]``.\nnrows : int, default None\n    Number of rows to parse.\nna_values : scalar, str, list-like, or dict, default None\n    Additional strings to recognize as NA/NaN. If dict passed, specific\n    per-column NA values. By default the following values are interpreted\n    as NaN: \'' + fill("', '".join(sorted(STR_NA_VALUES)), 70, subsequent_indent='    ') + '\'.\nkeep_default_na : bool, default True\n    Whether or not to include the default NaN values when parsing the data.\n    Depending on whether ``na_values`` is passed in, the behavior is as follows:\n\n    * If ``keep_default_na`` is True, and ``na_values`` are specified,\n      ``na_values`` is appended to the default NaN values used for parsing.\n    * If ``keep_default_na`` is True, and ``na_values`` are not specified, only\n      the default NaN values are used for parsing.\n    * If ``keep_default_na`` is False, and ``na_values`` are specified, only\n      the NaN values specified ``na_values`` are used for parsing.\n    * If ``keep_default_na`` is False, and ``na_values`` are not specified, no\n      strings will be parsed as NaN.\n\n    Note that if `na_filter` is passed in as False, the ``keep_default_na`` and\n    ``na_values`` parameters will be ignored.\nna_filter : bool, default True\n    Detect missing value markers (empty strings and the value of na_values). In\n    data without any NAs, passing ``na_filter=False`` can improve the\n    performance of reading a large file.\nverbose : bool, default False\n    Indicate number of NA values placed in non-numeric columns.\nparse_dates : bool, list-like, or dict, default False\n    The behavior is as follows:\n\n    * ``bool``. If True -> try parsing the index.\n    * ``list`` of int or names. e.g. If [1, 2, 3] -> try parsing columns 1, 2, 3\n      each as a separate date column.\n    * ``list`` of lists. e.g.  If [[1, 3]] -> combine columns 1 and 3 and parse as\n      a single date column.\n    * ``dict``, e.g. {{\'foo\' : [1, 3]}} -> parse columns 1, 3 as date and call\n      result \'foo\'\n\n    If a column or index contains an unparsable date, the entire column or\n    index will be returned unaltered as an object data type. If you don`t want to\n    parse some cells as date just change their type in Excel to "Text".\n    For non-standard datetime parsing, use ``pd.to_datetime`` after ``pd.read_excel``.\n\n    Note: A fast-path exists for iso8601-formatted dates.\ndate_format : str or dict of column -> format, default ``None``\n   If used in conjunction with ``parse_dates``, will parse dates according to this\n   format. For anything more complex,\n   please read in as ``object`` and then apply :func:`to_datetime` as-needed.\n\n   .. versionadded:: 2.0.0\nthousands : str, default None\n    Thousands separator for parsing string columns to numeric.  Note that\n    this parameter is only necessary for columns stored as TEXT in Excel,\n    any numeric columns will automatically be parsed, regardless of display\n    format.\ndecimal : str, default \'.\'\n    Character to recognize as decimal point for parsing string columns to numeric.\n    Note that this parameter is only necessary for columns stored as TEXT in Excel,\n    any numeric columns will automatically be parsed, regardless of display\n    format.(e.g. use \',\' for European data).\n\n    .. versionadded:: 1.4.0\n\ncomment : str, default None\n    Comments out remainder of line. Pass a character or characters to this\n    argument to indicate comments in the input file. Any data between the\n    comment string and the end of the current line is ignored.\nskipfooter : int, default 0\n    Rows at the end to skip (0-indexed).\n{storage_options}\n\ndtype_backend : {{\'numpy_nullable\', \'pyarrow\'}}\n    Back-end data type applied to the resultant :class:`DataFrame`\n    (still experimental). If not specified, the default behavior\n    is to not use nullable data types. If specified, the behavior\n    is as follows:\n\n    * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`\n    * ``"pyarrow"``: returns pyarrow-backed nullable\n      :class:`ArrowDtype` :class:`DataFrame`\n\n    .. versionadded:: 2.0\n\nengine_kwargs : dict, optional\n    Arbitrary keyword arguments passed to excel engine.\n\nReturns\n-------\nDataFrame or dict of DataFrames\n    DataFrame from the passed in Excel file. See notes in sheet_name\n    argument for more information on when a dict of DataFrames is returned.\n\nSee Also\n--------\nDataFrame.to_excel : Write DataFrame to an Excel file.\nDataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.\nread_csv : Read a comma-separated values (csv) file into DataFrame.\nread_fwf : Read a table of fixed-width formatted lines into DataFrame.\n\nNotes\n-----\nFor specific information on the methods used for each Excel engine, refer to the pandas\n:ref:`user guide <io.excel_reader>`\n\nExamples\n--------\nThe file can be read using the file name as string or an open file object:\n\n>>> pd.read_excel(\'tmp.xlsx\', index_col=0)  # doctest: +SKIP\n       Name  Value\n0   string1      1\n1   string2      2\n2  #Comment      3\n\n>>> pd.read_excel(open(\'tmp.xlsx\', \'rb\'),\n...               sheet_name=\'Sheet3\')  # doctest: +SKIP\n   Unnamed: 0      Name  Value\n0           0   string1      1\n1           1   string2      2\n2           2  #Comment      3\n\nIndex and header can be specified via the `index_col` and `header` arguments\n\n>>> pd.read_excel(\'tmp.xlsx\', index_col=None, header=None)  # doctest: +SKIP\n     0         1      2\n0  NaN      Name  Value\n1  0.0   string1      1\n2  1.0   string2      2\n3  2.0  #Comment      3\n\nColumn types are inferred but can be explicitly specified\n\n>>> pd.read_excel(\'tmp.xlsx\', index_col=0,\n...               dtype={{\'Name\': str, \'Value\': float}})  # doctest: +SKIP\n       Name  Value\n0   string1    1.0\n1   string2    2.0\n2  #Comment    3.0\n\nTrue, False, and NA values, and thousands separators have defaults,\nbut can be explicitly specified, too. Supply the values you would like\nas strings or lists of strings!\n\n>>> pd.read_excel(\'tmp.xlsx\', index_col=0,\n...               na_values=[\'string1\', \'string2\'])  # doctest: +SKIP\n       Name  Value\n0       NaN      1\n1       NaN      2\n2  #Comment      3\n\nComment lines in the excel input file can be skipped using the\n``comment`` kwarg.\n\n>>> pd.read_excel(\'tmp.xlsx\', index_col=0, comment=\'#\')  # doctest: +SKIP\n      Name  Value\n0  string1    1.0\n1  string2    2.0\n2     None    NaN\n'
+
+@overload
+def read_excel(io, sheet_name: str | int=..., *, header: int | Sequence[int] | None=..., names: SequenceNotStr[Hashable] | range | None=..., index_col: int | str | Sequence[int] | None=..., usecols: int | str | Sequence[int] | Sequence[str] | Callable[[HashableT], bool] | None=..., dtype: DtypeArg | None=..., engine: Literal['xlrd', 'openpyxl', 'odf', 'pyxlsb', 'calamine'] | None=..., converters: dict[str, Callable] | dict[int, Callable] | None=..., true_values: Iterable[Hashable] | None=..., false_values: Iterable[Hashable] | None=..., skiprows: Sequence[int] | int | Callable[[int], object] | None=..., nrows: int | None=..., na_values=..., keep_default_na: bool=..., na_filter: bool=..., verbose: bool=..., parse_dates: list | dict | bool=..., date_format: dict[Hashable, str] | str | None=..., thousands: str | None=..., decimal: str=..., comment: str | None=..., skipfooter: int=..., storage_options: StorageOptions=..., dtype_backend: DtypeBackend | lib.NoDefault=...) -> DataFrame:
+    ...
+
+@overload
+def read_excel(io, sheet_name: list[IntStrT] | None, *, header: int | Sequence[int] | None=..., names: SequenceNotStr[Hashable] | range | None=..., index_col: int | str | Sequence[int] | None=..., usecols: int | str | Sequence[int] | Sequence[str] | Callable[[HashableT], bool] | None=..., dtype: DtypeArg | None=..., engine: Literal['xlrd', 'openpyxl', 'odf', 'pyxlsb', 'calamine'] | None=..., converters: dict[str, Callable] | dict[int, Callable] | None=..., true_values: Iterable[Hashable] | None=..., false_values: Iterable[Hashable] | None=..., skiprows: Sequence[int] | int | Callable[[int], object] | None=..., nrows: int | None=..., na_values=..., keep_default_na: bool=..., na_filter: bool=..., verbose: bool=..., parse_dates: list | dict | bool=..., date_format: dict[Hashable, str] | str | None=..., thousands: str | None=..., decimal: str=..., comment: str | None=..., skipfooter: int=..., storage_options: StorageOptions=..., dtype_backend: DtypeBackend | lib.NoDefault=...) -> dict[IntStrT, DataFrame]:
+    ...
+
+@doc(storage_options=_shared_docs['storage_options'])
+@Appender(_read_excel_doc)
+def read_excel(io, sheet_name: str | int | list[IntStrT] | None=0, *, header: int | Sequence[int] | None=0, names: SequenceNotStr[Hashable] | range | None=None, index_col: int | str | Sequence[int] | None=None, usecols: int | str | Sequence[int] | Sequence[str] | Callable[[HashableT], bool] | None=None, dtype: DtypeArg | None=None, engine: Literal['xlrd', 'openpyxl', 'odf', 'pyxlsb', 'calamine'] | None=None, converters: dict[str, Callable] | dict[int, Callable] | None=None, true_values: Iterable[Hashable] | None=None, false_values: Iterable[Hashable] | None=None, skiprows: Sequence[int] | int | Callable[[int], object] | None=None, nrows: int | None=None, na_values=None, keep_default_na: bool=True, na_filter: bool=True, verbose: bool=False, parse_dates: list | dict | bool=False, date_format: dict[Hashable, str] | str | None=None, thousands: str | None=None, decimal: str='.', comment: str | None=None, skipfooter: int=0, storage_options: StorageOptions | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, engine_kwargs: dict | None=None) -> DataFrame | dict[IntStrT, DataFrame]:
+    check_dtype_backend(dtype_backend)
+    should_close = False
+    if engine_kwargs is None:
+        engine_kwargs = {}
+    if not isinstance(io, ExcelFile):
+        should_close = True
+        io = ExcelFile(io, storage_options=storage_options, engine=engine, engine_kwargs=engine_kwargs)
+    elif engine and engine != io.engine:
+        raise ValueError('Engine should not be specified when passing an ExcelFile - ExcelFile already has the engine set')
+    try:
+        data = io.parse(sheet_name=sheet_name, header=header, names=names, index_col=index_col, usecols=usecols, dtype=dtype, converters=converters, true_values=true_values, false_values=false_values, skiprows=skiprows, nrows=nrows, na_values=na_values, keep_default_na=keep_default_na, na_filter=na_filter, verbose=verbose, parse_dates=parse_dates, date_format=date_format, thousands=thousands, decimal=decimal, comment=comment, skipfooter=skipfooter, dtype_backend=dtype_backend)
+    finally:
+        if should_close:
+            io.close()
+    return data
+_WorkbookT = TypeVar('_WorkbookT')
+
+class BaseExcelReader(Generic[_WorkbookT]):
+    book: _WorkbookT
+
+    def __init__(self, filepath_or_buffer, storage_options: StorageOptions | None=None, engine_kwargs: dict | None=None) -> None:
+        if engine_kwargs is None:
+            engine_kwargs = {}
+        self.handles = IOHandles(handle=filepath_or_buffer, compression={'method': None})
+        if not isinstance(filepath_or_buffer, (ExcelFile, self._workbook_class)):
+            self.handles = get_handle(filepath_or_buffer, 'rb', storage_options=storage_options, is_text=False)
+        if isinstance(self.handles.handle, self._workbook_class):
+            self.book = self.handles.handle
+        elif hasattr(self.handles.handle, 'read'):
+            self.handles.handle.seek(0)
+            try:
+                self.book = self.load_workbook(self.handles.handle, engine_kwargs)
+            except Exception:
+                self.close()
+                raise
+        else:
+            raise ValueError('Must explicitly set engine if not passing in buffer or path for io.')
+
+    @property
+    def _workbook_class(self) -> type[_WorkbookT]:
+        raise NotImplementedError
+
+    def load_workbook(self, filepath_or_buffer, engine_kwargs) -> _WorkbookT:
+        raise NotImplementedError
+
+    def close(self) -> None:
+        if hasattr(self, 'book'):
+            if hasattr(self.book, 'close'):
+                self.book.close()
+            elif hasattr(self.book, 'release_resources'):
+                self.book.release_resources()
+        self.handles.close()
+
+    @property
+    def sheet_names(self) -> list[str]:
+        raise NotImplementedError
+
+    def get_sheet_by_name(self, name: str):
+        raise NotImplementedError
+
+    def get_sheet_by_index(self, index: int):
+        raise NotImplementedError
+
+    def get_sheet_data(self, sheet, rows: int | None=None):
+        raise NotImplementedError
+
+    def raise_if_bad_sheet_by_index(self, index: int) -> None:
+        n_sheets = len(self.sheet_names)
+        if index >= n_sheets:
+            raise ValueError(f'Worksheet index {index} is invalid, {n_sheets} worksheets found')
+
+    def raise_if_bad_sheet_by_name(self, name: str) -> None:
+        if name not in self.sheet_names:
+            raise ValueError(f"Worksheet named '{name}' not found")
+
+    def _check_skiprows_func(self, skiprows: Callable, rows_to_use: int) -> int:
+        i = 0
+        rows_used_so_far = 0
+        while rows_used_so_far < rows_to_use:
+            if not skiprows(i):
+                rows_used_so_far += 1
+            i += 1
+        return i
+
+    def _calc_rows(self, header: int | Sequence[int] | None, index_col: int | Sequence[int] | None, skiprows: Sequence[int] | int | Callable[[int], object] | None, nrows: int | None) -> int | None:
+        if nrows is None:
+            return None
+        if header is None:
+            header_rows = 1
+        elif is_integer(header):
+            header = cast(int, header)
+            header_rows = 1 + header
+        else:
+            header = cast(Sequence, header)
+            header_rows = 1 + header[-1]
+        if is_list_like(header) and index_col is not None:
+            header = cast(Sequence, header)
+            if len(header) > 1:
+                header_rows += 1
+        if skiprows is None:
+            return header_rows + nrows
+        if is_integer(skiprows):
+            skiprows = cast(int, skiprows)
+            return header_rows + nrows + skiprows
+        if is_list_like(skiprows):
+
+            def f(skiprows: Sequence, x: int) -> bool:
+                return x in skiprows
+            skiprows = cast(Sequence, skiprows)
+            return self._check_skiprows_func(partial(f, skiprows), header_rows + nrows)
+        if callable(skiprows):
+            return self._check_skiprows_func(skiprows, header_rows + nrows)
+        return None
+
+    def parse(self, sheet_name: str | int | list[int] | list[str] | None=0, header: int | Sequence[int] | None=0, names: SequenceNotStr[Hashable] | range | None=None, index_col: int | Sequence[int] | None=None, usecols=None, dtype: DtypeArg | None=None, true_values: Iterable[Hashable] | None=None, false_values: Iterable[Hashable] | None=None, skiprows: Sequence[int] | int | Callable[[int], object] | None=None, nrows: int | None=None, na_values=None, verbose: bool=False, parse_dates: list | dict | bool=False, date_format: dict[Hashable, str] | str | None=None, thousands: str | None=None, decimal: str='.', comment: str | None=None, skipfooter: int=0, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, **kwds):
+        validate_header_arg(header)
+        validate_integer('nrows', nrows)
+        ret_dict = False
+        sheets: list[int] | list[str]
+        if isinstance(sheet_name, list):
+            sheets = sheet_name
+            ret_dict = True
+        elif sheet_name is None:
+            sheets = self.sheet_names
+            ret_dict = True
+        elif isinstance(sheet_name, str):
+            sheets = [sheet_name]
+        else:
+            sheets = [sheet_name]
+        sheets = cast(Union[list[int], list[str]], list(dict.fromkeys(sheets).keys()))
+        output = {}
+        last_sheetname = None
+        for asheetname in sheets:
+            last_sheetname = asheetname
+            if verbose:
+                print(f'Reading sheet {asheetname}')
+            if isinstance(asheetname, str):
+                sheet = self.get_sheet_by_name(asheetname)
+            else:
+                sheet = self.get_sheet_by_index(asheetname)
+            file_rows_needed = self._calc_rows(header, index_col, skiprows, nrows)
+            data = self.get_sheet_data(sheet, file_rows_needed)
+            if hasattr(sheet, 'close'):
+                sheet.close()
+            usecols = maybe_convert_usecols(usecols)
+            if not data:
+                output[asheetname] = DataFrame()
+                continue
+            output = self._parse_sheet(data=data, output=output, asheetname=asheetname, header=header, names=names, index_col=index_col, usecols=usecols, dtype=dtype, skiprows=skiprows, nrows=nrows, true_values=true_values, false_values=false_values, na_values=na_values, parse_dates=parse_dates, date_format=date_format, thousands=thousands, decimal=decimal, comment=comment, skipfooter=skipfooter, dtype_backend=dtype_backend, **kwds)
+        if last_sheetname is None:
+            raise ValueError('Sheet name is an empty list')
+        if ret_dict:
+            return output
+        else:
+            return output[last_sheetname]
+
+    def _parse_sheet(self, data: list, output: dict, asheetname: str | int | None=None, header: int | Sequence[int] | None=0, names: SequenceNotStr[Hashable] | range | None=None, index_col: int | Sequence[int] | None=None, usecols=None, dtype: DtypeArg | None=None, skiprows: Sequence[int] | int | Callable[[int], object] | None=None, nrows: int | None=None, true_values: Iterable[Hashable] | None=None, false_values: Iterable[Hashable] | None=None, na_values=None, parse_dates: list | dict | bool=False, date_format: dict[Hashable, str] | str | None=None, thousands: str | None=None, decimal: str='.', comment: str | None=None, skipfooter: int=0, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, **kwds):
+        is_list_header = False
+        is_len_one_list_header = False
+        if is_list_like(header):
+            assert isinstance(header, Sequence)
+            is_list_header = True
+            if len(header) == 1:
+                is_len_one_list_header = True
+        if is_len_one_list_header:
+            header = cast(Sequence[int], header)[0]
+        header_names = None
+        if header is not None and is_list_like(header):
+            assert isinstance(header, Sequence)
+            header_names = []
+            control_row = [True] * len(data[0])
+            for row in header:
+                if is_integer(skiprows):
+                    assert isinstance(skiprows, int)
+                    row += skiprows
+                if row > len(data) - 1:
+                    raise ValueError(f'header index {row} exceeds maximum index {len(data) - 1} of data.')
+                (data[row], control_row) = fill_mi_header(data[row], control_row)
+                if index_col is not None:
+                    (header_name, _) = pop_header_name(data[row], index_col)
+                    header_names.append(header_name)
+        has_index_names = False
+        if is_list_header and (not is_len_one_list_header) and (index_col is not None):
+            index_col_set: set[int]
+            if isinstance(index_col, int):
+                index_col_set = {index_col}
+            else:
+                assert isinstance(index_col, Sequence)
+                index_col_set = set(index_col)
+            assert isinstance(header, Sequence)
+            if len(header) < len(data):
+                potential_index_names = data[len(header)]
+                has_index_names = all((x == '' or x is None for (i, x) in enumerate(potential_index_names) if not control_row[i] and i not in index_col_set))
+        if is_list_like(index_col):
+            if header is None:
+                offset = 0
+            elif isinstance(header, int):
+                offset = 1 + header
+            else:
+                offset = 1 + max(header)
+            if has_index_names:
+                offset += 1
+            if offset < len(data):
+                assert isinstance(index_col, Sequence)
+                for col in index_col:
+                    last = data[offset][col]
+                    for row in range(offset + 1, len(data)):
+                        if data[row][col] == '' or data[row][col] is None:
+                            data[row][col] = last
+                        else:
+                            last = data[row][col]
+        try:
+            parser = TextParser(data, names=names, header=header, index_col=index_col, has_index_names=has_index_names, dtype=dtype, true_values=true_values, false_values=false_values, skiprows=skiprows, nrows=nrows, na_values=na_values, skip_blank_lines=False, parse_dates=parse_dates, date_format=date_format, thousands=thousands, decimal=decimal, comment=comment, skipfooter=skipfooter, usecols=usecols, dtype_backend=dtype_backend, **kwds)
+            output[asheetname] = parser.read(nrows=nrows)
+            if header_names:
+                output[asheetname].columns = output[asheetname].columns.set_names(header_names)
+        except EmptyDataError:
+            output[asheetname] = DataFrame()
+        except Exception as err:
+            err.args = (f'{err.args[0]} (sheet: {asheetname})', *err.args[1:])
+            raise err
+        return output
+
+@doc(storage_options=_shared_docs['storage_options'])
+class ExcelWriter(Generic[_WorkbookT]):
+    _engine: str
+    _supported_extensions: tuple[str, ...]
+
+    def __new__(cls, path: FilePath | WriteExcelBuffer | ExcelWriter, engine: str | None=None, date_format: str | None=None, datetime_format: str | None=None, mode: str='w', storage_options: StorageOptions | None=None, if_sheet_exists: ExcelWriterIfSheetExists | None=None, engine_kwargs: dict | None=None) -> Self:
+        if cls is ExcelWriter:
+            if engine is None or (isinstance(engine, str) and engine == 'auto'):
+                if isinstance(path, str):
+                    ext = os.path.splitext(path)[-1][1:]
+                else:
+                    ext = 'xlsx'
+                try:
+                    engine = config.get_option(f'io.excel.{ext}.writer')
+                    if engine == 'auto':
+                        engine = get_default_engine(ext, mode='writer')
+                except KeyError as err:
+                    raise ValueError(f"No engine for filetype: '{ext}'") from err
+            assert engine is not None
+            cls = get_writer(engine)
+        return object.__new__(cls)
+    _path = None
+
+    @property
+    def supported_extensions(self) -> tuple[str, ...]:
+        return self._supported_extensions
+
+    @property
+    def engine(self) -> str:
+        return self._engine
+
+    @property
+    def sheets(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+    @property
+    def book(self) -> _WorkbookT:
+        raise NotImplementedError
+
+    def _write_cells(self, cells, sheet_name: str | None=None, startrow: int=0, startcol: int=0, freeze_panes: tuple[int, int] | None=None) -> None:
+        raise NotImplementedError
+
+    def _save(self) -> None:
+        raise NotImplementedError
+
+    def __init__(self, path: FilePath | WriteExcelBuffer | ExcelWriter, engine: str | None=None, date_format: str | None=None, datetime_format: str | None=None, mode: str='w', storage_options: StorageOptions | None=None, if_sheet_exists: ExcelWriterIfSheetExists | None=None, engine_kwargs: dict[str, Any] | None=None) -> None:
+        if isinstance(path, str):
+            ext = os.path.splitext(path)[-1]
+            self.check_extension(ext)
+        if 'b' not in mode:
+            mode += 'b'
+        mode = mode.replace('a', 'r+')
+        if if_sheet_exists not in (None, 'error', 'new', 'replace', 'overlay'):
+            raise ValueError(f"'{if_sheet_exists}' is not valid for if_sheet_exists. Valid options are 'error', 'new', 'replace' and 'overlay'.")
+        if if_sheet_exists and 'r+' not in mode:
+            raise ValueError("if_sheet_exists is only valid in append mode (mode='a')")
+        if if_sheet_exists is None:
+            if_sheet_exists = 'error'
+        self._if_sheet_exists = if_sheet_exists
+        self._handles = IOHandles(cast(IO[bytes], path), compression={'compression': None})
+        if not isinstance(path, ExcelWriter):
+            self._handles = get_handle(path, mode, storage_options=storage_options, is_text=False)
+        self._cur_sheet = None
+        if date_format is None:
+            self._date_format = 'YYYY-MM-DD'
+        else:
+            self._date_format = date_format
+        if datetime_format is None:
+            self._datetime_format = 'YYYY-MM-DD HH:MM:SS'
+        else:
+            self._datetime_format = datetime_format
+        self._mode = mode
+
+    @property
+    def date_format(self) -> str:
+        return self._date_format
+
+    @property
+    def datetime_format(self) -> str:
+        return self._datetime_format
+
+    @property
+    def if_sheet_exists(self) -> str:
+        return self._if_sheet_exists
+
+    def __fspath__(self) -> str:
+        return getattr(self._handles.handle, 'name', '')
+
+    def _get_sheet_name(self, sheet_name: str | None) -> str:
+        if sheet_name is None:
+            sheet_name = self._cur_sheet
+        if sheet_name is None:
+            raise ValueError('Must pass explicit sheet_name or set _cur_sheet property')
+        return sheet_name
+
+    def _value_with_fmt(self, val) -> tuple[int | float | bool | str | datetime.datetime | datetime.date, str | None]:
+        fmt = None
+        if is_integer(val):
+            val = int(val)
+        elif is_float(val):
+            val = float(val)
+        elif is_bool(val):
+            val = bool(val)
+        elif isinstance(val, datetime.datetime):
+            fmt = self._datetime_format
+        elif isinstance(val, datetime.date):
+            fmt = self._date_format
+        elif isinstance(val, datetime.timedelta):
+            val = val.total_seconds() / 86400
+            fmt = '0'
+        else:
+            val = str(val)
+            if len(val) > 32767:
+                warnings.warn(f'Cell contents too long ({len(val)}), truncated to 32767 characters', UserWarning, stacklevel=find_stack_level())
+        return (val, fmt)
+
+    @classmethod
+    def check_extension(cls, ext: str) -> Literal[True]:
+        if ext.startswith('.'):
+            ext = ext[1:]
+        if not any((ext in extension for extension in cls._supported_extensions)):
+            raise ValueError(f"Invalid extension for engine '{cls.engine}': '{ext}'")
+        return True
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._save()
+        self._handles.close()
+XLS_SIGNATURES = (b'\t\x00\x04\x00\x07\x00\x10\x00', b'\t\x02\x06\x00\x00\x00\x10\x00', b'\t\x04\x06\x00\x00\x00\x10\x00', b'\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1')
+ZIP_SIGNATURE = b'PK\x03\x04'
+PEEK_SIZE = max(map(len, XLS_SIGNATURES + (ZIP_SIGNATURE,)))
+
+@doc(storage_options=_shared_docs['storage_options'])
+def inspect_excel_format(content_or_path: FilePath | ReadBuffer[bytes], storage_options: StorageOptions | None=None) -> str | None:
+    with get_handle(content_or_path, 'rb', storage_options=storage_options, is_text=False) as handle:
+        stream = handle.handle
+        stream.seek(0)
+        buf = stream.read(PEEK_SIZE)
+        if buf is None:
+            raise ValueError('stream is empty')
+        assert isinstance(buf, bytes)
+        peek = buf
+        stream.seek(0)
+        if any((peek.startswith(sig) for sig in XLS_SIGNATURES)):
+            return 'xls'
+        elif not peek.startswith(ZIP_SIGNATURE):
+            return None
+        with zipfile.ZipFile(stream) as zf:
+            component_names = {name.replace('\\', '/').lower() for name in zf.namelist()}
+        if 'xl/workbook.xml' in component_names:
+            return 'xlsx'
+        if 'xl/workbook.bin' in component_names:
+            return 'xlsb'
+        if 'content.xml' in component_names:
+            return 'ods'
+        return 'zip'
+
+@doc(storage_options=_shared_docs['storage_options'])
+class ExcelFile:
+    from pandas.io.excel._calamine import CalamineReader
+    from pandas.io.excel._odfreader import ODFReader
+    from pandas.io.excel._openpyxl import OpenpyxlReader
+    from pandas.io.excel._pyxlsb import PyxlsbReader
+    from pandas.io.excel._xlrd import XlrdReader
+    _engines: Mapping[str, Any] = {'xlrd': XlrdReader, 'openpyxl': OpenpyxlReader, 'odf': ODFReader, 'pyxlsb': PyxlsbReader, 'calamine': CalamineReader}
+
+    def __init__(self, path_or_buffer, engine: str | None=None, storage_options: StorageOptions | None=None, engine_kwargs: dict | None=None) -> None:
+        if engine_kwargs is None:
+            engine_kwargs = {}
+        if engine is not None and engine not in self._engines:
+            raise ValueError(f'Unknown engine: {engine}')
+        self._io = stringify_path(path_or_buffer)
+        if engine is None:
+            ext: str | None = None
+            if not isinstance(path_or_buffer, (str, os.PathLike, ExcelFile)) and (not is_file_like(path_or_buffer)):
+                if import_optional_dependency('xlrd', errors='ignore') is None:
+                    xlrd_version = None
+                else:
+                    import xlrd
+                    xlrd_version = Version(get_version(xlrd))
+                if xlrd_version is not None and isinstance(path_or_buffer, xlrd.Book):
+                    ext = 'xls'
+            if ext is None:
+                ext = inspect_excel_format(content_or_path=path_or_buffer, storage_options=storage_options)
+                if ext is None:
+                    raise ValueError('Excel file format cannot be determined, you must specify an engine manually.')
+            engine = config.get_option(f'io.excel.{ext}.reader')
+            if engine == 'auto':
+                engine = get_default_engine(ext, mode='reader')
+        assert engine is not None
+        self.engine = engine
+        self.storage_options = storage_options
+        self._reader = self._engines[engine](self._io, storage_options=storage_options, engine_kwargs=engine_kwargs)
+
+    def __fspath__(self):
+        return self._io
+
+    def parse(self, sheet_name: str | int | list[int] | list[str] | None=0, header: int | Sequence[int] | None=0, names: SequenceNotStr[Hashable] | range | None=None, index_col: int | Sequence[int] | None=None, usecols=None, converters=None, true_values: Iterable[Hashable] | None=None, false_values: Iterable[Hashable] | None=None, skiprows: Sequence[int] | int | Callable[[int], object] | None=None, nrows: int | None=None, na_values=None, parse_dates: list | dict | bool=False, date_format: str | dict[Hashable, str] | None=None, thousands: str | None=None, comment: str | None=None, skipfooter: int=0, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, **kwds) -> DataFrame | dict[str, DataFrame] | dict[int, DataFrame]:
+        return self._reader.parse(sheet_name=sheet_name, header=header, names=names, index_col=index_col, usecols=usecols, converters=converters, true_values=true_values, false_values=false_values, skiprows=skiprows, nrows=nrows, na_values=na_values, parse_dates=parse_dates, date_format=date_format, thousands=thousands, comment=comment, skipfooter=skipfooter, dtype_backend=dtype_backend, **kwds)
+
+    @property
+    def book(self):
+        return self._reader.book
+
+    @property
+    def sheet_names(self):
+        return self._reader.sheet_names
+
+    def close(self) -> None:
+        self._reader.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
+        self.close()
+
+# File: pandas-main/pandas/io/excel/_calamine.py
+from __future__ import annotations
+from datetime import date, datetime, time, timedelta
+from typing import TYPE_CHECKING, Any, Union
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+import pandas as pd
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.excel._base import BaseExcelReader
+if TYPE_CHECKING:
+    from python_calamine import CalamineSheet, CalamineWorkbook
+    from pandas._typing import FilePath, NaTType, ReadBuffer, Scalar, StorageOptions
+_CellValue = Union[int, float, str, bool, time, date, datetime, timedelta]
+
+class CalamineReader(BaseExcelReader['CalamineWorkbook']):
+
+    @doc(storage_options=_shared_docs['storage_options'])
+    def __init__(self, filepath_or_buffer: FilePath | ReadBuffer[bytes], storage_options: StorageOptions | None=None, engine_kwargs: dict | None=None) -> None:
+        import_optional_dependency('python_calamine')
+        super().__init__(filepath_or_buffer, storage_options=storage_options, engine_kwargs=engine_kwargs)
+
+    @property
+    def _workbook_class(self) -> type[CalamineWorkbook]:
+        from python_calamine import CalamineWorkbook
+        return CalamineWorkbook
+
+    def load_workbook(self, filepath_or_buffer: FilePath | ReadBuffer[bytes], engine_kwargs: Any) -> CalamineWorkbook:
+        from python_calamine import load_workbook
+        return load_workbook(filepath_or_buffer, **engine_kwargs)
+
+    @property
+    def sheet_names(self) -> list[str]:
+        from python_calamine import SheetTypeEnum
+        return [sheet.name for sheet in self.book.sheets_metadata if sheet.typ == SheetTypeEnum.WorkSheet]
+
+    def get_sheet_by_name(self, name: str) -> CalamineSheet:
+        self.raise_if_bad_sheet_by_name(name)
+        return self.book.get_sheet_by_name(name)
+
+    def get_sheet_by_index(self, index: int) -> CalamineSheet:
+        self.raise_if_bad_sheet_by_index(index)
+        return self.book.get_sheet_by_index(index)
+
+    def get_sheet_data(self, sheet: CalamineSheet, file_rows_needed: int | None=None) -> list[list[Scalar | NaTType | time]]:
+
+        def _convert_cell(value: _CellValue) -> Scalar | NaTType | time:
+            if isinstance(value, float):
+                val = int(value)
+                if val == value:
+                    return val
+                else:
+                    return value
+            elif isinstance(value, date):
+                return pd.Timestamp(value)
+            elif isinstance(value, timedelta):
+                return pd.Timedelta(value)
+            elif isinstance(value, time):
+                return value
+            return value
+        rows: list[list[_CellValue]] = sheet.to_python(skip_empty_area=False, nrows=file_rows_needed)
+        data = [[_convert_cell(cell) for cell in row] for row in rows]
+        return data
+
+# File: pandas-main/pandas/io/excel/_odfreader.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, cast
+import numpy as np
+from pandas._typing import FilePath, ReadBuffer, Scalar, StorageOptions
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+import pandas as pd
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.excel._base import BaseExcelReader
+if TYPE_CHECKING:
+    from odf.opendocument import OpenDocument
+    from pandas._libs.tslibs.nattype import NaTType
+
+@doc(storage_options=_shared_docs['storage_options'])
+class ODFReader(BaseExcelReader['OpenDocument']):
+
+    def __init__(self, filepath_or_buffer: FilePath | ReadBuffer[bytes], storage_options: StorageOptions | None=None, engine_kwargs: dict | None=None) -> None:
+        import_optional_dependency('odf')
+        super().__init__(filepath_or_buffer, storage_options=storage_options, engine_kwargs=engine_kwargs)
+
+    @property
+    def _workbook_class(self) -> type[OpenDocument]:
+        from odf.opendocument import OpenDocument
+        return OpenDocument
+
+    def load_workbook(self, filepath_or_buffer: FilePath | ReadBuffer[bytes], engine_kwargs) -> OpenDocument:
+        from odf.opendocument import load
+        return load(filepath_or_buffer, **engine_kwargs)
+
+    @property
+    def empty_value(self) -> str:
+        return ''
+
+    @property
+    def sheet_names(self) -> list[str]:
+        from odf.table import Table
+        tables = self.book.getElementsByType(Table)
+        return [t.getAttribute('name') for t in tables]
+
+    def get_sheet_by_index(self, index: int):
+        from odf.table import Table
+        self.raise_if_bad_sheet_by_index(index)
+        tables = self.book.getElementsByType(Table)
+        return tables[index]
+
+    def get_sheet_by_name(self, name: str):
+        from odf.table import Table
+        self.raise_if_bad_sheet_by_name(name)
+        tables = self.book.getElementsByType(Table)
+        for table in tables:
+            if table.getAttribute('name') == name:
+                return table
+        self.close()
+        raise ValueError(f'sheet {name} not found')
+
+    def get_sheet_data(self, sheet, file_rows_needed: int | None=None) -> list[list[Scalar | NaTType]]:
+        from odf.table import CoveredTableCell, TableCell, TableRow
+        covered_cell_name = CoveredTableCell().qname
+        table_cell_name = TableCell().qname
+        cell_names = {covered_cell_name, table_cell_name}
+        sheet_rows = sheet.getElementsByType(TableRow)
+        empty_rows = 0
+        max_row_len = 0
+        table: list[list[Scalar | NaTType]] = []
+        for sheet_row in sheet_rows:
+            empty_cells = 0
+            table_row: list[Scalar | NaTType] = []
+            for sheet_cell in sheet_row.childNodes:
+                if hasattr(sheet_cell, 'qname') and sheet_cell.qname in cell_names:
+                    if sheet_cell.qname == table_cell_name:
+                        value = self._get_cell_value(sheet_cell)
+                    else:
+                        value = self.empty_value
+                    column_repeat = self._get_column_repeat(sheet_cell)
+                    if value == self.empty_value:
+                        empty_cells += column_repeat
+                    else:
+                        table_row.extend([self.empty_value] * empty_cells)
+                        empty_cells = 0
+                        table_row.extend([value] * column_repeat)
+            if max_row_len < len(table_row):
+                max_row_len = len(table_row)
+            row_repeat = self._get_row_repeat(sheet_row)
+            if len(table_row) == 0:
+                empty_rows += row_repeat
+            else:
+                table.extend([[self.empty_value]] * empty_rows)
+                empty_rows = 0
+                table.extend((table_row for _ in range(row_repeat)))
+            if file_rows_needed is not None and len(table) >= file_rows_needed:
+                break
+        for row in table:
+            if len(row) < max_row_len:
+                row.extend([self.empty_value] * (max_row_len - len(row)))
+        return table
+
+    def _get_row_repeat(self, row) -> int:
+        from odf.namespaces import TABLENS
+        return int(row.attributes.get((TABLENS, 'number-rows-repeated'), 1))
+
+    def _get_column_repeat(self, cell) -> int:
+        from odf.namespaces import TABLENS
+        return int(cell.attributes.get((TABLENS, 'number-columns-repeated'), 1))
+
+    def _get_cell_value(self, cell) -> Scalar | NaTType:
+        from odf.namespaces import OFFICENS
+        if str(cell) == '#N/A':
+            return np.nan
+        cell_type = cell.attributes.get((OFFICENS, 'value-type'))
+        if cell_type == 'boolean':
+            if str(cell) == 'TRUE':
+                return True
+            return False
+        if cell_type is None:
+            return self.empty_value
+        elif cell_type == 'float':
+            cell_value = float(cell.attributes.get((OFFICENS, 'value')))
+            val = int(cell_value)
+            if val == cell_value:
+                return val
+            return cell_value
+        elif cell_type == 'percentage':
+            cell_value = cell.attributes.get((OFFICENS, 'value'))
+            return float(cell_value)
+        elif cell_type == 'string':
+            return self._get_cell_string_value(cell)
+        elif cell_type == 'currency':
+            cell_value = cell.attributes.get((OFFICENS, 'value'))
+            return float(cell_value)
+        elif cell_type == 'date':
+            cell_value = cell.attributes.get((OFFICENS, 'date-value'))
+            return pd.Timestamp(cell_value)
+        elif cell_type == 'time':
+            stamp = pd.Timestamp(str(cell))
+            return cast(Scalar, stamp.time())
+        else:
+            self.close()
+            raise ValueError(f'Unrecognized type {cell_type}')
+
+    def _get_cell_string_value(self, cell) -> str:
+        from odf.element import Element
+        from odf.namespaces import TEXTNS
+        from odf.office import Annotation
+        from odf.text import S
+        office_annotation = Annotation().qname
+        text_s = S().qname
+        value = []
+        for fragment in cell.childNodes:
+            if isinstance(fragment, Element):
+                if fragment.qname == text_s:
+                    spaces = int(fragment.attributes.get((TEXTNS, 'c'), 1))
+                    value.append(' ' * spaces)
+                elif fragment.qname == office_annotation:
+                    continue
+                else:
+                    value.append(self._get_cell_string_value(fragment))
+            else:
+                value.append(str(fragment).strip('\n'))
+        return ''.join(value)
+
+# File: pandas-main/pandas/io/excel/_odswriter.py
+from __future__ import annotations
+from collections import defaultdict
+import datetime
+import json
+from typing import TYPE_CHECKING, Any, DefaultDict, cast, overload
+from pandas.io.excel._base import ExcelWriter
+from pandas.io.excel._util import combine_kwargs, validate_freeze_panes
+if TYPE_CHECKING:
+    from odf.opendocument import OpenDocumentSpreadsheet
+    from pandas._typing import ExcelWriterIfSheetExists, FilePath, StorageOptions, WriteExcelBuffer
+    from pandas.io.formats.excel import ExcelCell
+
+class ODSWriter(ExcelWriter):
+    _engine = 'odf'
+    _supported_extensions = ('.ods',)
+
+    def __init__(self, path: FilePath | WriteExcelBuffer | ExcelWriter, engine: str | None=None, date_format: str | None=None, datetime_format: str | None=None, mode: str='w', storage_options: StorageOptions | None=None, if_sheet_exists: ExcelWriterIfSheetExists | None=None, engine_kwargs: dict[str, Any] | None=None, **kwargs: Any) -> None:
+        from odf.opendocument import OpenDocumentSpreadsheet
+        if mode == 'a':
+            raise ValueError('Append mode is not supported with odf!')
+        engine_kwargs = combine_kwargs(engine_kwargs, kwargs)
+        self._book = OpenDocumentSpreadsheet(**engine_kwargs)
+        super().__init__(path, mode=mode, storage_options=storage_options, if_sheet_exists=if_sheet_exists, engine_kwargs=engine_kwargs)
+        self._style_dict: dict[str, str] = {}
+
+    @property
+    def book(self) -> OpenDocumentSpreadsheet:
+        return self._book
+
+    @property
+    def sheets(self) -> dict[str, Any]:
+        from odf.table import Table
+        result = {sheet.getAttribute('name'): sheet for sheet in self.book.getElementsByType(Table)}
+        return result
+
+    def _save(self) -> None:
+        for sheet in self.sheets.values():
+            self.book.spreadsheet.addElement(sheet)
+        self.book.save(self._handles.handle)
+
+    def _write_cells(self, cells: list[ExcelCell], sheet_name: str | None=None, startrow: int=0, startcol: int=0, freeze_panes: tuple[int, int] | None=None) -> None:
+        from odf.table import Table, TableCell, TableRow
+        from odf.text import P
+        sheet_name = self._get_sheet_name(sheet_name)
+        assert sheet_name is not None
+        if sheet_name in self.sheets:
+            wks = self.sheets[sheet_name]
+        else:
+            wks = Table(name=sheet_name)
+            self.book.spreadsheet.addElement(wks)
+        if validate_freeze_panes(freeze_panes):
+            freeze_panes = cast(tuple[int, int], freeze_panes)
+            self._create_freeze_panes(sheet_name, freeze_panes)
+        for _ in range(startrow):
+            wks.addElement(TableRow())
+        rows: DefaultDict = defaultdict(TableRow)
+        col_count: DefaultDict = defaultdict(int)
+        for cell in sorted(cells, key=lambda cell: (cell.row, cell.col)):
+            if not col_count[cell.row]:
+                for _ in range(startcol):
+                    rows[cell.row].addElement(TableCell())
+            for _ in range(cell.col - col_count[cell.row]):
+                rows[cell.row].addElement(TableCell())
+                col_count[cell.row] += 1
+            (pvalue, tc) = self._make_table_cell(cell)
+            rows[cell.row].addElement(tc)
+            col_count[cell.row] += 1
+            p = P(text=pvalue)
+            tc.addElement(p)
+        if len(rows) > 0:
+            for row_nr in range(max(rows.keys()) + 1):
+                wks.addElement(rows[row_nr])
+
+    def _make_table_cell_attributes(self, cell: ExcelCell) -> dict[str, int | str]:
+        attributes: dict[str, int | str] = {}
+        style_name = self._process_style(cell.style)
+        if style_name is not None:
+            attributes['stylename'] = style_name
+        if cell.mergestart is not None and cell.mergeend is not None:
+            attributes['numberrowsspanned'] = max(1, cell.mergestart)
+            attributes['numbercolumnsspanned'] = cell.mergeend
+        return attributes
+
+    def _make_table_cell(self, cell: ExcelCell) -> tuple[object, Any]:
+        from odf.table import TableCell
+        attributes = self._make_table_cell_attributes(cell)
+        (val, fmt) = self._value_with_fmt(cell.val)
+        pvalue = value = val
+        if isinstance(val, bool):
+            value = str(val).lower()
+            pvalue = str(val).upper()
+            return (pvalue, TableCell(valuetype='boolean', booleanvalue=value, attributes=attributes))
+        elif isinstance(val, datetime.datetime):
+            value = val.isoformat()
+            pvalue = val.strftime('%c')
+            return (pvalue, TableCell(valuetype='date', datevalue=value, attributes=attributes))
+        elif isinstance(val, datetime.date):
+            value = f'{val.year}-{val.month:02d}-{val.day:02d}'
+            pvalue = val.strftime('%x')
+            return (pvalue, TableCell(valuetype='date', datevalue=value, attributes=attributes))
+        elif isinstance(val, str):
+            return (pvalue, TableCell(valuetype='string', stringvalue=value, attributes=attributes))
+        else:
+            return (pvalue, TableCell(valuetype='float', value=value, attributes=attributes))
+
+    @overload
+    def _process_style(self, style: dict[str, Any]) -> str:
+        ...
+
+    @overload
+    def _process_style(self, style: None) -> None:
+        ...
+
+    def _process_style(self, style: dict[str, Any] | None) -> str | None:
+        from odf.style import ParagraphProperties, Style, TableCellProperties, TextProperties
+        if style is None:
+            return None
+        style_key = json.dumps(style)
+        if style_key in self._style_dict:
+            return self._style_dict[style_key]
+        name = f'pd{len(self._style_dict) + 1}'
+        self._style_dict[style_key] = name
+        odf_style = Style(name=name, family='table-cell')
+        if 'font' in style:
+            font = style['font']
+            if font.get('bold', False):
+                odf_style.addElement(TextProperties(fontweight='bold'))
+        if 'borders' in style:
+            borders = style['borders']
+            for (side, thickness) in borders.items():
+                thickness_translation = {'thin': '0.75pt solid #000000'}
+                odf_style.addElement(TableCellProperties(attributes={f'border{side}': thickness_translation[thickness]}))
+        if 'alignment' in style:
+            alignment = style['alignment']
+            horizontal = alignment.get('horizontal')
+            if horizontal:
+                odf_style.addElement(ParagraphProperties(textalign=horizontal))
+            vertical = alignment.get('vertical')
+            if vertical:
+                odf_style.addElement(TableCellProperties(verticalalign=vertical))
+        self.book.styles.addElement(odf_style)
+        return name
+
+    def _create_freeze_panes(self, sheet_name: str, freeze_panes: tuple[int, int]) -> None:
+        from odf.config import ConfigItem, ConfigItemMapEntry, ConfigItemMapIndexed, ConfigItemMapNamed, ConfigItemSet
+        config_item_set = ConfigItemSet(name='ooo:view-settings')
+        self.book.settings.addElement(config_item_set)
+        config_item_map_indexed = ConfigItemMapIndexed(name='Views')
+        config_item_set.addElement(config_item_map_indexed)
+        config_item_map_entry = ConfigItemMapEntry()
+        config_item_map_indexed.addElement(config_item_map_entry)
+        config_item_map_named = ConfigItemMapNamed(name='Tables')
+        config_item_map_entry.addElement(config_item_map_named)
+        config_item_map_entry = ConfigItemMapEntry(name=sheet_name)
+        config_item_map_named.addElement(config_item_map_entry)
+        config_item_map_entry.addElement(ConfigItem(name='HorizontalSplitMode', type='short', text='2'))
+        config_item_map_entry.addElement(ConfigItem(name='VerticalSplitMode', type='short', text='2'))
+        config_item_map_entry.addElement(ConfigItem(name='HorizontalSplitPosition', type='int', text=str(freeze_panes[0])))
+        config_item_map_entry.addElement(ConfigItem(name='VerticalSplitPosition', type='int', text=str(freeze_panes[1])))
+        config_item_map_entry.addElement(ConfigItem(name='PositionRight', type='int', text=str(freeze_panes[0])))
+        config_item_map_entry.addElement(ConfigItem(name='PositionBottom', type='int', text=str(freeze_panes[1])))
+
+# File: pandas-main/pandas/io/excel/_openpyxl.py
+from __future__ import annotations
+import mmap
+from typing import TYPE_CHECKING, Any, cast
+import numpy as np
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.excel._base import BaseExcelReader, ExcelWriter
+from pandas.io.excel._util import combine_kwargs, validate_freeze_panes
+if TYPE_CHECKING:
+    from openpyxl import Workbook
+    from openpyxl.descriptors.serialisable import Serialisable
+    from openpyxl.styles import Fill
+    from pandas._typing import ExcelWriterIfSheetExists, FilePath, ReadBuffer, Scalar, StorageOptions, WriteExcelBuffer
+
+class OpenpyxlWriter(ExcelWriter):
+    _engine = 'openpyxl'
+    _supported_extensions = ('.xlsx', '.xlsm')
+
+    def __init__(self, path: FilePath | WriteExcelBuffer | ExcelWriter, engine: str | None=None, date_format: str | None=None, datetime_format: str | None=None, mode: str='w', storage_options: StorageOptions | None=None, if_sheet_exists: ExcelWriterIfSheetExists | None=None, engine_kwargs: dict[str, Any] | None=None, **kwargs) -> None:
+        from openpyxl.workbook import Workbook
+        engine_kwargs = combine_kwargs(engine_kwargs, kwargs)
+        super().__init__(path, mode=mode, storage_options=storage_options, if_sheet_exists=if_sheet_exists, engine_kwargs=engine_kwargs)
+        if 'r+' in self._mode:
+            from openpyxl import load_workbook
+            try:
+                self._book = load_workbook(self._handles.handle, **engine_kwargs)
+            except TypeError:
+                self._handles.handle.close()
+                raise
+            self._handles.handle.seek(0)
+        else:
+            try:
+                self._book = Workbook(**engine_kwargs)
+            except TypeError:
+                self._handles.handle.close()
+                raise
+            if self.book.worksheets:
+                self.book.remove(self.book.worksheets[0])
+
+    @property
+    def book(self) -> Workbook:
+        return self._book
+
+    @property
+    def sheets(self) -> dict[str, Any]:
+        result = {name: self.book[name] for name in self.book.sheetnames}
+        return result
+
+    def _save(self) -> None:
+        self.book.save(self._handles.handle)
+        if 'r+' in self._mode and (not isinstance(self._handles.handle, mmap.mmap)):
+            self._handles.handle.truncate()
+
+    @classmethod
+    def _convert_to_style_kwargs(cls, style_dict: dict) -> dict[str, Serialisable]:
+        _style_key_map = {'borders': 'border'}
+        style_kwargs: dict[str, Serialisable] = {}
+        for (k, v) in style_dict.items():
+            k = _style_key_map.get(k, k)
+            _conv_to_x = getattr(cls, f'_convert_to_{k}', lambda x: None)
+            new_v = _conv_to_x(v)
+            if new_v:
+                style_kwargs[k] = new_v
+        return style_kwargs
+
+    @classmethod
+    def _convert_to_color(cls, color_spec):
+        from openpyxl.styles import Color
+        if isinstance(color_spec, str):
+            return Color(color_spec)
+        else:
+            return Color(**color_spec)
+
+    @classmethod
+    def _convert_to_font(cls, font_dict):
+        from openpyxl.styles import Font
+        _font_key_map = {'sz': 'size', 'b': 'bold', 'i': 'italic', 'u': 'underline', 'strike': 'strikethrough', 'vertalign': 'vertAlign'}
+        font_kwargs = {}
+        for (k, v) in font_dict.items():
+            k = _font_key_map.get(k, k)
+            if k == 'color':
+                v = cls._convert_to_color(v)
+            font_kwargs[k] = v
+        return Font(**font_kwargs)
+
+    @classmethod
+    def _convert_to_stop(cls, stop_seq):
+        return map(cls._convert_to_color, stop_seq)
+
+    @classmethod
+    def _convert_to_fill(cls, fill_dict: dict[str, Any]) -> Fill:
+        from openpyxl.styles import GradientFill, PatternFill
+        _pattern_fill_key_map = {'patternType': 'fill_type', 'patterntype': 'fill_type', 'fgColor': 'start_color', 'fgcolor': 'start_color', 'bgColor': 'end_color', 'bgcolor': 'end_color'}
+        _gradient_fill_key_map = {'fill_type': 'type'}
+        pfill_kwargs = {}
+        gfill_kwargs = {}
+        for (k, v) in fill_dict.items():
+            pk = _pattern_fill_key_map.get(k)
+            gk = _gradient_fill_key_map.get(k)
+            if pk in ['start_color', 'end_color']:
+                v = cls._convert_to_color(v)
+            if gk == 'stop':
+                v = cls._convert_to_stop(v)
+            if pk:
+                pfill_kwargs[pk] = v
+            elif gk:
+                gfill_kwargs[gk] = v
+            else:
+                pfill_kwargs[k] = v
+                gfill_kwargs[k] = v
+        try:
+            return PatternFill(**pfill_kwargs)
+        except TypeError:
+            return GradientFill(**gfill_kwargs)
+
+    @classmethod
+    def _convert_to_side(cls, side_spec):
+        from openpyxl.styles import Side
+        _side_key_map = {'border_style': 'style'}
+        if isinstance(side_spec, str):
+            return Side(style=side_spec)
+        side_kwargs = {}
+        for (k, v) in side_spec.items():
+            k = _side_key_map.get(k, k)
+            if k == 'color':
+                v = cls._convert_to_color(v)
+            side_kwargs[k] = v
+        return Side(**side_kwargs)
+
+    @classmethod
+    def _convert_to_border(cls, border_dict):
+        from openpyxl.styles import Border
+        _border_key_map = {'diagonalup': 'diagonalUp', 'diagonaldown': 'diagonalDown'}
+        border_kwargs = {}
+        for (k, v) in border_dict.items():
+            k = _border_key_map.get(k, k)
+            if k == 'color':
+                v = cls._convert_to_color(v)
+            if k in ['left', 'right', 'top', 'bottom', 'diagonal']:
+                v = cls._convert_to_side(v)
+            border_kwargs[k] = v
+        return Border(**border_kwargs)
+
+    @classmethod
+    def _convert_to_alignment(cls, alignment_dict):
+        from openpyxl.styles import Alignment
+        return Alignment(**alignment_dict)
+
+    @classmethod
+    def _convert_to_number_format(cls, number_format_dict):
+        return number_format_dict['format_code']
+
+    @classmethod
+    def _convert_to_protection(cls, protection_dict):
+        from openpyxl.styles import Protection
+        return Protection(**protection_dict)
+
+    def _write_cells(self, cells, sheet_name: str | None=None, startrow: int=0, startcol: int=0, freeze_panes: tuple[int, int] | None=None) -> None:
+        sheet_name = self._get_sheet_name(sheet_name)
+        _style_cache: dict[str, dict[str, Serialisable]] = {}
+        if sheet_name in self.sheets and self._if_sheet_exists != 'new':
+            if 'r+' in self._mode:
+                if self._if_sheet_exists == 'replace':
+                    old_wks = self.sheets[sheet_name]
+                    target_index = self.book.index(old_wks)
+                    del self.book[sheet_name]
+                    wks = self.book.create_sheet(sheet_name, target_index)
+                elif self._if_sheet_exists == 'error':
+                    raise ValueError(f"Sheet '{sheet_name}' already exists and if_sheet_exists is set to 'error'.")
+                elif self._if_sheet_exists == 'overlay':
+                    wks = self.sheets[sheet_name]
+                else:
+                    raise ValueError(f"'{self._if_sheet_exists}' is not valid for if_sheet_exists. Valid options are 'error', 'new', 'replace' and 'overlay'.")
+            else:
+                wks = self.sheets[sheet_name]
+        else:
+            wks = self.book.create_sheet()
+            wks.title = sheet_name
+        if validate_freeze_panes(freeze_panes):
+            freeze_panes = cast(tuple[int, int], freeze_panes)
+            wks.freeze_panes = wks.cell(row=freeze_panes[0] + 1, column=freeze_panes[1] + 1)
+        for cell in cells:
+            xcell = wks.cell(row=startrow + cell.row + 1, column=startcol + cell.col + 1)
+            (xcell.value, fmt) = self._value_with_fmt(cell.val)
+            if fmt:
+                xcell.number_format = fmt
+            style_kwargs: dict[str, Serialisable] | None = {}
+            if cell.style:
+                key = str(cell.style)
+                style_kwargs = _style_cache.get(key)
+                if style_kwargs is None:
+                    style_kwargs = self._convert_to_style_kwargs(cell.style)
+                    _style_cache[key] = style_kwargs
+            if style_kwargs:
+                for (k, v) in style_kwargs.items():
+                    setattr(xcell, k, v)
+            if cell.mergestart is not None and cell.mergeend is not None:
+                wks.merge_cells(start_row=startrow + cell.row + 1, start_column=startcol + cell.col + 1, end_column=startcol + cell.mergeend + 1, end_row=startrow + cell.mergestart + 1)
+                if style_kwargs:
+                    first_row = startrow + cell.row + 1
+                    last_row = startrow + cell.mergestart + 1
+                    first_col = startcol + cell.col + 1
+                    last_col = startcol + cell.mergeend + 1
+                    for row in range(first_row, last_row + 1):
+                        for col in range(first_col, last_col + 1):
+                            if row == first_row and col == first_col:
+                                continue
+                            xcell = wks.cell(column=col, row=row)
+                            for (k, v) in style_kwargs.items():
+                                setattr(xcell, k, v)
+
+class OpenpyxlReader(BaseExcelReader['Workbook']):
+
+    @doc(storage_options=_shared_docs['storage_options'])
+    def __init__(self, filepath_or_buffer: FilePath | ReadBuffer[bytes], storage_options: StorageOptions | None=None, engine_kwargs: dict | None=None) -> None:
+        import_optional_dependency('openpyxl')
+        super().__init__(filepath_or_buffer, storage_options=storage_options, engine_kwargs=engine_kwargs)
+
+    @property
+    def _workbook_class(self) -> type[Workbook]:
+        from openpyxl import Workbook
+        return Workbook
+
+    def load_workbook(self, filepath_or_buffer: FilePath | ReadBuffer[bytes], engine_kwargs) -> Workbook:
+        from openpyxl import load_workbook
+        default_kwargs = {'read_only': True, 'data_only': True, 'keep_links': False}
+        return load_workbook(filepath_or_buffer, **default_kwargs | engine_kwargs)
+
+    @property
+    def sheet_names(self) -> list[str]:
+        return [sheet.title for sheet in self.book.worksheets]
+
+    def get_sheet_by_name(self, name: str):
+        self.raise_if_bad_sheet_by_name(name)
+        return self.book[name]
+
+    def get_sheet_by_index(self, index: int):
+        self.raise_if_bad_sheet_by_index(index)
+        return self.book.worksheets[index]
+
+    def _convert_cell(self, cell) -> Scalar:
+        from openpyxl.cell.cell import TYPE_ERROR, TYPE_NUMERIC
+        if cell.value is None:
+            return ''
+        elif cell.data_type == TYPE_ERROR:
+            return np.nan
+        elif cell.data_type == TYPE_NUMERIC:
+            val = int(cell.value)
+            if val == cell.value:
+                return val
+            return float(cell.value)
+        return cell.value
+
+    def get_sheet_data(self, sheet, file_rows_needed: int | None=None) -> list[list[Scalar]]:
+        if self.book.read_only:
+            sheet.reset_dimensions()
+        data: list[list[Scalar]] = []
+        last_row_with_data = -1
+        for (row_number, row) in enumerate(sheet.rows):
+            converted_row = [self._convert_cell(cell) for cell in row]
+            while converted_row and converted_row[-1] == '':
+                converted_row.pop()
+            if converted_row:
+                last_row_with_data = row_number
+            data.append(converted_row)
+            if file_rows_needed is not None and len(data) >= file_rows_needed:
+                break
+        data = data[:last_row_with_data + 1]
+        if len(data) > 0:
+            max_width = max((len(data_row) for data_row in data))
+            if min((len(data_row) for data_row in data)) < max_width:
+                empty_cell: list[Scalar] = ['']
+                data = [data_row + (max_width - len(data_row)) * empty_cell for data_row in data]
+        return data
+
+# File: pandas-main/pandas/io/excel/_pyxlsb.py
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.excel._base import BaseExcelReader
+if TYPE_CHECKING:
+    from pyxlsb import Workbook
+    from pandas._typing import FilePath, ReadBuffer, Scalar, StorageOptions
+
+class PyxlsbReader(BaseExcelReader['Workbook']):
+
+    @doc(storage_options=_shared_docs['storage_options'])
+    def __init__(self, filepath_or_buffer: FilePath | ReadBuffer[bytes], storage_options: StorageOptions | None=None, engine_kwargs: dict | None=None) -> None:
+        import_optional_dependency('pyxlsb')
+        super().__init__(filepath_or_buffer, storage_options=storage_options, engine_kwargs=engine_kwargs)
+
+    @property
+    def _workbook_class(self) -> type[Workbook]:
+        from pyxlsb import Workbook
+        return Workbook
+
+    def load_workbook(self, filepath_or_buffer: FilePath | ReadBuffer[bytes], engine_kwargs) -> Workbook:
+        from pyxlsb import open_workbook
+        return open_workbook(filepath_or_buffer, **engine_kwargs)
+
+    @property
+    def sheet_names(self) -> list[str]:
+        return self.book.sheets
+
+    def get_sheet_by_name(self, name: str):
+        self.raise_if_bad_sheet_by_name(name)
+        return self.book.get_sheet(name)
+
+    def get_sheet_by_index(self, index: int):
+        self.raise_if_bad_sheet_by_index(index)
+        return self.book.get_sheet(index + 1)
+
+    def _convert_cell(self, cell) -> Scalar:
+        if cell.v is None:
+            return ''
+        if isinstance(cell.v, float):
+            val = int(cell.v)
+            if val == cell.v:
+                return val
+            else:
+                return float(cell.v)
+        return cell.v
+
+    def get_sheet_data(self, sheet, file_rows_needed: int | None=None) -> list[list[Scalar]]:
+        data: list[list[Scalar]] = []
+        previous_row_number = -1
+        for row in sheet.rows(sparse=True):
+            row_number = row[0].r
+            converted_row = [self._convert_cell(cell) for cell in row]
+            while converted_row and converted_row[-1] == '':
+                converted_row.pop()
+            if converted_row:
+                data.extend([[]] * (row_number - previous_row_number - 1))
+                data.append(converted_row)
+                previous_row_number = row_number
+            if file_rows_needed is not None and len(data) >= file_rows_needed:
+                break
+        if data:
+            max_width = max((len(data_row) for data_row in data))
+            if min((len(data_row) for data_row in data)) < max_width:
+                empty_cell: list[Scalar] = ['']
+                data = [data_row + (max_width - len(data_row)) * empty_cell for data_row in data]
+        return data
+
+# File: pandas-main/pandas/io/excel/_util.py
+from __future__ import annotations
+from collections.abc import Callable, Hashable, Iterable, MutableMapping, Sequence
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, overload
+from pandas.compat._optional import import_optional_dependency
+from pandas.core.dtypes.common import is_integer, is_list_like
+if TYPE_CHECKING:
+    from pandas.io.excel._base import ExcelWriter
+    ExcelWriter_t = type[ExcelWriter]
+    usecols_func = TypeVar('usecols_func', bound=Callable[[Hashable], object])
+_writers: MutableMapping[str, ExcelWriter_t] = {}
+
+def register_writer(klass: ExcelWriter_t) -> None:
+    if not callable(klass):
+        raise ValueError('Can only register callables as engines')
+    engine_name = klass._engine
+    _writers[engine_name] = klass
+
+def get_default_engine(ext: str, mode: Literal['reader', 'writer']='reader') -> str:
+    _default_readers = {'xlsx': 'openpyxl', 'xlsm': 'openpyxl', 'xlsb': 'pyxlsb', 'xls': 'xlrd', 'ods': 'odf'}
+    _default_writers = {'xlsx': 'openpyxl', 'xlsm': 'openpyxl', 'xlsb': 'pyxlsb', 'ods': 'odf'}
+    assert mode in ['reader', 'writer']
+    if mode == 'writer':
+        xlsxwriter = import_optional_dependency('xlsxwriter', errors='warn')
+        if xlsxwriter:
+            _default_writers['xlsx'] = 'xlsxwriter'
+        return _default_writers[ext]
+    else:
+        return _default_readers[ext]
+
+def get_writer(engine_name: str) -> ExcelWriter_t:
+    try:
+        return _writers[engine_name]
+    except KeyError as err:
+        raise ValueError(f"No Excel writer '{engine_name}'") from err
+
+def _excel2num(x: str) -> int:
+    index = 0
+    for c in x.upper().strip():
+        cp = ord(c)
+        if cp < ord('A') or cp > ord('Z'):
+            raise ValueError(f'Invalid column name: {x}')
+        index = index * 26 + cp - ord('A') + 1
+    return index - 1
+
+def _range2cols(areas: str) -> list[int]:
+    cols: list[int] = []
+    for rng in areas.split(','):
+        if ':' in rng:
+            rngs = rng.split(':')
+            cols.extend(range(_excel2num(rngs[0]), _excel2num(rngs[1]) + 1))
+        else:
+            cols.append(_excel2num(rng))
+    return cols
+
+@overload
+def maybe_convert_usecols(usecols: str | list[int]) -> list[int]:
+    ...
+
+@overload
+def maybe_convert_usecols(usecols: list[str]) -> list[str]:
+    ...
+
+@overload
+def maybe_convert_usecols(usecols: usecols_func) -> usecols_func:
+    ...
+
+@overload
+def maybe_convert_usecols(usecols: None) -> None:
+    ...
+
+def maybe_convert_usecols(usecols: str | list[int] | list[str] | usecols_func | None) -> None | list[int] | list[str] | usecols_func:
+    if usecols is None:
+        return usecols
+    if is_integer(usecols):
+        raise ValueError('Passing an integer for `usecols` is no longer supported.  Please pass in a list of int from 0 to `usecols` inclusive instead.')
+    if isinstance(usecols, str):
+        return _range2cols(usecols)
+    return usecols
+
+@overload
+def validate_freeze_panes(freeze_panes: tuple[int, int]) -> Literal[True]:
+    ...
+
+@overload
+def validate_freeze_panes(freeze_panes: None) -> Literal[False]:
+    ...
+
+def validate_freeze_panes(freeze_panes: tuple[int, int] | None) -> bool:
+    if freeze_panes is not None:
+        if len(freeze_panes) == 2 and all((isinstance(item, int) for item in freeze_panes)):
+            return True
+        raise ValueError('freeze_panes must be of form (row, column) where row and column are integers')
+    return False
+
+def fill_mi_header(row: list[Hashable], control_row: list[bool]) -> tuple[list[Hashable], list[bool]]:
+    last = row[0]
+    for i in range(1, len(row)):
+        if not control_row[i]:
+            last = row[i]
+        if row[i] == '' or row[i] is None:
+            row[i] = last
+        else:
+            control_row[i] = False
+            last = row[i]
+    return (row, control_row)
+
+def pop_header_name(row: list[Hashable], index_col: int | Sequence[int]) -> tuple[Hashable | None, list[Hashable]]:
+    if is_list_like(index_col):
+        assert isinstance(index_col, Iterable)
+        i = max(index_col)
+    else:
+        assert not isinstance(index_col, Iterable)
+        i = index_col
+    header_name = row[i]
+    header_name = None if header_name == '' else header_name
+    return (header_name, row[:i] + [''] + row[i + 1:])
+
+def combine_kwargs(engine_kwargs: dict[str, Any] | None, kwargs: dict) -> dict:
+    if engine_kwargs is None:
+        result = {}
+    else:
+        result = engine_kwargs.copy()
+    result.update(kwargs)
+    return result
+
+# File: pandas-main/pandas/io/excel/_xlrd.py
+from __future__ import annotations
+from datetime import time
+import math
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.excel._base import BaseExcelReader
+if TYPE_CHECKING:
+    from xlrd import Book
+    from pandas._typing import Scalar, StorageOptions
+
+class XlrdReader(BaseExcelReader['Book']):
+
+    @doc(storage_options=_shared_docs['storage_options'])
+    def __init__(self, filepath_or_buffer, storage_options: StorageOptions | None=None, engine_kwargs: dict | None=None) -> None:
+        err_msg = 'Install xlrd >= 2.0.1 for xls Excel support'
+        import_optional_dependency('xlrd', extra=err_msg)
+        super().__init__(filepath_or_buffer, storage_options=storage_options, engine_kwargs=engine_kwargs)
+
+    @property
+    def _workbook_class(self) -> type[Book]:
+        from xlrd import Book
+        return Book
+
+    def load_workbook(self, filepath_or_buffer, engine_kwargs) -> Book:
+        from xlrd import open_workbook
+        if hasattr(filepath_or_buffer, 'read'):
+            data = filepath_or_buffer.read()
+            return open_workbook(file_contents=data, **engine_kwargs)
+        else:
+            return open_workbook(filepath_or_buffer, **engine_kwargs)
+
+    @property
+    def sheet_names(self):
+        return self.book.sheet_names()
+
+    def get_sheet_by_name(self, name):
+        self.raise_if_bad_sheet_by_name(name)
+        return self.book.sheet_by_name(name)
+
+    def get_sheet_by_index(self, index):
+        self.raise_if_bad_sheet_by_index(index)
+        return self.book.sheet_by_index(index)
+
+    def get_sheet_data(self, sheet, file_rows_needed: int | None=None) -> list[list[Scalar]]:
+        from xlrd import XL_CELL_BOOLEAN, XL_CELL_DATE, XL_CELL_ERROR, XL_CELL_NUMBER, xldate
+        epoch1904 = self.book.datemode
+
+        def _parse_cell(cell_contents, cell_typ):
+            if cell_typ == XL_CELL_DATE:
+                try:
+                    cell_contents = xldate.xldate_as_datetime(cell_contents, epoch1904)
+                except OverflowError:
+                    return cell_contents
+                year = cell_contents.timetuple()[0:3]
+                if not epoch1904 and year == (1899, 12, 31) or (epoch1904 and year == (1904, 1, 1)):
+                    cell_contents = time(cell_contents.hour, cell_contents.minute, cell_contents.second, cell_contents.microsecond)
+            elif cell_typ == XL_CELL_ERROR:
+                cell_contents = np.nan
+            elif cell_typ == XL_CELL_BOOLEAN:
+                cell_contents = bool(cell_contents)
+            elif cell_typ == XL_CELL_NUMBER:
+                if math.isfinite(cell_contents):
+                    val = int(cell_contents)
+                    if val == cell_contents:
+                        cell_contents = val
+            return cell_contents
+        nrows = sheet.nrows
+        if file_rows_needed is not None:
+            nrows = min(nrows, file_rows_needed)
+        return [[_parse_cell(value, typ) for (value, typ) in zip(sheet.row_values(i), sheet.row_types(i))] for i in range(nrows)]
+
+# File: pandas-main/pandas/io/excel/_xlsxwriter.py
+from __future__ import annotations
+import json
+from typing import TYPE_CHECKING, Any
+from pandas.io.excel._base import ExcelWriter
+from pandas.io.excel._util import combine_kwargs, validate_freeze_panes
+if TYPE_CHECKING:
+    from pandas._typing import ExcelWriterIfSheetExists, FilePath, StorageOptions, WriteExcelBuffer
+
+class _XlsxStyler:
+    STYLE_MAPPING: dict[str, list[tuple[tuple[str, ...], str]]] = {'font': [(('name',), 'font_name'), (('sz',), 'font_size'), (('size',), 'font_size'), (('color', 'rgb'), 'font_color'), (('color',), 'font_color'), (('b',), 'bold'), (('bold',), 'bold'), (('i',), 'italic'), (('italic',), 'italic'), (('u',), 'underline'), (('underline',), 'underline'), (('strike',), 'font_strikeout'), (('vertAlign',), 'font_script'), (('vertalign',), 'font_script')], 'number_format': [(('format_code',), 'num_format'), ((), 'num_format')], 'protection': [(('locked',), 'locked'), (('hidden',), 'hidden')], 'alignment': [(('horizontal',), 'align'), (('vertical',), 'valign'), (('text_rotation',), 'rotation'), (('wrap_text',), 'text_wrap'), (('indent',), 'indent'), (('shrink_to_fit',), 'shrink')], 'fill': [(('patternType',), 'pattern'), (('patterntype',), 'pattern'), (('fill_type',), 'pattern'), (('start_color', 'rgb'), 'fg_color'), (('fgColor', 'rgb'), 'fg_color'), (('fgcolor', 'rgb'), 'fg_color'), (('start_color',), 'fg_color'), (('fgColor',), 'fg_color'), (('fgcolor',), 'fg_color'), (('end_color', 'rgb'), 'bg_color'), (('bgColor', 'rgb'), 'bg_color'), (('bgcolor', 'rgb'), 'bg_color'), (('end_color',), 'bg_color'), (('bgColor',), 'bg_color'), (('bgcolor',), 'bg_color')], 'border': [(('color', 'rgb'), 'border_color'), (('color',), 'border_color'), (('style',), 'border'), (('top', 'color', 'rgb'), 'top_color'), (('top', 'color'), 'top_color'), (('top', 'style'), 'top'), (('top',), 'top'), (('right', 'color', 'rgb'), 'right_color'), (('right', 'color'), 'right_color'), (('right', 'style'), 'right'), (('right',), 'right'), (('bottom', 'color', 'rgb'), 'bottom_color'), (('bottom', 'color'), 'bottom_color'), (('bottom', 'style'), 'bottom'), (('bottom',), 'bottom'), (('left', 'color', 'rgb'), 'left_color'), (('left', 'color'), 'left_color'), (('left', 'style'), 'left'), (('left',), 'left')]}
+
+    @classmethod
+    def convert(cls, style_dict, num_format_str=None) -> dict[str, Any]:
+        props = {}
+        if num_format_str is not None:
+            props['num_format'] = num_format_str
+        if style_dict is None:
+            return props
+        if 'borders' in style_dict:
+            style_dict = style_dict.copy()
+            style_dict['border'] = style_dict.pop('borders')
+        for (style_group_key, style_group) in style_dict.items():
+            for (src, dst) in cls.STYLE_MAPPING.get(style_group_key, []):
+                if dst in props:
+                    continue
+                v = style_group
+                for k in src:
+                    try:
+                        v = v[k]
+                    except (KeyError, TypeError):
+                        break
+                else:
+                    props[dst] = v
+        if isinstance(props.get('pattern'), str):
+            props['pattern'] = 0 if props['pattern'] == 'none' else 1
+        for k in ['border', 'top', 'right', 'bottom', 'left']:
+            if isinstance(props.get(k), str):
+                try:
+                    props[k] = ['none', 'thin', 'medium', 'dashed', 'dotted', 'thick', 'double', 'hair', 'mediumDashed', 'dashDot', 'mediumDashDot', 'dashDotDot', 'mediumDashDotDot', 'slantDashDot'].index(props[k])
+                except ValueError:
+                    props[k] = 2
+        if isinstance(props.get('font_script'), str):
+            props['font_script'] = ['baseline', 'superscript', 'subscript'].index(props['font_script'])
+        if isinstance(props.get('underline'), str):
+            props['underline'] = {'none': 0, 'single': 1, 'double': 2, 'singleAccounting': 33, 'doubleAccounting': 34}[props['underline']]
+        if props.get('valign') == 'center':
+            props['valign'] = 'vcenter'
+        return props
+
+class XlsxWriter(ExcelWriter):
+    _engine = 'xlsxwriter'
+    _supported_extensions = ('.xlsx',)
+
+    def __init__(self, path: FilePath | WriteExcelBuffer | ExcelWriter, engine: str | None=None, date_format: str | None=None, datetime_format: str | None=None, mode: str='w', storage_options: StorageOptions | None=None, if_sheet_exists: ExcelWriterIfSheetExists | None=None, engine_kwargs: dict[str, Any] | None=None, **kwargs) -> None:
+        from xlsxwriter import Workbook
+        engine_kwargs = combine_kwargs(engine_kwargs, kwargs)
+        if mode == 'a':
+            raise ValueError('Append mode is not supported with xlsxwriter!')
+        super().__init__(path, engine=engine, date_format=date_format, datetime_format=datetime_format, mode=mode, storage_options=storage_options, if_sheet_exists=if_sheet_exists, engine_kwargs=engine_kwargs)
+        try:
+            self._book = Workbook(self._handles.handle, **engine_kwargs)
+        except TypeError:
+            self._handles.handle.close()
+            raise
+
+    @property
+    def book(self):
+        return self._book
+
+    @property
+    def sheets(self) -> dict[str, Any]:
+        result = self.book.sheetnames
+        return result
+
+    def _save(self) -> None:
+        self.book.close()
+
+    def _write_cells(self, cells, sheet_name: str | None=None, startrow: int=0, startcol: int=0, freeze_panes: tuple[int, int] | None=None) -> None:
+        sheet_name = self._get_sheet_name(sheet_name)
+        wks = self.book.get_worksheet_by_name(sheet_name)
+        if wks is None:
+            wks = self.book.add_worksheet(sheet_name)
+        style_dict = {'null': None}
+        if validate_freeze_panes(freeze_panes):
+            wks.freeze_panes(*freeze_panes)
+        for cell in cells:
+            (val, fmt) = self._value_with_fmt(cell.val)
+            stylekey = json.dumps(cell.style)
+            if fmt:
+                stylekey += fmt
+            if stylekey in style_dict:
+                style = style_dict[stylekey]
+            else:
+                style = self.book.add_format(_XlsxStyler.convert(cell.style, fmt))
+                style_dict[stylekey] = style
+            if cell.mergestart is not None and cell.mergeend is not None:
+                wks.merge_range(startrow + cell.row, startcol + cell.col, startrow + cell.mergestart, startcol + cell.mergeend, val, style)
+            else:
+                wks.write(startrow + cell.row, startcol + cell.col, val, style)
+
+# File: pandas-main/pandas/io/feather_format.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+import warnings
+from pandas._config import using_string_dtype
+from pandas._libs import lib
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import doc
+from pandas.util._validators import check_dtype_backend
+import pandas as pd
+from pandas.core.api import DataFrame
+from pandas.core.shared_docs import _shared_docs
+from pandas.io._util import arrow_string_types_mapper
+from pandas.io.common import get_handle
+if TYPE_CHECKING:
+    from collections.abc import Hashable, Sequence
+    from pandas._typing import DtypeBackend, FilePath, ReadBuffer, StorageOptions, WriteBuffer
+
+@doc(storage_options=_shared_docs['storage_options'])
+def to_feather(df: DataFrame, path: FilePath | WriteBuffer[bytes], storage_options: StorageOptions | None=None, **kwargs: Any) -> None:
+    import_optional_dependency('pyarrow')
+    from pyarrow import feather
+    if not isinstance(df, DataFrame):
+        raise ValueError('feather only support IO with DataFrames')
+    with get_handle(path, 'wb', storage_options=storage_options, is_text=False) as handles:
+        feather.write_feather(df, handles.handle, **kwargs)
+
+@doc(storage_options=_shared_docs['storage_options'])
+def read_feather(path: FilePath | ReadBuffer[bytes], columns: Sequence[Hashable] | None=None, use_threads: bool=True, storage_options: StorageOptions | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default) -> DataFrame:
+    import_optional_dependency('pyarrow')
+    from pyarrow import feather
+    import pandas.core.arrays.arrow.extension_types
+    check_dtype_backend(dtype_backend)
+    with get_handle(path, 'rb', storage_options=storage_options, is_text=False) as handles:
+        if dtype_backend is lib.no_default and (not using_string_dtype()):
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore', 'make_block is deprecated', DeprecationWarning)
+                return feather.read_feather(handles.handle, columns=columns, use_threads=bool(use_threads))
+        pa_table = feather.read_table(handles.handle, columns=columns, use_threads=bool(use_threads))
+        if dtype_backend == 'numpy_nullable':
+            from pandas.io._util import _arrow_dtype_mapping
+            return pa_table.to_pandas(types_mapper=_arrow_dtype_mapping().get)
+        elif dtype_backend == 'pyarrow':
+            return pa_table.to_pandas(types_mapper=pd.ArrowDtype)
+        elif using_string_dtype():
+            return pa_table.to_pandas(types_mapper=arrow_string_types_mapper())
+        else:
+            raise NotImplementedError
+
+# File: pandas-main/pandas/io/formats/_color_data.py
+from __future__ import annotations
+CSS4_COLORS = {'aliceblue': 'F0F8FF', 'antiquewhite': 'FAEBD7', 'aqua': '00FFFF', 'aquamarine': '7FFFD4', 'azure': 'F0FFFF', 'beige': 'F5F5DC', 'bisque': 'FFE4C4', 'black': '000000', 'blanchedalmond': 'FFEBCD', 'blue': '0000FF', 'blueviolet': '8A2BE2', 'brown': 'A52A2A', 'burlywood': 'DEB887', 'cadetblue': '5F9EA0', 'chartreuse': '7FFF00', 'chocolate': 'D2691E', 'coral': 'FF7F50', 'cornflowerblue': '6495ED', 'cornsilk': 'FFF8DC', 'crimson': 'DC143C', 'cyan': '00FFFF', 'darkblue': '00008B', 'darkcyan': '008B8B', 'darkgoldenrod': 'B8860B', 'darkgray': 'A9A9A9', 'darkgreen': '006400', 'darkgrey': 'A9A9A9', 'darkkhaki': 'BDB76B', 'darkmagenta': '8B008B', 'darkolivegreen': '556B2F', 'darkorange': 'FF8C00', 'darkorchid': '9932CC', 'darkred': '8B0000', 'darksalmon': 'E9967A', 'darkseagreen': '8FBC8F', 'darkslateblue': '483D8B', 'darkslategray': '2F4F4F', 'darkslategrey': '2F4F4F', 'darkturquoise': '00CED1', 'darkviolet': '9400D3', 'deeppink': 'FF1493', 'deepskyblue': '00BFFF', 'dimgray': '696969', 'dimgrey': '696969', 'dodgerblue': '1E90FF', 'firebrick': 'B22222', 'floralwhite': 'FFFAF0', 'forestgreen': '228B22', 'fuchsia': 'FF00FF', 'gainsboro': 'DCDCDC', 'ghostwhite': 'F8F8FF', 'gold': 'FFD700', 'goldenrod': 'DAA520', 'gray': '808080', 'green': '008000', 'greenyellow': 'ADFF2F', 'grey': '808080', 'honeydew': 'F0FFF0', 'hotpink': 'FF69B4', 'indianred': 'CD5C5C', 'indigo': '4B0082', 'ivory': 'FFFFF0', 'khaki': 'F0E68C', 'lavender': 'E6E6FA', 'lavenderblush': 'FFF0F5', 'lawngreen': '7CFC00', 'lemonchiffon': 'FFFACD', 'lightblue': 'ADD8E6', 'lightcoral': 'F08080', 'lightcyan': 'E0FFFF', 'lightgoldenrodyellow': 'FAFAD2', 'lightgray': 'D3D3D3', 'lightgreen': '90EE90', 'lightgrey': 'D3D3D3', 'lightpink': 'FFB6C1', 'lightsalmon': 'FFA07A', 'lightseagreen': '20B2AA', 'lightskyblue': '87CEFA', 'lightslategray': '778899', 'lightslategrey': '778899', 'lightsteelblue': 'B0C4DE', 'lightyellow': 'FFFFE0', 'lime': '00FF00', 'limegreen': '32CD32', 'linen': 'FAF0E6', 'magenta': 'FF00FF', 'maroon': '800000', 'mediumaquamarine': '66CDAA', 'mediumblue': '0000CD', 'mediumorchid': 'BA55D3', 'mediumpurple': '9370DB', 'mediumseagreen': '3CB371', 'mediumslateblue': '7B68EE', 'mediumspringgreen': '00FA9A', 'mediumturquoise': '48D1CC', 'mediumvioletred': 'C71585', 'midnightblue': '191970', 'mintcream': 'F5FFFA', 'mistyrose': 'FFE4E1', 'moccasin': 'FFE4B5', 'navajowhite': 'FFDEAD', 'navy': '000080', 'oldlace': 'FDF5E6', 'olive': '808000', 'olivedrab': '6B8E23', 'orange': 'FFA500', 'orangered': 'FF4500', 'orchid': 'DA70D6', 'palegoldenrod': 'EEE8AA', 'palegreen': '98FB98', 'paleturquoise': 'AFEEEE', 'palevioletred': 'DB7093', 'papayawhip': 'FFEFD5', 'peachpuff': 'FFDAB9', 'peru': 'CD853F', 'pink': 'FFC0CB', 'plum': 'DDA0DD', 'powderblue': 'B0E0E6', 'purple': '800080', 'rebeccapurple': '663399', 'red': 'FF0000', 'rosybrown': 'BC8F8F', 'royalblue': '4169E1', 'saddlebrown': '8B4513', 'salmon': 'FA8072', 'sandybrown': 'F4A460', 'seagreen': '2E8B57', 'seashell': 'FFF5EE', 'sienna': 'A0522D', 'silver': 'C0C0C0', 'skyblue': '87CEEB', 'slateblue': '6A5ACD', 'slategray': '708090', 'slategrey': '708090', 'snow': 'FFFAFA', 'springgreen': '00FF7F', 'steelblue': '4682B4', 'tan': 'D2B48C', 'teal': '008080', 'thistle': 'D8BFD8', 'tomato': 'FF6347', 'turquoise': '40E0D0', 'violet': 'EE82EE', 'wheat': 'F5DEB3', 'white': 'FFFFFF', 'whitesmoke': 'F5F5F5', 'yellow': 'FFFF00', 'yellowgreen': '9ACD32'}
+
+# File: pandas-main/pandas/io/formats/console.py
+""""""
+from __future__ import annotations
+from shutil import get_terminal_size
+
+def get_console_size() -> tuple[int | None, int | None]:
+    from pandas import get_option
+    display_width = get_option('display.width')
+    display_height = get_option('display.max_rows')
+    if in_interactive_session():
+        if in_ipython_frontend():
+            from pandas._config.config import get_default_val
+            terminal_width = get_default_val('display.width')
+            terminal_height = get_default_val('display.max_rows')
+        else:
+            (terminal_width, terminal_height) = get_terminal_size()
+    else:
+        (terminal_width, terminal_height) = (None, None)
+    return (display_width or terminal_width, display_height or terminal_height)
+
+def in_interactive_session() -> bool:
+    from pandas import get_option
+
+    def check_main() -> bool:
+        try:
+            import __main__ as main
+        except ModuleNotFoundError:
+            return get_option('mode.sim_interactive')
+        return not hasattr(main, '__file__') or get_option('mode.sim_interactive')
+    try:
+        return __IPYTHON__ or check_main()
+    except NameError:
+        return check_main()
+
+def in_ipython_frontend() -> bool:
+    try:
+        ip = get_ipython()
+        return 'zmq' in str(type(ip)).lower()
+    except NameError:
+        pass
+    return False
+
+# File: pandas-main/pandas/io/formats/css.py
+""""""
+from __future__ import annotations
+import re
+from typing import TYPE_CHECKING
+import warnings
+from pandas.errors import CSSWarning
+from pandas.util._exceptions import find_stack_level
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator, Iterable, Iterator
+
+def _side_expander(prop_fmt: str) -> Callable:
+
+    def expand(self: CSSResolver, prop: str, value: str) -> Generator[tuple[str, str], None, None]:
+        tokens = value.split()
+        try:
+            mapping = self.SIDE_SHORTHANDS[len(tokens)]
+        except KeyError:
+            warnings.warn(f'Could not expand "{prop}: {value}"', CSSWarning, stacklevel=find_stack_level())
+            return
+        for (key, idx) in zip(self.SIDES, mapping):
+            yield (prop_fmt.format(key), tokens[idx])
+    return expand
+
+def _border_expander(side: str='') -> Callable:
+    if side != '':
+        side = f'-{side}'
+
+    def expand(self: CSSResolver, prop: str, value: str) -> Generator[tuple[str, str], None, None]:
+        tokens = value.split()
+        if len(tokens) == 0 or len(tokens) > 3:
+            warnings.warn(f'Too many tokens provided to "{prop}" (expected 1-3)', CSSWarning, stacklevel=find_stack_level())
+        border_declarations = {f'border{side}-color': 'black', f'border{side}-style': 'none', f'border{side}-width': 'medium'}
+        for token in tokens:
+            if token.lower() in self.BORDER_STYLES:
+                border_declarations[f'border{side}-style'] = token
+            elif any((ratio in token.lower() for ratio in self.BORDER_WIDTH_RATIOS)):
+                border_declarations[f'border{side}-width'] = token
+            else:
+                border_declarations[f'border{side}-color'] = token
+        yield from self.atomize(border_declarations.items())
+    return expand
+
+class CSSResolver:
+    UNIT_RATIOS = {'pt': ('pt', 1), 'em': ('em', 1), 'rem': ('pt', 12), 'ex': ('em', 0.5), 'px': ('pt', 0.75), 'pc': ('pt', 12), 'in': ('pt', 72), 'cm': ('in', 1 / 2.54), 'mm': ('in', 1 / 25.4), 'q': ('mm', 0.25), '!!default': ('em', 0)}
+    FONT_SIZE_RATIOS = UNIT_RATIOS.copy()
+    FONT_SIZE_RATIOS.update({'%': ('em', 0.01), 'xx-small': ('rem', 0.5), 'x-small': ('rem', 0.625), 'small': ('rem', 0.8), 'medium': ('rem', 1), 'large': ('rem', 1.125), 'x-large': ('rem', 1.5), 'xx-large': ('rem', 2), 'smaller': ('em', 1 / 1.2), 'larger': ('em', 1.2), '!!default': ('em', 1)})
+    MARGIN_RATIOS = UNIT_RATIOS.copy()
+    MARGIN_RATIOS.update({'none': ('pt', 0)})
+    BORDER_WIDTH_RATIOS = UNIT_RATIOS.copy()
+    BORDER_WIDTH_RATIOS.update({'none': ('pt', 0), 'thick': ('px', 4), 'medium': ('px', 2), 'thin': ('px', 1)})
+    BORDER_STYLES = ['none', 'hidden', 'dotted', 'dashed', 'solid', 'double', 'groove', 'ridge', 'inset', 'outset', 'mediumdashdot', 'dashdotdot', 'hair', 'mediumdashdotdot', 'dashdot', 'slantdashdot', 'mediumdashed']
+    SIDE_SHORTHANDS = {1: [0, 0, 0, 0], 2: [0, 1, 0, 1], 3: [0, 1, 2, 1], 4: [0, 1, 2, 3]}
+    SIDES = ('top', 'right', 'bottom', 'left')
+    CSS_EXPANSIONS = {**{f'border-{prop}' if prop else 'border': _border_expander(prop) for prop in ['', 'top', 'right', 'bottom', 'left']}, **{f'border-{prop}': _side_expander(f'border-{{:s}}-{prop}') for prop in ['color', 'style', 'width']}, 'margin': _side_expander('margin-{:s}'), 'padding': _side_expander('padding-{:s}')}
+
+    def __call__(self, declarations: str | Iterable[tuple[str, str]], inherited: dict[str, str] | None=None) -> dict[str, str]:
+        if isinstance(declarations, str):
+            declarations = self.parse(declarations)
+        props = dict(self.atomize(declarations))
+        if inherited is None:
+            inherited = {}
+        props = self._update_initial(props, inherited)
+        props = self._update_font_size(props, inherited)
+        return self._update_other_units(props)
+
+    def _update_initial(self, props: dict[str, str], inherited: dict[str, str]) -> dict[str, str]:
+        for (prop, val) in inherited.items():
+            if prop not in props:
+                props[prop] = val
+        new_props = props.copy()
+        for (prop, val) in props.items():
+            if val == 'inherit':
+                val = inherited.get(prop, 'initial')
+            if val in ('initial', None):
+                del new_props[prop]
+            else:
+                new_props[prop] = val
+        return new_props
+
+    def _update_font_size(self, props: dict[str, str], inherited: dict[str, str]) -> dict[str, str]:
+        if props.get('font-size'):
+            props['font-size'] = self.size_to_pt(props['font-size'], self._get_font_size(inherited), conversions=self.FONT_SIZE_RATIOS)
+        return props
+
+    def _get_font_size(self, props: dict[str, str]) -> float | None:
+        if props.get('font-size'):
+            font_size_string = props['font-size']
+            return self._get_float_font_size_from_pt(font_size_string)
+        return None
+
+    def _get_float_font_size_from_pt(self, font_size_string: str) -> float:
+        assert font_size_string.endswith('pt')
+        return float(font_size_string.rstrip('pt'))
+
+    def _update_other_units(self, props: dict[str, str]) -> dict[str, str]:
+        font_size = self._get_font_size(props)
+        for side in self.SIDES:
+            prop = f'border-{side}-width'
+            if prop in props:
+                props[prop] = self.size_to_pt(props[prop], em_pt=font_size, conversions=self.BORDER_WIDTH_RATIOS)
+            for prop in [f'margin-{side}', f'padding-{side}']:
+                if prop in props:
+                    props[prop] = self.size_to_pt(props[prop], em_pt=font_size, conversions=self.MARGIN_RATIOS)
+        return props
+
+    def size_to_pt(self, in_val: str, em_pt: float | None=None, conversions: dict=UNIT_RATIOS) -> str:
+
+        def _error() -> str:
+            warnings.warn(f'Unhandled size: {in_val!r}', CSSWarning, stacklevel=find_stack_level())
+            return self.size_to_pt('1!!default', conversions=conversions)
+        match = re.match('^(\\S*?)([a-zA-Z%!].*)', in_val)
+        if match is None:
+            return _error()
+        (val, unit) = match.groups()
+        if val == '':
+            val = 1
+        else:
+            try:
+                val = float(val)
+            except ValueError:
+                return _error()
+        while unit != 'pt':
+            if unit == 'em':
+                if em_pt is None:
+                    unit = 'rem'
+                else:
+                    val *= em_pt
+                    unit = 'pt'
+                continue
+            try:
+                (unit, mul) = conversions[unit]
+            except KeyError:
+                return _error()
+            val *= mul
+        val = round(val, 5)
+        if int(val) == val:
+            size_fmt = f'{int(val):d}pt'
+        else:
+            size_fmt = f'{val:f}pt'
+        return size_fmt
+
+    def atomize(self, declarations: Iterable) -> Generator[tuple[str, str], None, None]:
+        for (prop, value) in declarations:
+            prop = prop.lower()
+            value = value.lower()
+            if prop in self.CSS_EXPANSIONS:
+                expand = self.CSS_EXPANSIONS[prop]
+                yield from expand(self, prop, value)
+            else:
+                yield (prop, value)
+
+    def parse(self, declarations_str: str) -> Iterator[tuple[str, str]]:
+        for decl in declarations_str.split(';'):
+            if not decl.strip():
+                continue
+            (prop, sep, val) = decl.partition(':')
+            prop = prop.strip().lower()
+            val = val.strip().lower()
+            if sep:
+                yield (prop, val)
+            else:
+                warnings.warn(f'Ill-formatted attribute: expected a colon in {decl!r}', CSSWarning, stacklevel=find_stack_level())
+
+# File: pandas-main/pandas/io/formats/csvs.py
+""""""
+from __future__ import annotations
+from collections.abc import Hashable, Iterable, Iterator, Sequence
+import csv as csvlib
+import os
+from typing import TYPE_CHECKING, Any, cast
+import numpy as np
+from pandas._libs import writers as libwriters
+from pandas._typing import SequenceNotStr
+from pandas.util._decorators import cache_readonly
+from pandas.core.dtypes.generic import ABCDatetimeIndex, ABCIndex, ABCMultiIndex, ABCPeriodIndex
+from pandas.core.dtypes.missing import notna
+from pandas.core.indexes.api import Index
+from pandas.io.common import get_handle
+if TYPE_CHECKING:
+    from pandas._typing import CompressionOptions, FilePath, FloatFormatType, IndexLabel, StorageOptions, WriteBuffer, npt
+    from pandas.io.formats.format import DataFrameFormatter
+_DEFAULT_CHUNKSIZE_CELLS = 100000
+
+class CSVFormatter:
+    cols: npt.NDArray[np.object_]
+
+    def __init__(self, formatter: DataFrameFormatter, path_or_buf: FilePath | WriteBuffer[str] | WriteBuffer[bytes]='', sep: str=',', cols: Sequence[Hashable] | None=None, index_label: IndexLabel | None=None, mode: str='w', encoding: str | None=None, errors: str='strict', compression: CompressionOptions='infer', quoting: int | None=None, lineterminator: str | None='\n', chunksize: int | None=None, quotechar: str | None='"', date_format: str | None=None, doublequote: bool=True, escapechar: str | None=None, storage_options: StorageOptions | None=None) -> None:
+        self.fmt = formatter
+        self.obj = self.fmt.frame
+        self.filepath_or_buffer = path_or_buf
+        self.encoding = encoding
+        self.compression: CompressionOptions = compression
+        self.mode = mode
+        self.storage_options = storage_options
+        self.sep = sep
+        self.index_label = self._initialize_index_label(index_label)
+        self.errors = errors
+        self.quoting = quoting or csvlib.QUOTE_MINIMAL
+        self.quotechar = self._initialize_quotechar(quotechar)
+        self.doublequote = doublequote
+        self.escapechar = escapechar
+        self.lineterminator = lineterminator or os.linesep
+        self.date_format = date_format
+        self.cols = self._initialize_columns(cols)
+        self.chunksize = self._initialize_chunksize(chunksize)
+
+    @property
+    def na_rep(self) -> str:
+        return self.fmt.na_rep
+
+    @property
+    def float_format(self) -> FloatFormatType | None:
+        return self.fmt.float_format
+
+    @property
+    def decimal(self) -> str:
+        return self.fmt.decimal
+
+    @property
+    def header(self) -> bool | SequenceNotStr[str]:
+        return self.fmt.header
+
+    @property
+    def index(self) -> bool:
+        return self.fmt.index
+
+    def _initialize_index_label(self, index_label: IndexLabel | None) -> IndexLabel:
+        if index_label is not False:
+            if index_label is None:
+                return self._get_index_label_from_obj()
+            elif not isinstance(index_label, (list, tuple, np.ndarray, ABCIndex)):
+                return [index_label]
+        return index_label
+
+    def _get_index_label_from_obj(self) -> Sequence[Hashable]:
+        if isinstance(self.obj.index, ABCMultiIndex):
+            return self._get_index_label_multiindex()
+        else:
+            return self._get_index_label_flat()
+
+    def _get_index_label_multiindex(self) -> Sequence[Hashable]:
+        return [name or '' for name in self.obj.index.names]
+
+    def _get_index_label_flat(self) -> Sequence[Hashable]:
+        index_label = self.obj.index.name
+        return [''] if index_label is None else [index_label]
+
+    def _initialize_quotechar(self, quotechar: str | None) -> str | None:
+        if self.quoting != csvlib.QUOTE_NONE:
+            return quotechar
+        return None
+
+    @property
+    def has_mi_columns(self) -> bool:
+        return bool(isinstance(self.obj.columns, ABCMultiIndex))
+
+    def _initialize_columns(self, cols: Iterable[Hashable] | None) -> npt.NDArray[np.object_]:
+        if self.has_mi_columns:
+            if cols is not None:
+                msg = 'cannot specify cols with a MultiIndex on the columns'
+                raise TypeError(msg)
+        if cols is not None:
+            if isinstance(cols, ABCIndex):
+                cols = cols._get_values_for_csv(**self._number_format)
+            else:
+                cols = list(cols)
+            self.obj = self.obj.loc[:, cols]
+        new_cols = self.obj.columns
+        return new_cols._get_values_for_csv(**self._number_format)
+
+    def _initialize_chunksize(self, chunksize: int | None) -> int:
+        if chunksize is None:
+            return _DEFAULT_CHUNKSIZE_CELLS // (len(self.cols) or 1) or 1
+        return int(chunksize)
+
+    @property
+    def _number_format(self) -> dict[str, Any]:
+        return {'na_rep': self.na_rep, 'float_format': self.float_format, 'date_format': self.date_format, 'quoting': self.quoting, 'decimal': self.decimal}
+
+    @cache_readonly
+    def data_index(self) -> Index:
+        data_index = self.obj.index
+        if isinstance(data_index, (ABCDatetimeIndex, ABCPeriodIndex)) and self.date_format is not None:
+            data_index = Index([x.strftime(self.date_format) if notna(x) else '' for x in data_index])
+        elif isinstance(data_index, ABCMultiIndex):
+            data_index = data_index.remove_unused_levels()
+        return data_index
+
+    @property
+    def nlevels(self) -> int:
+        if self.index:
+            return getattr(self.data_index, 'nlevels', 1)
+        else:
+            return 0
+
+    @property
+    def _has_aliases(self) -> bool:
+        return isinstance(self.header, (tuple, list, np.ndarray, ABCIndex))
+
+    @property
+    def _need_to_save_header(self) -> bool:
+        return bool(self._has_aliases or self.header)
+
+    @property
+    def write_cols(self) -> SequenceNotStr[Hashable]:
+        if self._has_aliases:
+            assert not isinstance(self.header, bool)
+            if len(self.header) != len(self.cols):
+                raise ValueError(f'Writing {len(self.cols)} cols but got {len(self.header)} aliases')
+            return self.header
+        else:
+            return cast(SequenceNotStr[Hashable], self.cols)
+
+    @property
+    def encoded_labels(self) -> list[Hashable]:
+        encoded_labels: list[Hashable] = []
+        if self.index and self.index_label:
+            assert isinstance(self.index_label, Sequence)
+            encoded_labels = list(self.index_label)
+        if not self.has_mi_columns or self._has_aliases:
+            encoded_labels += list(self.write_cols)
+        return encoded_labels
+
+    def save(self) -> None:
+        with get_handle(self.filepath_or_buffer, self.mode, encoding=self.encoding, errors=self.errors, compression=self.compression, storage_options=self.storage_options) as handles:
+            self.writer = csvlib.writer(handles.handle, lineterminator=self.lineterminator, delimiter=self.sep, quoting=self.quoting, doublequote=self.doublequote, escapechar=self.escapechar, quotechar=self.quotechar)
+            self._save()
+
+    def _save(self) -> None:
+        if self._need_to_save_header:
+            self._save_header()
+        self._save_body()
+
+    def _save_header(self) -> None:
+        if not self.has_mi_columns or self._has_aliases:
+            self.writer.writerow(self.encoded_labels)
+        else:
+            for row in self._generate_multiindex_header_rows():
+                self.writer.writerow(row)
+
+    def _generate_multiindex_header_rows(self) -> Iterator[list[Hashable]]:
+        columns = self.obj.columns
+        for i in range(columns.nlevels):
+            col_line = []
+            if self.index:
+                col_line.append(columns.names[i])
+                if isinstance(self.index_label, list) and len(self.index_label) > 1:
+                    col_line.extend([''] * (len(self.index_label) - 1))
+            col_line.extend(columns._get_level_values(i))
+            yield col_line
+        if self.encoded_labels and set(self.encoded_labels) != {''}:
+            yield (self.encoded_labels + [''] * len(columns))
+
+    def _save_body(self) -> None:
+        nrows = len(self.data_index)
+        chunks = nrows // self.chunksize + 1
+        for i in range(chunks):
+            start_i = i * self.chunksize
+            end_i = min(start_i + self.chunksize, nrows)
+            if start_i >= end_i:
+                break
+            self._save_chunk(start_i, end_i)
+
+    def _save_chunk(self, start_i: int, end_i: int) -> None:
+        slicer = slice(start_i, end_i)
+        df = self.obj.iloc[slicer]
+        res = df._get_values_for_csv(**self._number_format)
+        data = list(res._iter_column_arrays())
+        ix = self.data_index[slicer]._get_values_for_csv(**self._number_format) if self.nlevels != 0 else np.empty(end_i - start_i)
+        libwriters.write_csv_rows(data, ix, self.nlevels, self.cols, self.writer)
+
+# File: pandas-main/pandas/io/formats/excel.py
+""""""
+from __future__ import annotations
+from collections.abc import Callable, Hashable, Iterable, Mapping, Sequence
+import functools
+import itertools
+import re
+from typing import TYPE_CHECKING, Any, cast
+import warnings
+import numpy as np
+from pandas._libs.lib import is_list_like
+from pandas.util._decorators import doc
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes import missing
+from pandas.core.dtypes.common import is_float, is_scalar
+from pandas import DataFrame, Index, MultiIndex, PeriodIndex
+import pandas.core.common as com
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.formats._color_data import CSS4_COLORS
+from pandas.io.formats.css import CSSResolver, CSSWarning
+from pandas.io.formats.format import get_level_lengths
+from pandas.io.formats.printing import pprint_thing
+if TYPE_CHECKING:
+    from pandas._typing import ExcelWriterMergeCells, FilePath, IndexLabel, StorageOptions, WriteExcelBuffer
+    from pandas import ExcelWriter
+
+class ExcelCell:
+    __fields__ = ('row', 'col', 'val', 'style', 'mergestart', 'mergeend')
+    __slots__ = __fields__
+
+    def __init__(self, row: int, col: int, val, style=None, mergestart: int | None=None, mergeend: int | None=None) -> None:
+        self.row = row
+        self.col = col
+        self.val = val
+        self.style = style
+        self.mergestart = mergestart
+        self.mergeend = mergeend
+
+class CssExcelCell(ExcelCell):
+
+    def __init__(self, row: int, col: int, val, style: dict | None, css_styles: dict[tuple[int, int], list[tuple[str, Any]]] | None, css_row: int, css_col: int, css_converter: Callable | None, **kwargs) -> None:
+        if css_styles and css_converter:
+            declaration_dict = {prop.lower(): val for (prop, val) in css_styles[css_row, css_col]}
+            unique_declarations = frozenset(declaration_dict.items())
+            style = css_converter(unique_declarations)
+        super().__init__(row=row, col=col, val=val, style=style, **kwargs)
+
+class CSSToExcelConverter:
+    NAMED_COLORS = CSS4_COLORS
+    VERTICAL_MAP = {'top': 'top', 'text-top': 'top', 'middle': 'center', 'baseline': 'bottom', 'bottom': 'bottom', 'text-bottom': 'bottom'}
+    BOLD_MAP = {'bold': True, 'bolder': True, '600': True, '700': True, '800': True, '900': True, 'normal': False, 'lighter': False, '100': False, '200': False, '300': False, '400': False, '500': False}
+    ITALIC_MAP = {'normal': False, 'italic': True, 'oblique': True}
+    FAMILY_MAP = {'serif': 1, 'sans-serif': 2, 'cursive': 4, 'fantasy': 5}
+    BORDER_STYLE_MAP = {style.lower(): style for style in ['dashed', 'mediumDashDot', 'dashDotDot', 'hair', 'dotted', 'mediumDashDotDot', 'double', 'dashDot', 'slantDashDot', 'mediumDashed']}
+    inherited: dict[str, str] | None
+
+    def __init__(self, inherited: str | None=None) -> None:
+        if inherited is not None:
+            self.inherited = self.compute_css(inherited)
+        else:
+            self.inherited = None
+        self._call_cached = functools.cache(self._call_uncached)
+    compute_css = CSSResolver()
+
+    def __call__(self, declarations: str | frozenset[tuple[str, str]]) -> dict[str, dict[str, str]]:
+        return self._call_cached(declarations)
+
+    def _call_uncached(self, declarations: str | frozenset[tuple[str, str]]) -> dict[str, dict[str, str]]:
+        properties = self.compute_css(declarations, self.inherited)
+        return self.build_xlstyle(properties)
+
+    def build_xlstyle(self, props: Mapping[str, str]) -> dict[str, dict[str, str]]:
+        out = {'alignment': self.build_alignment(props), 'border': self.build_border(props), 'fill': self.build_fill(props), 'font': self.build_font(props), 'number_format': self.build_number_format(props)}
+
+        def remove_none(d: dict[str, str | None]) -> None:
+            for (k, v) in list(d.items()):
+                if v is None:
+                    del d[k]
+                elif isinstance(v, dict):
+                    remove_none(v)
+                    if not v:
+                        del d[k]
+        remove_none(out)
+        return out
+
+    def build_alignment(self, props: Mapping[str, str]) -> dict[str, bool | str | None]:
+        return {'horizontal': props.get('text-align'), 'vertical': self._get_vertical_alignment(props), 'wrap_text': self._get_is_wrap_text(props)}
+
+    def _get_vertical_alignment(self, props: Mapping[str, str]) -> str | None:
+        vertical_align = props.get('vertical-align')
+        if vertical_align:
+            return self.VERTICAL_MAP.get(vertical_align)
+        return None
+
+    def _get_is_wrap_text(self, props: Mapping[str, str]) -> bool | None:
+        if props.get('white-space') is None:
+            return None
+        return bool(props['white-space'] not in ('nowrap', 'pre', 'pre-line'))
+
+    def build_border(self, props: Mapping[str, str]) -> dict[str, dict[str, str | None]]:
+        return {side: {'style': self._border_style(props.get(f'border-{side}-style'), props.get(f'border-{side}-width'), self.color_to_excel(props.get(f'border-{side}-color'))), 'color': self.color_to_excel(props.get(f'border-{side}-color'))} for side in ['top', 'right', 'bottom', 'left']}
+
+    def _border_style(self, style: str | None, width: str | None, color: str | None) -> str | None:
+        if width is None and style is None and (color is None):
+            return None
+        if width is None and style is None:
+            return 'none'
+        if style in ('none', 'hidden'):
+            return 'none'
+        width_name = self._get_width_name(width)
+        if width_name is None:
+            return 'none'
+        if style in (None, 'groove', 'ridge', 'inset', 'outset', 'solid'):
+            return width_name
+        if style == 'double':
+            return 'double'
+        if style == 'dotted':
+            if width_name in ('hair', 'thin'):
+                return 'dotted'
+            return 'mediumDashDotDot'
+        if style == 'dashed':
+            if width_name in ('hair', 'thin'):
+                return 'dashed'
+            return 'mediumDashed'
+        elif style in self.BORDER_STYLE_MAP:
+            return self.BORDER_STYLE_MAP[style]
+        else:
+            warnings.warn(f'Unhandled border style format: {style!r}', CSSWarning, stacklevel=find_stack_level())
+            return 'none'
+
+    def _get_width_name(self, width_input: str | None) -> str | None:
+        width = self._width_to_float(width_input)
+        if width < 1e-05:
+            return None
+        elif width < 1.3:
+            return 'thin'
+        elif width < 2.8:
+            return 'medium'
+        return 'thick'
+
+    def _width_to_float(self, width: str | None) -> float:
+        if width is None:
+            width = '2pt'
+        return self._pt_to_float(width)
+
+    def _pt_to_float(self, pt_string: str) -> float:
+        assert pt_string.endswith('pt')
+        return float(pt_string.rstrip('pt'))
+
+    def build_fill(self, props: Mapping[str, str]):
+        fill_color = props.get('background-color')
+        if fill_color not in (None, 'transparent', 'none'):
+            return {'fgColor': self.color_to_excel(fill_color), 'patternType': 'solid'}
+
+    def build_number_format(self, props: Mapping[str, str]) -> dict[str, str | None]:
+        fc = props.get('number-format')
+        fc = fc.replace('§', ';') if isinstance(fc, str) else fc
+        return {'format_code': fc}
+
+    def build_font(self, props: Mapping[str, str]) -> dict[str, bool | float | str | None]:
+        font_names = self._get_font_names(props)
+        decoration = self._get_decoration(props)
+        return {'name': font_names[0] if font_names else None, 'family': self._select_font_family(font_names), 'size': self._get_font_size(props), 'bold': self._get_is_bold(props), 'italic': self._get_is_italic(props), 'underline': 'single' if 'underline' in decoration else None, 'strike': 'line-through' in decoration or None, 'color': self.color_to_excel(props.get('color')), 'shadow': self._get_shadow(props)}
+
+    def _get_is_bold(self, props: Mapping[str, str]) -> bool | None:
+        weight = props.get('font-weight')
+        if weight:
+            return self.BOLD_MAP.get(weight)
+        return None
+
+    def _get_is_italic(self, props: Mapping[str, str]) -> bool | None:
+        font_style = props.get('font-style')
+        if font_style:
+            return self.ITALIC_MAP.get(font_style)
+        return None
+
+    def _get_decoration(self, props: Mapping[str, str]) -> Sequence[str]:
+        decoration = props.get('text-decoration')
+        if decoration is not None:
+            return decoration.split()
+        else:
+            return ()
+
+    def _get_underline(self, decoration: Sequence[str]) -> str | None:
+        if 'underline' in decoration:
+            return 'single'
+        return None
+
+    def _get_shadow(self, props: Mapping[str, str]) -> bool | None:
+        if 'text-shadow' in props:
+            return bool(re.search('^[^#(]*[1-9]', props['text-shadow']))
+        return None
+
+    def _get_font_names(self, props: Mapping[str, str]) -> Sequence[str]:
+        font_names_tmp = re.findall('(?x)\n            (\n            "(?:[^"]|\\\\")+"\n            |\n            \'(?:[^\']|\\\\\')+\'\n            |\n            [^\'",]+\n            )(?=,|\\s*$)\n        ', props.get('font-family', ''))
+        font_names = []
+        for name in font_names_tmp:
+            if name[:1] == '"':
+                name = name[1:-1].replace('\\"', '"')
+            elif name[:1] == "'":
+                name = name[1:-1].replace("\\'", "'")
+            else:
+                name = name.strip()
+            if name:
+                font_names.append(name)
+        return font_names
+
+    def _get_font_size(self, props: Mapping[str, str]) -> float | None:
+        size = props.get('font-size')
+        if size is None:
+            return size
+        return self._pt_to_float(size)
+
+    def _select_font_family(self, font_names: Sequence[str]) -> int | None:
+        family = None
+        for name in font_names:
+            family = self.FAMILY_MAP.get(name)
+            if family:
+                break
+        return family
+
+    def color_to_excel(self, val: str | None) -> str | None:
+        if val is None:
+            return None
+        if self._is_hex_color(val):
+            return self._convert_hex_to_excel(val)
+        try:
+            return self.NAMED_COLORS[val]
+        except KeyError:
+            warnings.warn(f'Unhandled color format: {val!r}', CSSWarning, stacklevel=find_stack_level())
+        return None
+
+    def _is_hex_color(self, color_string: str) -> bool:
+        return bool(color_string.startswith('#'))
+
+    def _convert_hex_to_excel(self, color_string: str) -> str:
+        code = color_string.lstrip('#')
+        if self._is_shorthand_color(color_string):
+            return (code[0] * 2 + code[1] * 2 + code[2] * 2).upper()
+        else:
+            return code.upper()
+
+    def _is_shorthand_color(self, color_string: str) -> bool:
+        code = color_string.lstrip('#')
+        if len(code) == 3:
+            return True
+        elif len(code) == 6:
+            return False
+        else:
+            raise ValueError(f'Unexpected color {color_string}')
+
+class ExcelFormatter:
+    max_rows = 2 ** 20
+    max_cols = 2 ** 14
+
+    def __init__(self, df, na_rep: str='', float_format: str | None=None, cols: Sequence[Hashable] | None=None, header: Sequence[Hashable] | bool=True, index: bool=True, index_label: IndexLabel | None=None, merge_cells: ExcelWriterMergeCells=False, inf_rep: str='inf', style_converter: Callable | None=None) -> None:
+        self.rowcounter = 0
+        self.na_rep = na_rep
+        if not isinstance(df, DataFrame):
+            self.styler = df
+            self.styler._compute()
+            df = df.data
+            if style_converter is None:
+                style_converter = CSSToExcelConverter()
+            self.style_converter: Callable | None = style_converter
+        else:
+            self.styler = None
+            self.style_converter = None
+        self.df = df
+        if cols is not None:
+            if not len(Index(cols).intersection(df.columns)):
+                raise KeyError('passes columns are not ALL present dataframe')
+            if len(Index(cols).intersection(df.columns)) != len(set(cols)):
+                raise KeyError("Not all names specified in 'columns' are found")
+            self.df = df.reindex(columns=cols)
+        self.columns = self.df.columns
+        self.float_format = float_format
+        self.index = index
+        self.index_label = index_label
+        self.header = header
+        if not isinstance(merge_cells, bool) and merge_cells != 'columns':
+            raise ValueError(f'Unexpected value for merge_cells={merge_cells!r}.')
+        self.merge_cells = merge_cells
+        self.inf_rep = inf_rep
+
+    def _format_value(self, val):
+        if is_scalar(val) and missing.isna(val):
+            val = self.na_rep
+        elif is_float(val):
+            if missing.isposinf_scalar(val):
+                val = self.inf_rep
+            elif missing.isneginf_scalar(val):
+                val = f'-{self.inf_rep}'
+            elif self.float_format is not None:
+                val = float(self.float_format % val)
+        if getattr(val, 'tzinfo', None) is not None:
+            raise ValueError('Excel does not support datetimes with timezones. Please ensure that datetimes are timezone unaware before writing to Excel.')
+        return val
+
+    def _format_header_mi(self) -> Iterable[ExcelCell]:
+        if self.columns.nlevels > 1:
+            if not self.index:
+                raise NotImplementedError("Writing to Excel with MultiIndex columns and no index ('index'=False) is not yet implemented.")
+        if not (self._has_aliases or self.header):
+            return
+        columns = self.columns
+        level_strs = columns._format_multi(sparsify=self.merge_cells in {True, 'columns'}, include_names=False)
+        level_lengths = get_level_lengths(level_strs)
+        coloffset = 0
+        lnum = 0
+        if self.index and isinstance(self.df.index, MultiIndex):
+            coloffset = self.df.index.nlevels - 1
+        if self.merge_cells in {True, 'columns'}:
+            for (lnum, name) in enumerate(columns.names):
+                yield ExcelCell(row=lnum, col=coloffset, val=name, style=None)
+            for (lnum, (spans, levels, level_codes)) in enumerate(zip(level_lengths, columns.levels, columns.codes)):
+                values = levels.take(level_codes)
+                for (i, span_val) in spans.items():
+                    (mergestart, mergeend) = (None, None)
+                    if span_val > 1:
+                        (mergestart, mergeend) = (lnum, coloffset + i + span_val)
+                    yield CssExcelCell(row=lnum, col=coloffset + i + 1, val=values[i], style=None, css_styles=getattr(self.styler, 'ctx_columns', None), css_row=lnum, css_col=i, css_converter=self.style_converter, mergestart=mergestart, mergeend=mergeend)
+        else:
+            for (i, values) in enumerate(zip(*level_strs)):
+                v = '.'.join(map(pprint_thing, values))
+                yield CssExcelCell(row=lnum, col=coloffset + i + 1, val=v, style=None, css_styles=getattr(self.styler, 'ctx_columns', None), css_row=lnum, css_col=i, css_converter=self.style_converter)
+        self.rowcounter = lnum
+
+    def _format_header_regular(self) -> Iterable[ExcelCell]:
+        if self._has_aliases or self.header:
+            coloffset = 0
+            if self.index:
+                coloffset = 1
+                if isinstance(self.df.index, MultiIndex):
+                    coloffset = len(self.df.index.names)
+            colnames = self.columns
+            if self._has_aliases:
+                self.header = cast(Sequence, self.header)
+                if len(self.header) != len(self.columns):
+                    raise ValueError(f'Writing {len(self.columns)} cols but got {len(self.header)} aliases')
+                colnames = self.header
+            for (colindex, colname) in enumerate(colnames):
+                yield CssExcelCell(row=self.rowcounter, col=colindex + coloffset, val=colname, style=None, css_styles=getattr(self.styler, 'ctx_columns', None), css_row=0, css_col=colindex, css_converter=self.style_converter)
+
+    def _format_header(self) -> Iterable[ExcelCell]:
+        gen: Iterable[ExcelCell]
+        if isinstance(self.columns, MultiIndex):
+            gen = self._format_header_mi()
+        else:
+            gen = self._format_header_regular()
+        gen2: Iterable[ExcelCell] = ()
+        if self.df.index.names:
+            row = [x if x is not None else '' for x in self.df.index.names] + [''] * len(self.columns)
+            if functools.reduce(lambda x, y: x and y, (x != '' for x in row)):
+                gen2 = (ExcelCell(self.rowcounter, colindex, val, None) for (colindex, val) in enumerate(row))
+                self.rowcounter += 1
+        return itertools.chain(gen, gen2)
+
+    def _format_body(self) -> Iterable[ExcelCell]:
+        if isinstance(self.df.index, MultiIndex):
+            return self._format_hierarchical_rows()
+        else:
+            return self._format_regular_rows()
+
+    def _format_regular_rows(self) -> Iterable[ExcelCell]:
+        if self._has_aliases or self.header:
+            self.rowcounter += 1
+        if self.index:
+            if self.index_label and isinstance(self.index_label, (list, tuple, np.ndarray, Index)):
+                index_label = self.index_label[0]
+            elif self.index_label and isinstance(self.index_label, str):
+                index_label = self.index_label
+            else:
+                index_label = self.df.index.names[0]
+            if isinstance(self.columns, MultiIndex):
+                self.rowcounter += 1
+            if index_label and self.header is not False:
+                yield ExcelCell(self.rowcounter - 1, 0, index_label, None)
+            index_values = self.df.index
+            if isinstance(self.df.index, PeriodIndex):
+                index_values = self.df.index.to_timestamp()
+            for (idx, idxval) in enumerate(index_values):
+                yield CssExcelCell(row=self.rowcounter + idx, col=0, val=idxval, style=None, css_styles=getattr(self.styler, 'ctx_index', None), css_row=idx, css_col=0, css_converter=self.style_converter)
+            coloffset = 1
+        else:
+            coloffset = 0
+        yield from self._generate_body(coloffset)
+
+    def _format_hierarchical_rows(self) -> Iterable[ExcelCell]:
+        if self._has_aliases or self.header:
+            self.rowcounter += 1
+        gcolidx = 0
+        if self.index:
+            index_labels = self.df.index.names
+            if self.index_label and isinstance(self.index_label, (list, tuple, np.ndarray, Index)):
+                index_labels = self.index_label
+            if isinstance(self.columns, MultiIndex) and self.merge_cells in {True, 'columns'}:
+                self.rowcounter += 1
+            if com.any_not_none(*index_labels) and self.header is not False:
+                for (cidx, name) in enumerate(index_labels):
+                    yield ExcelCell(self.rowcounter - 1, cidx, name, None)
+            if self.merge_cells and self.merge_cells != 'columns':
+                level_strs = self.df.index._format_multi(sparsify=True, include_names=False)
+                level_lengths = get_level_lengths(level_strs)
+                for (spans, levels, level_codes) in zip(level_lengths, self.df.index.levels, self.df.index.codes):
+                    values = levels.take(level_codes, allow_fill=levels._can_hold_na, fill_value=levels._na_value)
+                    for (i, span_val) in spans.items():
+                        (mergestart, mergeend) = (None, None)
+                        if span_val > 1:
+                            mergestart = self.rowcounter + i + span_val - 1
+                            mergeend = gcolidx
+                        yield CssExcelCell(row=self.rowcounter + i, col=gcolidx, val=values[i], style=None, css_styles=getattr(self.styler, 'ctx_index', None), css_row=i, css_col=gcolidx, css_converter=self.style_converter, mergestart=mergestart, mergeend=mergeend)
+                    gcolidx += 1
+            else:
+                for indexcolvals in zip(*self.df.index):
+                    for (idx, indexcolval) in enumerate(indexcolvals):
+                        yield CssExcelCell(row=self.rowcounter + idx, col=gcolidx, val=indexcolval, style=None, css_styles=getattr(self.styler, 'ctx_index', None), css_row=idx, css_col=gcolidx, css_converter=self.style_converter)
+                    gcolidx += 1
+        yield from self._generate_body(gcolidx)
+
+    @property
+    def _has_aliases(self) -> bool:
+        return is_list_like(self.header)
+
+    def _generate_body(self, coloffset: int) -> Iterable[ExcelCell]:
+        for colidx in range(len(self.columns)):
+            series = self.df.iloc[:, colidx]
+            for (i, val) in enumerate(series):
+                yield CssExcelCell(row=self.rowcounter + i, col=colidx + coloffset, val=val, style=None, css_styles=getattr(self.styler, 'ctx', None), css_row=i, css_col=colidx, css_converter=self.style_converter)
+
+    def get_formatted_cells(self) -> Iterable[ExcelCell]:
+        for cell in itertools.chain(self._format_header(), self._format_body()):
+            cell.val = self._format_value(cell.val)
+            yield cell
+
+    @doc(storage_options=_shared_docs['storage_options'])
+    def write(self, writer: FilePath | WriteExcelBuffer | ExcelWriter, sheet_name: str='Sheet1', startrow: int=0, startcol: int=0, freeze_panes: tuple[int, int] | None=None, engine: str | None=None, storage_options: StorageOptions | None=None, engine_kwargs: dict | None=None) -> None:
+        from pandas.io.excel import ExcelWriter
+        (num_rows, num_cols) = self.df.shape
+        if num_rows > self.max_rows or num_cols > self.max_cols:
+            raise ValueError(f'This sheet is too large! Your sheet size is: {num_rows}, {num_cols} Max sheet size is: {self.max_rows}, {self.max_cols}')
+        if engine_kwargs is None:
+            engine_kwargs = {}
+        formatted_cells = self.get_formatted_cells()
+        if isinstance(writer, ExcelWriter):
+            need_save = False
+        else:
+            writer = ExcelWriter(writer, engine=engine, storage_options=storage_options, engine_kwargs=engine_kwargs)
+            need_save = True
+        try:
+            writer._write_cells(formatted_cells, sheet_name, startrow=startrow, startcol=startcol, freeze_panes=freeze_panes)
+        finally:
+            if need_save:
+                writer.close()
+
+# File: pandas-main/pandas/io/formats/format.py
+""""""
+from __future__ import annotations
+from collections.abc import Callable, Generator, Hashable, Mapping, Sequence
+from contextlib import contextmanager
+from csv import QUOTE_NONE
+from decimal import Decimal
+from functools import partial
+from io import StringIO
+import math
+import re
+from shutil import get_terminal_size
+from typing import TYPE_CHECKING, Any, Final, cast
+import numpy as np
+from pandas._config.config import get_option, set_option
+from pandas._libs import lib
+from pandas._libs.missing import NA
+from pandas._libs.tslibs import NaT, Timedelta, Timestamp
+from pandas._libs.tslibs.nattype import NaTType
+from pandas.core.dtypes.common import is_complex_dtype, is_float, is_integer, is_list_like, is_numeric_dtype, is_scalar
+from pandas.core.dtypes.dtypes import CategoricalDtype, DatetimeTZDtype, ExtensionDtype
+from pandas.core.dtypes.missing import isna, notna
+from pandas.core.arrays import Categorical, DatetimeArray, ExtensionArray, TimedeltaArray
+from pandas.core.arrays.string_ import StringDtype
+from pandas.core.base import PandasObject
+import pandas.core.common as com
+from pandas.core.indexes.api import Index, MultiIndex, PeriodIndex, ensure_index
+from pandas.core.indexes.datetimes import DatetimeIndex
+from pandas.core.indexes.timedeltas import TimedeltaIndex
+from pandas.core.reshape.concat import concat
+from pandas.io.common import check_parent_directory, stringify_path
+from pandas.io.formats import printing
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike, Axes, ColspaceArgType, ColspaceType, CompressionOptions, FilePath, FloatFormatType, FormattersType, IndexLabel, SequenceNotStr, StorageOptions, WriteBuffer
+    from pandas import DataFrame, Series
+common_docstring: Final = "\n        Parameters\n        ----------\n        buf : str, Path or StringIO-like, optional, default None\n            Buffer to write to. If None, the output is returned as a string.\n        columns : array-like, optional, default None\n            The subset of columns to write. Writes all columns by default.\n        col_space : %(col_space_type)s, optional\n            %(col_space)s.\n        header : %(header_type)s, optional\n            %(header)s.\n        index : bool, optional, default True\n            Whether to print index (row) labels.\n        na_rep : str, optional, default 'NaN'\n            String representation of ``NaN`` to use.\n        formatters : list, tuple or dict of one-param. functions, optional\n            Formatter functions to apply to columns' elements by position or\n            name.\n            The result of each function must be a unicode string.\n            List/tuple must be of length equal to the number of columns.\n        float_format : one-parameter function, optional, default None\n            Formatter function to apply to columns' elements if they are\n            floats. This function must return a unicode string and will be\n            applied only to the non-``NaN`` elements, with ``NaN`` being\n            handled by ``na_rep``.\n        sparsify : bool, optional, default True\n            Set to False for a DataFrame with a hierarchical index to print\n            every multiindex key at each row.\n        index_names : bool, optional, default True\n            Prints the names of the indexes.\n        justify : str, default None\n            How to justify the column labels. If None uses the option from\n            the print configuration (controlled by set_option), 'right' out\n            of the box. Valid values are\n\n            * left\n            * right\n            * center\n            * justify\n            * justify-all\n            * start\n            * end\n            * inherit\n            * match-parent\n            * initial\n            * unset.\n        max_rows : int, optional\n            Maximum number of rows to display in the console.\n        max_cols : int, optional\n            Maximum number of columns to display in the console.\n        show_dimensions : bool, default False\n            Display DataFrame dimensions (number of rows by number of columns).\n        decimal : str, default '.'\n            Character recognized as decimal separator, e.g. ',' in Europe.\n    "
+VALID_JUSTIFY_PARAMETERS = ('left', 'right', 'center', 'justify', 'justify-all', 'start', 'end', 'inherit', 'match-parent', 'initial', 'unset')
+return_docstring: Final = '\n        Returns\n        -------\n        str or None\n            If buf is None, returns the result as a string. Otherwise returns\n            None.\n    '
+
+class SeriesFormatter:
+
+    def __init__(self, series: Series, *, length: bool | str=True, header: bool=True, index: bool=True, na_rep: str='NaN', name: bool=False, float_format: str | None=None, dtype: bool=True, max_rows: int | None=None, min_rows: int | None=None) -> None:
+        self.series = series
+        self.buf = StringIO()
+        self.name = name
+        self.na_rep = na_rep
+        self.header = header
+        self.length = length
+        self.index = index
+        self.max_rows = max_rows
+        self.min_rows = min_rows
+        if float_format is None:
+            float_format = get_option('display.float_format')
+        self.float_format = float_format
+        self.dtype = dtype
+        self.adj = printing.get_adjustment()
+        self._chk_truncate()
+
+    def _chk_truncate(self) -> None:
+        self.tr_row_num: int | None
+        min_rows = self.min_rows
+        max_rows = self.max_rows
+        is_truncated_vertically = max_rows and len(self.series) > max_rows
+        series = self.series
+        if is_truncated_vertically:
+            max_rows = cast(int, max_rows)
+            if min_rows:
+                max_rows = min(min_rows, max_rows)
+            if max_rows == 1:
+                row_num = max_rows
+                series = series.iloc[:max_rows]
+            else:
+                row_num = max_rows // 2
+                series = concat((series.iloc[:row_num], series.iloc[-row_num:]))
+            self.tr_row_num = row_num
+        else:
+            self.tr_row_num = None
+        self.tr_series = series
+        self.is_truncated_vertically = is_truncated_vertically
+
+    def _get_footer(self) -> str:
+        name = self.series.name
+        footer = ''
+        index = self.series.index
+        if isinstance(index, (DatetimeIndex, PeriodIndex, TimedeltaIndex)) and index.freq is not None:
+            footer += f'Freq: {index.freqstr}'
+        if self.name is not False and name is not None:
+            if footer:
+                footer += ', '
+            series_name = printing.pprint_thing(name, escape_chars=('\t', '\r', '\n'))
+            footer += f'Name: {series_name}'
+        if self.length is True or (self.length == 'truncate' and self.is_truncated_vertically):
+            if footer:
+                footer += ', '
+            footer += f'Length: {len(self.series)}'
+        if self.dtype is not False and self.dtype is not None:
+            dtype_name = getattr(self.tr_series.dtype, 'name', None)
+            if dtype_name:
+                if footer:
+                    footer += ', '
+                footer += f'dtype: {printing.pprint_thing(dtype_name)}'
+        if isinstance(self.tr_series.dtype, CategoricalDtype):
+            level_info = self.tr_series._values._get_repr_footer()
+            if footer:
+                footer += '\n'
+            footer += level_info
+        return str(footer)
+
+    def _get_formatted_values(self) -> list[str]:
+        return format_array(self.tr_series._values, None, float_format=self.float_format, na_rep=self.na_rep, leading_space=self.index)
+
+    def to_string(self) -> str:
+        series = self.tr_series
+        footer = self._get_footer()
+        if len(series) == 0:
+            return f'{type(self.series).__name__}([], {footer})'
+        index = series.index
+        have_header = _has_names(index)
+        if isinstance(index, MultiIndex):
+            fmt_index = index._format_multi(include_names=True, sparsify=None)
+            adj = printing.get_adjustment()
+            fmt_index = adj.adjoin(2, *fmt_index).split('\n')
+        else:
+            fmt_index = index._format_flat(include_name=True)
+        fmt_values = self._get_formatted_values()
+        if self.is_truncated_vertically:
+            n_header_rows = 0
+            row_num = self.tr_row_num
+            row_num = cast(int, row_num)
+            width = self.adj.len(fmt_values[row_num - 1])
+            if width > 3:
+                dot_str = '...'
+            else:
+                dot_str = '..'
+            dot_str = self.adj.justify([dot_str], width, mode='center')[0]
+            fmt_values.insert(row_num + n_header_rows, dot_str)
+            fmt_index.insert(row_num + 1, '')
+        if self.index:
+            result = self.adj.adjoin(3, *[fmt_index[1:], fmt_values])
+        else:
+            result = self.adj.adjoin(3, fmt_values)
+        if self.header and have_header:
+            result = fmt_index[0] + '\n' + result
+        if footer:
+            result += '\n' + footer
+        return str(''.join(result))
+
+def get_dataframe_repr_params() -> dict[str, Any]:
+    from pandas.io.formats import console
+    if get_option('display.expand_frame_repr'):
+        (line_width, _) = console.get_console_size()
+    else:
+        line_width = None
+    return {'max_rows': get_option('display.max_rows'), 'min_rows': get_option('display.min_rows'), 'max_cols': get_option('display.max_columns'), 'max_colwidth': get_option('display.max_colwidth'), 'show_dimensions': get_option('display.show_dimensions'), 'line_width': line_width}
+
+def get_series_repr_params() -> dict[str, Any]:
+    (width, height) = get_terminal_size()
+    max_rows_opt = get_option('display.max_rows')
+    max_rows = height if max_rows_opt == 0 else max_rows_opt
+    min_rows = height if max_rows_opt == 0 else get_option('display.min_rows')
+    return {'name': True, 'dtype': True, 'min_rows': min_rows, 'max_rows': max_rows, 'length': get_option('display.show_dimensions')}
+
+class DataFrameFormatter:
+    __doc__ = __doc__ if __doc__ else ''
+    __doc__ += common_docstring + return_docstring
+
+    def __init__(self, frame: DataFrame, columns: Axes | None=None, col_space: ColspaceArgType | None=None, header: bool | SequenceNotStr[str]=True, index: bool=True, na_rep: str='NaN', formatters: FormattersType | None=None, justify: str | None=None, float_format: FloatFormatType | None=None, sparsify: bool | None=None, index_names: bool=True, max_rows: int | None=None, min_rows: int | None=None, max_cols: int | None=None, show_dimensions: bool | str=False, decimal: str='.', bold_rows: bool=False, escape: bool=True) -> None:
+        self.frame = frame
+        self.columns = self._initialize_columns(columns)
+        self.col_space = self._initialize_colspace(col_space)
+        self.header = header
+        self.index = index
+        self.na_rep = na_rep
+        self.formatters = self._initialize_formatters(formatters)
+        self.justify = self._initialize_justify(justify)
+        self.float_format = float_format
+        self.sparsify = self._initialize_sparsify(sparsify)
+        self.show_index_names = index_names
+        self.decimal = decimal
+        self.bold_rows = bold_rows
+        self.escape = escape
+        self.max_rows = max_rows
+        self.min_rows = min_rows
+        self.max_cols = max_cols
+        self.show_dimensions = show_dimensions
+        self.max_cols_fitted = self._calc_max_cols_fitted()
+        self.max_rows_fitted = self._calc_max_rows_fitted()
+        self.tr_frame = self.frame
+        self.truncate()
+        self.adj = printing.get_adjustment()
+
+    def get_strcols(self) -> list[list[str]]:
+        strcols = self._get_strcols_without_index()
+        if self.index:
+            str_index = self._get_formatted_index(self.tr_frame)
+            strcols.insert(0, str_index)
+        return strcols
+
+    @property
+    def should_show_dimensions(self) -> bool:
+        return self.show_dimensions is True or (self.show_dimensions == 'truncate' and self.is_truncated)
+
+    @property
+    def is_truncated(self) -> bool:
+        return bool(self.is_truncated_horizontally or self.is_truncated_vertically)
+
+    @property
+    def is_truncated_horizontally(self) -> bool:
+        return bool(self.max_cols_fitted and len(self.columns) > self.max_cols_fitted)
+
+    @property
+    def is_truncated_vertically(self) -> bool:
+        return bool(self.max_rows_fitted and len(self.frame) > self.max_rows_fitted)
+
+    @property
+    def dimensions_info(self) -> str:
+        return f'\n\n[{len(self.frame)} rows x {len(self.frame.columns)} columns]'
+
+    @property
+    def has_index_names(self) -> bool:
+        return _has_names(self.frame.index)
+
+    @property
+    def has_column_names(self) -> bool:
+        return _has_names(self.frame.columns)
+
+    @property
+    def show_row_idx_names(self) -> bool:
+        return all((self.has_index_names, self.index, self.show_index_names))
+
+    @property
+    def show_col_idx_names(self) -> bool:
+        return all((self.has_column_names, self.show_index_names, self.header))
+
+    @property
+    def max_rows_displayed(self) -> int:
+        return min(self.max_rows or len(self.frame), len(self.frame))
+
+    def _initialize_sparsify(self, sparsify: bool | None) -> bool:
+        if sparsify is None:
+            return get_option('display.multi_sparse')
+        return sparsify
+
+    def _initialize_formatters(self, formatters: FormattersType | None) -> FormattersType:
+        if formatters is None:
+            return {}
+        elif len(self.frame.columns) == len(formatters) or isinstance(formatters, dict):
+            return formatters
+        else:
+            raise ValueError(f'Formatters length({len(formatters)}) should match DataFrame number of columns({len(self.frame.columns)})')
+
+    def _initialize_justify(self, justify: str | None) -> str:
+        if justify is None:
+            return get_option('display.colheader_justify')
+        else:
+            return justify
+
+    def _initialize_columns(self, columns: Axes | None) -> Index:
+        if columns is not None:
+            cols = ensure_index(columns)
+            self.frame = self.frame[cols]
+            return cols
+        else:
+            return self.frame.columns
+
+    def _initialize_colspace(self, col_space: ColspaceArgType | None) -> ColspaceType:
+        result: ColspaceType
+        if col_space is None:
+            result = {}
+        elif isinstance(col_space, (int, str)):
+            result = {'': col_space}
+            result.update({column: col_space for column in self.frame.columns})
+        elif isinstance(col_space, Mapping):
+            for column in col_space.keys():
+                if column not in self.frame.columns and column != '':
+                    raise ValueError(f'Col_space is defined for an unknown column: {column}')
+            result = col_space
+        else:
+            if len(self.frame.columns) != len(col_space):
+                raise ValueError(f'Col_space length({len(col_space)}) should match DataFrame number of columns({len(self.frame.columns)})')
+            result = dict(zip(self.frame.columns, col_space))
+        return result
+
+    def _calc_max_cols_fitted(self) -> int | None:
+        if not self._is_in_terminal():
+            return self.max_cols
+        (width, _) = get_terminal_size()
+        if self._is_screen_narrow(width):
+            return width
+        else:
+            return self.max_cols
+
+    def _calc_max_rows_fitted(self) -> int | None:
+        max_rows: int | None
+        if self._is_in_terminal():
+            (_, height) = get_terminal_size()
+            if self.max_rows == 0:
+                return height - self._get_number_of_auxiliary_rows()
+            if self._is_screen_short(height):
+                max_rows = height
+            else:
+                max_rows = self.max_rows
+        else:
+            max_rows = self.max_rows
+        return self._adjust_max_rows(max_rows)
+
+    def _adjust_max_rows(self, max_rows: int | None) -> int | None:
+        if max_rows:
+            if len(self.frame) > max_rows and self.min_rows:
+                max_rows = min(self.min_rows, max_rows)
+        return max_rows
+
+    def _is_in_terminal(self) -> bool:
+        return bool(self.max_cols == 0 or self.max_rows == 0)
+
+    def _is_screen_narrow(self, max_width) -> bool:
+        return bool(self.max_cols == 0 and len(self.frame.columns) > max_width)
+
+    def _is_screen_short(self, max_height) -> bool:
+        return bool(self.max_rows == 0 and len(self.frame) > max_height)
+
+    def _get_number_of_auxiliary_rows(self) -> int:
+        dot_row = 1
+        prompt_row = 1
+        num_rows = dot_row + prompt_row
+        if self.show_dimensions:
+            num_rows += len(self.dimensions_info.splitlines())
+        if self.header:
+            num_rows += 1
+        return num_rows
+
+    def truncate(self) -> None:
+        if self.is_truncated_horizontally:
+            self._truncate_horizontally()
+        if self.is_truncated_vertically:
+            self._truncate_vertically()
+
+    def _truncate_horizontally(self) -> None:
+        assert self.max_cols_fitted is not None
+        col_num = self.max_cols_fitted // 2
+        if col_num >= 1:
+            left = self.tr_frame.iloc[:, :col_num]
+            right = self.tr_frame.iloc[:, -col_num:]
+            self.tr_frame = concat((left, right), axis=1)
+            if isinstance(self.formatters, (list, tuple)):
+                self.formatters = [*self.formatters[:col_num], *self.formatters[-col_num:]]
+        else:
+            col_num = cast(int, self.max_cols)
+            self.tr_frame = self.tr_frame.iloc[:, :col_num]
+        self.tr_col_num = col_num
+
+    def _truncate_vertically(self) -> None:
+        assert self.max_rows_fitted is not None
+        row_num = self.max_rows_fitted // 2
+        if row_num >= 1:
+            _len = len(self.tr_frame)
+            _slice = np.hstack([np.arange(row_num), np.arange(_len - row_num, _len)])
+            self.tr_frame = self.tr_frame.iloc[_slice]
+        else:
+            row_num = cast(int, self.max_rows)
+            self.tr_frame = self.tr_frame.iloc[:row_num, :]
+        self.tr_row_num = row_num
+
+    def _get_strcols_without_index(self) -> list[list[str]]:
+        strcols: list[list[str]] = []
+        if not is_list_like(self.header) and (not self.header):
+            for (i, c) in enumerate(self.tr_frame):
+                fmt_values = self.format_col(i)
+                fmt_values = _make_fixed_width(strings=fmt_values, justify=self.justify, minimum=int(self.col_space.get(c, 0)), adj=self.adj)
+                strcols.append(fmt_values)
+            return strcols
+        if is_list_like(self.header):
+            self.header = cast(list[str], self.header)
+            if len(self.header) != len(self.columns):
+                raise ValueError(f'Writing {len(self.columns)} cols but got {len(self.header)} aliases')
+            str_columns = [[label] for label in self.header]
+        else:
+            str_columns = self._get_formatted_column_labels(self.tr_frame)
+        if self.show_row_idx_names:
+            for x in str_columns:
+                x.append('')
+        for (i, c) in enumerate(self.tr_frame):
+            cheader = str_columns[i]
+            header_colwidth = max(int(self.col_space.get(c, 0)), *(self.adj.len(x) for x in cheader))
+            fmt_values = self.format_col(i)
+            fmt_values = _make_fixed_width(fmt_values, self.justify, minimum=header_colwidth, adj=self.adj)
+            max_len = max(*(self.adj.len(x) for x in fmt_values), header_colwidth)
+            cheader = self.adj.justify(cheader, max_len, mode=self.justify)
+            strcols.append(cheader + fmt_values)
+        return strcols
+
+    def format_col(self, i: int) -> list[str]:
+        frame = self.tr_frame
+        formatter = self._get_formatter(i)
+        return format_array(frame.iloc[:, i]._values, formatter, float_format=self.float_format, na_rep=self.na_rep, space=self.col_space.get(frame.columns[i]), decimal=self.decimal, leading_space=self.index)
+
+    def _get_formatter(self, i: str | int) -> Callable | None:
+        if isinstance(self.formatters, (list, tuple)):
+            if is_integer(i):
+                i = cast(int, i)
+                return self.formatters[i]
+            else:
+                return None
+        else:
+            if is_integer(i) and i not in self.columns:
+                i = self.columns[i]
+            return self.formatters.get(i, None)
+
+    def _get_formatted_column_labels(self, frame: DataFrame) -> list[list[str]]:
+        from pandas.core.indexes.multi import sparsify_labels
+        columns = frame.columns
+        if isinstance(columns, MultiIndex):
+            fmt_columns = columns._format_multi(sparsify=False, include_names=False)
+            if self.sparsify and len(fmt_columns):
+                fmt_columns = sparsify_labels(fmt_columns)
+            str_columns = [list(x) for x in zip(*fmt_columns)]
+        else:
+            fmt_columns = columns._format_flat(include_name=False)
+            str_columns = [[' ' + x if not self._get_formatter(i) and is_numeric_dtype(dtype) else x] for (i, (x, dtype)) in enumerate(zip(fmt_columns, self.frame.dtypes))]
+        return str_columns
+
+    def _get_formatted_index(self, frame: DataFrame) -> list[str]:
+        col_space = {k: cast(int, v) for (k, v) in self.col_space.items()}
+        index = frame.index
+        columns = frame.columns
+        fmt = self._get_formatter('__index__')
+        if isinstance(index, MultiIndex):
+            fmt_index = index._format_multi(sparsify=self.sparsify, include_names=self.show_row_idx_names, formatter=fmt)
+        else:
+            fmt_index = [index._format_flat(include_name=self.show_row_idx_names, formatter=fmt)]
+        fmt_index = [tuple(_make_fixed_width(list(x), justify='left', minimum=col_space.get('', 0), adj=self.adj)) for x in fmt_index]
+        adjoined = self.adj.adjoin(1, *fmt_index).split('\n')
+        if self.show_col_idx_names:
+            col_header = [str(x) for x in self._get_column_name_list()]
+        else:
+            col_header = [''] * columns.nlevels
+        if self.header:
+            return col_header + adjoined
+        else:
+            return adjoined
+
+    def _get_column_name_list(self) -> list[Hashable]:
+        names: list[Hashable] = []
+        columns = self.frame.columns
+        if isinstance(columns, MultiIndex):
+            names.extend(('' if name is None else name for name in columns.names))
+        else:
+            names.append('' if columns.name is None else columns.name)
+        return names
+
+class DataFrameRenderer:
+
+    def __init__(self, fmt: DataFrameFormatter) -> None:
+        self.fmt = fmt
+
+    def to_html(self, buf: FilePath | WriteBuffer[str] | None=None, encoding: str | None=None, classes: str | list | tuple | None=None, notebook: bool=False, border: int | bool | None=None, table_id: str | None=None, render_links: bool=False) -> str | None:
+        from pandas.io.formats.html import HTMLFormatter, NotebookFormatter
+        Klass = NotebookFormatter if notebook else HTMLFormatter
+        html_formatter = Klass(self.fmt, classes=classes, border=border, table_id=table_id, render_links=render_links)
+        string = html_formatter.to_string()
+        return save_to_buffer(string, buf=buf, encoding=encoding)
+
+    def to_string(self, buf: FilePath | WriteBuffer[str] | None=None, encoding: str | None=None, line_width: int | None=None) -> str | None:
+        from pandas.io.formats.string import StringFormatter
+        string_formatter = StringFormatter(self.fmt, line_width=line_width)
+        string = string_formatter.to_string()
+        return save_to_buffer(string, buf=buf, encoding=encoding)
+
+    def to_csv(self, path_or_buf: FilePath | WriteBuffer[bytes] | WriteBuffer[str] | None=None, encoding: str | None=None, sep: str=',', columns: Sequence[Hashable] | None=None, index_label: IndexLabel | None=None, mode: str='w', compression: CompressionOptions='infer', quoting: int | None=None, quotechar: str='"', lineterminator: str | None=None, chunksize: int | None=None, date_format: str | None=None, doublequote: bool=True, escapechar: str | None=None, errors: str='strict', storage_options: StorageOptions | None=None) -> str | None:
+        from pandas.io.formats.csvs import CSVFormatter
+        if path_or_buf is None:
+            created_buffer = True
+            path_or_buf = StringIO()
+        else:
+            created_buffer = False
+        csv_formatter = CSVFormatter(path_or_buf=path_or_buf, lineterminator=lineterminator, sep=sep, encoding=encoding, errors=errors, compression=compression, quoting=quoting, cols=columns, index_label=index_label, mode=mode, chunksize=chunksize, quotechar=quotechar, date_format=date_format, doublequote=doublequote, escapechar=escapechar, storage_options=storage_options, formatter=self.fmt)
+        csv_formatter.save()
+        if created_buffer:
+            assert isinstance(path_or_buf, StringIO)
+            content = path_or_buf.getvalue()
+            path_or_buf.close()
+            return content
+        return None
+
+def save_to_buffer(string: str, buf: FilePath | WriteBuffer[str] | None=None, encoding: str | None=None) -> str | None:
+    with _get_buffer(buf, encoding=encoding) as fd:
+        fd.write(string)
+        if buf is None:
+            return fd.getvalue()
+        return None
+
+@contextmanager
+def _get_buffer(buf: FilePath | WriteBuffer[str] | None, encoding: str | None=None) -> Generator[WriteBuffer[str], None, None] | Generator[StringIO, None, None]:
+    if buf is not None:
+        buf = stringify_path(buf)
+    else:
+        buf = StringIO()
+    if encoding is None:
+        encoding = 'utf-8'
+    elif not isinstance(buf, str):
+        raise ValueError('buf is not a file name and encoding is specified.')
+    if hasattr(buf, 'write'):
+        yield buf
+    elif isinstance(buf, str):
+        check_parent_directory(str(buf))
+        with open(buf, 'w', encoding=encoding, newline='') as f:
+            yield f
+    else:
+        raise TypeError('buf is not a file name and it has no write method')
+
+def format_array(values: ArrayLike, formatter: Callable | None, float_format: FloatFormatType | None=None, na_rep: str='NaN', digits: int | None=None, space: str | int | None=None, justify: str='right', decimal: str='.', leading_space: bool | None=True, quoting: int | None=None, fallback_formatter: Callable | None=None) -> list[str]:
+    fmt_klass: type[_GenericArrayFormatter]
+    if lib.is_np_dtype(values.dtype, 'M'):
+        fmt_klass = _Datetime64Formatter
+        values = cast(DatetimeArray, values)
+    elif isinstance(values.dtype, DatetimeTZDtype):
+        fmt_klass = _Datetime64TZFormatter
+        values = cast(DatetimeArray, values)
+    elif lib.is_np_dtype(values.dtype, 'm'):
+        fmt_klass = _Timedelta64Formatter
+        values = cast(TimedeltaArray, values)
+    elif isinstance(values.dtype, ExtensionDtype):
+        fmt_klass = _ExtensionArrayFormatter
+    elif lib.is_np_dtype(values.dtype, 'fc'):
+        fmt_klass = FloatArrayFormatter
+    elif lib.is_np_dtype(values.dtype, 'iu'):
+        fmt_klass = _IntArrayFormatter
+    else:
+        fmt_klass = _GenericArrayFormatter
+    if space is None:
+        space = 12
+    if float_format is None:
+        float_format = get_option('display.float_format')
+    if digits is None:
+        digits = get_option('display.precision')
+    fmt_obj = fmt_klass(values, digits=digits, na_rep=na_rep, float_format=float_format, formatter=formatter, space=space, justify=justify, decimal=decimal, leading_space=leading_space, quoting=quoting, fallback_formatter=fallback_formatter)
+    return fmt_obj.get_result()
+
+class _GenericArrayFormatter:
+
+    def __init__(self, values: ArrayLike, digits: int=7, formatter: Callable | None=None, na_rep: str='NaN', space: str | int=12, float_format: FloatFormatType | None=None, justify: str='right', decimal: str='.', quoting: int | None=None, fixed_width: bool=True, leading_space: bool | None=True, fallback_formatter: Callable | None=None) -> None:
+        self.values = values
+        self.digits = digits
+        self.na_rep = na_rep
+        self.space = space
+        self.formatter = formatter
+        self.float_format = float_format
+        self.justify = justify
+        self.decimal = decimal
+        self.quoting = quoting
+        self.fixed_width = fixed_width
+        self.leading_space = leading_space
+        self.fallback_formatter = fallback_formatter
+
+    def get_result(self) -> list[str]:
+        fmt_values = self._format_strings()
+        return _make_fixed_width(fmt_values, self.justify)
+
+    def _format_strings(self) -> list[str]:
+        if self.float_format is None:
+            float_format = get_option('display.float_format')
+            if float_format is None:
+                precision = get_option('display.precision')
+                float_format = lambda x: _trim_zeros_single_float(f'{x: .{precision:d}f}')
+        else:
+            float_format = self.float_format
+        if self.formatter is not None:
+            formatter = self.formatter
+        elif self.fallback_formatter is not None:
+            formatter = self.fallback_formatter
+        else:
+            quote_strings = self.quoting is not None and self.quoting != QUOTE_NONE
+            formatter = partial(printing.pprint_thing, escape_chars=('\t', '\r', '\n'), quote_strings=quote_strings)
+
+        def _format(x):
+            if self.na_rep is not None and is_scalar(x) and isna(x):
+                if x is None:
+                    return 'None'
+                elif x is NA:
+                    return str(NA)
+                elif x is NaT or isinstance(x, (np.datetime64, np.timedelta64)):
+                    return 'NaT'
+                return self.na_rep
+            elif isinstance(x, PandasObject):
+                return str(x)
+            elif isinstance(x, StringDtype):
+                return repr(x)
+            else:
+                return str(formatter(x))
+        vals = self.values
+        if not isinstance(vals, np.ndarray):
+            raise TypeError('ExtensionArray formatting should use _ExtensionArrayFormatter')
+        inferred = lib.map_infer(vals, is_float)
+        is_float_type = inferred & np.all(notna(vals), axis=tuple(range(1, len(vals.shape))))
+        leading_space = self.leading_space
+        if leading_space is None:
+            leading_space = is_float_type.any()
+        fmt_values = []
+        for (i, v) in enumerate(vals):
+            if (not is_float_type[i] or self.formatter is not None) and leading_space:
+                fmt_values.append(f' {_format(v)}')
+            elif is_float_type[i]:
+                fmt_values.append(float_format(v))
+            else:
+                if leading_space is False:
+                    tpl = '{v}'
+                else:
+                    tpl = ' {v}'
+                fmt_values.append(tpl.format(v=_format(v)))
+        return fmt_values
+
+class FloatArrayFormatter(_GenericArrayFormatter):
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        if self.float_format is not None and self.formatter is None:
+            self.fixed_width = False
+            if callable(self.float_format):
+                self.formatter = self.float_format
+                self.float_format = None
+
+    def _value_formatter(self, float_format: FloatFormatType | None=None, threshold: float | None=None) -> Callable:
+        if float_format is None:
+            float_format = self.float_format
+        if float_format:
+
+            def base_formatter(v):
+                assert float_format is not None
+                return float_format(value=v) if notna(v) else self.na_rep
+        else:
+
+            def base_formatter(v):
+                return str(v) if notna(v) else self.na_rep
+        if self.decimal != '.':
+
+            def decimal_formatter(v):
+                return base_formatter(v).replace('.', self.decimal, 1)
+        else:
+            decimal_formatter = base_formatter
+        if threshold is None:
+            return decimal_formatter
+
+        def formatter(value):
+            if notna(value):
+                if abs(value) > threshold:
+                    return decimal_formatter(value)
+                else:
+                    return decimal_formatter(0.0)
+            else:
+                return self.na_rep
+        return formatter
+
+    def get_result_as_array(self) -> np.ndarray:
+
+        def format_with_na_rep(values: ArrayLike, formatter: Callable, na_rep: str) -> np.ndarray:
+            mask = isna(values)
+            formatted = np.array([formatter(val) if not m else na_rep for (val, m) in zip(values.ravel(), mask.ravel())]).reshape(values.shape)
+            return formatted
+
+        def format_complex_with_na_rep(values: ArrayLike, formatter: Callable, na_rep: str) -> np.ndarray:
+            real_values = np.real(values).ravel()
+            imag_values = np.imag(values).ravel()
+            (real_mask, imag_mask) = (isna(real_values), isna(imag_values))
+            formatted_lst = []
+            for (val, real_val, imag_val, re_isna, im_isna) in zip(values.ravel(), real_values, imag_values, real_mask, imag_mask):
+                if not re_isna and (not im_isna):
+                    formatted_lst.append(formatter(val))
+                elif not re_isna:
+                    formatted_lst.append(f'{formatter(real_val)}+{na_rep}j')
+                elif not im_isna:
+                    imag_formatted = formatter(imag_val).strip()
+                    if imag_formatted.startswith('-'):
+                        formatted_lst.append(f'{na_rep}{imag_formatted}j')
+                    else:
+                        formatted_lst.append(f'{na_rep}+{imag_formatted}j')
+                else:
+                    formatted_lst.append(f'{na_rep}+{na_rep}j')
+            return np.array(formatted_lst).reshape(values.shape)
+        if self.formatter is not None:
+            return format_with_na_rep(self.values, self.formatter, self.na_rep)
+        if self.fixed_width:
+            threshold = get_option('display.chop_threshold')
+        else:
+            threshold = None
+
+        def format_values_with(float_format):
+            formatter = self._value_formatter(float_format, threshold)
+            na_rep = ' ' + self.na_rep if self.justify == 'left' else self.na_rep
+            values = self.values
+            is_complex = is_complex_dtype(values)
+            if is_complex:
+                values = format_complex_with_na_rep(values, formatter, na_rep)
+            else:
+                values = format_with_na_rep(values, formatter, na_rep)
+            if self.fixed_width:
+                if is_complex:
+                    result = _trim_zeros_complex(values, self.decimal)
+                else:
+                    result = _trim_zeros_float(values, self.decimal)
+                return np.asarray(result, dtype='object')
+            return values
+        float_format: FloatFormatType | None
+        if self.float_format is None:
+            if self.fixed_width:
+                if self.leading_space is True:
+                    fmt_str = '{value: .{digits:d}f}'
+                else:
+                    fmt_str = '{value:.{digits:d}f}'
+                float_format = partial(fmt_str.format, digits=self.digits)
+            else:
+                float_format = self.float_format
+        else:
+            float_format = lambda value: self.float_format % value
+        formatted_values = format_values_with(float_format)
+        if not self.fixed_width:
+            return formatted_values
+        if len(formatted_values) > 0:
+            maxlen = max((len(x) for x in formatted_values))
+            too_long = maxlen > self.digits + 6
+        else:
+            too_long = False
+        abs_vals = np.abs(self.values)
+        has_large_values = (abs_vals > 1000000.0).any()
+        has_small_values = ((abs_vals < 10 ** (-self.digits)) & (abs_vals > 0)).any()
+        if has_small_values or (too_long and has_large_values):
+            if self.leading_space is True:
+                fmt_str = '{value: .{digits:d}e}'
+            else:
+                fmt_str = '{value:.{digits:d}e}'
+            float_format = partial(fmt_str.format, digits=self.digits)
+            formatted_values = format_values_with(float_format)
+        return formatted_values
+
+    def _format_strings(self) -> list[str]:
+        return list(self.get_result_as_array())
+
+class _IntArrayFormatter(_GenericArrayFormatter):
+
+    def _format_strings(self) -> list[str]:
+        if self.leading_space is False:
+            formatter_str = lambda x: f'{x:d}'.format(x=x)
+        else:
+            formatter_str = lambda x: f'{x: d}'.format(x=x)
+        formatter = self.formatter or formatter_str
+        fmt_values = [formatter(x) for x in self.values]
+        return fmt_values
+
+class _Datetime64Formatter(_GenericArrayFormatter):
+    values: DatetimeArray
+
+    def __init__(self, values: DatetimeArray, nat_rep: str='NaT', date_format: None=None, **kwargs) -> None:
+        super().__init__(values, **kwargs)
+        self.nat_rep = nat_rep
+        self.date_format = date_format
+
+    def _format_strings(self) -> list[str]:
+        values = self.values
+        if self.formatter is not None:
+            return [self.formatter(x) for x in values]
+        fmt_values = values._format_native_types(na_rep=self.nat_rep, date_format=self.date_format)
+        return fmt_values.tolist()
+
+class _ExtensionArrayFormatter(_GenericArrayFormatter):
+    values: ExtensionArray
+
+    def _format_strings(self) -> list[str]:
+        values = self.values
+        formatter = self.formatter
+        fallback_formatter = None
+        if formatter is None:
+            fallback_formatter = values._formatter(boxed=True)
+        if isinstance(values, Categorical):
+            array = values._internal_get_values()
+        else:
+            array = np.asarray(values, dtype=object)
+        fmt_values = format_array(array, formatter, float_format=self.float_format, na_rep=self.na_rep, digits=self.digits, space=self.space, justify=self.justify, decimal=self.decimal, leading_space=self.leading_space, quoting=self.quoting, fallback_formatter=fallback_formatter)
+        return fmt_values
+
+def format_percentiles(percentiles: np.ndarray | Sequence[float]) -> list[str]:
+    percentiles = np.asarray(percentiles)
+    if not is_numeric_dtype(percentiles) or not np.all(percentiles >= 0) or (not np.all(percentiles <= 1)):
+        raise ValueError('percentiles should all be in the interval [0,1]')
+    percentiles = 100 * percentiles
+    prec = get_precision(percentiles)
+    percentiles_round_type = percentiles.round(prec).astype(int)
+    int_idx = np.isclose(percentiles_round_type, percentiles)
+    if np.all(int_idx):
+        out = percentiles_round_type.astype(str)
+        return [i + '%' for i in out]
+    unique_pcts = np.unique(percentiles)
+    prec = get_precision(unique_pcts)
+    out = np.empty_like(percentiles, dtype=object)
+    out[int_idx] = percentiles[int_idx].round().astype(int).astype(str)
+    out[~int_idx] = percentiles[~int_idx].round(prec).astype(str)
+    return [i + '%' for i in out]
+
+def get_precision(array: np.ndarray | Sequence[float]) -> int:
+    to_begin = array[0] if array[0] > 0 else None
+    to_end = 100 - array[-1] if array[-1] < 100 else None
+    diff = np.ediff1d(array, to_begin=to_begin, to_end=to_end)
+    diff = abs(diff)
+    prec = -np.floor(np.log10(np.min(diff))).astype(int)
+    prec = max(1, prec)
+    return prec
+
+def _format_datetime64(x: NaTType | Timestamp, nat_rep: str='NaT') -> str:
+    if x is NaT:
+        return nat_rep
+    return str(x)
+
+def _format_datetime64_dateonly(x: NaTType | Timestamp, nat_rep: str='NaT', date_format: str | None=None) -> str:
+    if isinstance(x, NaTType):
+        return nat_rep
+    if date_format:
+        return x.strftime(date_format)
+    else:
+        return x._date_repr
+
+def get_format_datetime64(is_dates_only: bool, nat_rep: str='NaT', date_format: str | None=None) -> Callable:
+    if is_dates_only:
+        return lambda x: _format_datetime64_dateonly(x, nat_rep=nat_rep, date_format=date_format)
+    else:
+        return lambda x: _format_datetime64(x, nat_rep=nat_rep)
+
+class _Datetime64TZFormatter(_Datetime64Formatter):
+    values: DatetimeArray
+
+    def _format_strings(self) -> list[str]:
+        ido = self.values._is_dates_only
+        values = self.values.astype(object)
+        formatter = self.formatter or get_format_datetime64(ido, date_format=self.date_format)
+        fmt_values = [formatter(x) for x in values]
+        return fmt_values
+
+class _Timedelta64Formatter(_GenericArrayFormatter):
+    values: TimedeltaArray
+
+    def __init__(self, values: TimedeltaArray, nat_rep: str='NaT', **kwargs) -> None:
+        super().__init__(values, **kwargs)
+        self.nat_rep = nat_rep
+
+    def _format_strings(self) -> list[str]:
+        formatter = self.formatter or get_format_timedelta64(self.values, nat_rep=self.nat_rep, box=False)
+        return [formatter(x) for x in self.values]
+
+def get_format_timedelta64(values: TimedeltaArray, nat_rep: str | float='NaT', box: bool=False) -> Callable:
+    even_days = values._is_dates_only
+    if even_days:
+        format = None
+    else:
+        format = 'long'
+
+    def _formatter(x):
+        if x is None or (is_scalar(x) and isna(x)):
+            return nat_rep
+        if not isinstance(x, Timedelta):
+            x = Timedelta(x)
+        result = x._repr_base(format=format)
+        if box:
+            result = f"'{result}'"
+        return result
+    return _formatter
+
+def _make_fixed_width(strings: list[str], justify: str='right', minimum: int | None=None, adj: printing._TextAdjustment | None=None) -> list[str]:
+    if len(strings) == 0 or justify == 'all':
+        return strings
+    if adj is None:
+        adjustment = printing.get_adjustment()
+    else:
+        adjustment = adj
+    max_len = max((adjustment.len(x) for x in strings))
+    if minimum is not None:
+        max_len = max(minimum, max_len)
+    conf_max = get_option('display.max_colwidth')
+    if conf_max is not None and max_len > conf_max:
+        max_len = conf_max
+
+    def just(x: str) -> str:
+        if conf_max is not None:
+            if (conf_max > 3) & (adjustment.len(x) > max_len):
+                x = x[:max_len - 3] + '...'
+        return x
+    strings = [just(x) for x in strings]
+    result = adjustment.justify(strings, max_len, mode=justify)
+    return result
+
+def _trim_zeros_complex(str_complexes: ArrayLike, decimal: str='.') -> list[str]:
+    (real_part, imag_part) = ([], [])
+    for x in str_complexes:
+        trimmed = re.split('([j+-])', x)
+        real_part.append(''.join(trimmed[:-4]))
+        imag_part.append(''.join(trimmed[-4:-2]))
+    n = len(str_complexes)
+    padded_parts = _trim_zeros_float(real_part + imag_part, decimal)
+    if len(padded_parts) == 0:
+        return []
+    padded_length = max((len(part) for part in padded_parts)) - 1
+    padded = [real_pt + imag_pt[0] + f'{imag_pt[1:]:>{padded_length}}' + 'j' for (real_pt, imag_pt) in zip(padded_parts[:n], padded_parts[n:])]
+    return padded
+
+def _trim_zeros_single_float(str_float: str) -> str:
+    str_float = str_float.rstrip('0')
+    if str_float.endswith('.'):
+        str_float += '0'
+    return str_float
+
+def _trim_zeros_float(str_floats: ArrayLike | list[str], decimal: str='.') -> list[str]:
+    trimmed = str_floats
+    number_regex = re.compile(f'^\\s*[\\+-]?[0-9]+\\{decimal}[0-9]*$')
+
+    def is_number_with_decimal(x) -> bool:
+        return re.match(number_regex, x) is not None
+
+    def should_trim(values: ArrayLike | list[str]) -> bool:
+        numbers = [x for x in values if is_number_with_decimal(x)]
+        return len(numbers) > 0 and all((x.endswith('0') for x in numbers))
+    while should_trim(trimmed):
+        trimmed = [x[:-1] if is_number_with_decimal(x) else x for x in trimmed]
+    result = [x + '0' if is_number_with_decimal(x) and x.endswith(decimal) else x for x in trimmed]
+    return result
+
+def _has_names(index: Index) -> bool:
+    if isinstance(index, MultiIndex):
+        return com.any_not_none(*index.names)
+    else:
+        return index.name is not None
+
+class EngFormatter:
+    ENG_PREFIXES = {-24: 'y', -21: 'z', -18: 'a', -15: 'f', -12: 'p', -9: 'n', -6: 'u', -3: 'm', 0: '', 3: 'k', 6: 'M', 9: 'G', 12: 'T', 15: 'P', 18: 'E', 21: 'Z', 24: 'Y'}
+
+    def __init__(self, accuracy: int | None=None, use_eng_prefix: bool=False) -> None:
+        self.accuracy = accuracy
+        self.use_eng_prefix = use_eng_prefix
+
+    def __call__(self, num: float) -> str:
+        dnum = Decimal(str(num))
+        if Decimal.is_nan(dnum):
+            return 'NaN'
+        if Decimal.is_infinite(dnum):
+            return 'inf'
+        sign = 1
+        if dnum < 0:
+            sign = -1
+            dnum = -dnum
+        if dnum != 0:
+            pow10 = Decimal(int(math.floor(dnum.log10() / 3) * 3))
+        else:
+            pow10 = Decimal(0)
+        pow10 = pow10.min(max(self.ENG_PREFIXES.keys()))
+        pow10 = pow10.max(min(self.ENG_PREFIXES.keys()))
+        int_pow10 = int(pow10)
+        if self.use_eng_prefix:
+            prefix = self.ENG_PREFIXES[int_pow10]
+        elif int_pow10 < 0:
+            prefix = f'E-{-int_pow10:02d}'
+        else:
+            prefix = f'E+{int_pow10:02d}'
+        mant = sign * dnum / 10 ** pow10
+        if self.accuracy is None:
+            format_str = '{mant: g}{prefix}'
+        else:
+            format_str = f'{{mant: .{self.accuracy:d}f}}{{prefix}}'
+        formatted = format_str.format(mant=mant, prefix=prefix)
+        return formatted
+
+def set_eng_float_format(accuracy: int=3, use_eng_prefix: bool=False) -> None:
+    set_option('display.float_format', EngFormatter(accuracy, use_eng_prefix))
+
+def get_level_lengths(levels: Any, sentinel: bool | object | str='') -> list[dict[int, int]]:
+    if len(levels) == 0:
+        return []
+    control = [True] * len(levels[0])
+    result = []
+    for level in levels:
+        last_index = 0
+        lengths = {}
+        for (i, key) in enumerate(level):
+            if control[i] and key == sentinel:
+                pass
+            else:
+                control[i] = False
+                lengths[last_index] = i - last_index
+                last_index = i
+        lengths[last_index] = len(level) - last_index
+        result.append(lengths)
+    return result
+
+def buffer_put_lines(buf: WriteBuffer[str], lines: list[str]) -> None:
+    if any((isinstance(x, str) for x in lines)):
+        lines = [str(x) for x in lines]
+    buf.write('\n'.join(lines))
+
+# File: pandas-main/pandas/io/formats/html.py
+""""""
+from __future__ import annotations
+from textwrap import dedent
+from typing import TYPE_CHECKING, Any, Final, cast
+from pandas._config import get_option
+from pandas._libs import lib
+from pandas import MultiIndex, option_context
+from pandas.io.common import is_url
+from pandas.io.formats.format import DataFrameFormatter, get_level_lengths
+from pandas.io.formats.printing import pprint_thing
+if TYPE_CHECKING:
+    from collections.abc import Hashable, Iterable, Mapping
+
+class HTMLFormatter:
+    indent_delta: Final = 2
+
+    def __init__(self, formatter: DataFrameFormatter, classes: str | list[str] | tuple[str, ...] | None=None, border: int | bool | None=None, table_id: str | None=None, render_links: bool=False) -> None:
+        self.fmt = formatter
+        self.classes = classes
+        self.frame = self.fmt.frame
+        self.columns = self.fmt.tr_frame.columns
+        self.elements: list[str] = []
+        self.bold_rows = self.fmt.bold_rows
+        self.escape = self.fmt.escape
+        self.show_dimensions = self.fmt.show_dimensions
+        if border is None or border is True:
+            border = cast(int, get_option('display.html.border'))
+        elif not border:
+            border = None
+        self.border = border
+        self.table_id = table_id
+        self.render_links = render_links
+        self.col_space = {}
+        is_multi_index = isinstance(self.columns, MultiIndex)
+        for (column, value) in self.fmt.col_space.items():
+            col_space_value = f'{value}px' if isinstance(value, int) else value
+            self.col_space[column] = col_space_value
+            if is_multi_index and isinstance(column, tuple):
+                for column_index in column:
+                    self.col_space[str(column_index)] = col_space_value
+
+    def to_string(self) -> str:
+        lines = self.render()
+        if any((isinstance(x, str) for x in lines)):
+            lines = [str(x) for x in lines]
+        return '\n'.join(lines)
+
+    def render(self) -> list[str]:
+        self._write_table()
+        if self.should_show_dimensions:
+            by = chr(215)
+            self.write(f'<p>{len(self.frame)} rows {by} {len(self.frame.columns)} columns</p>')
+        return self.elements
+
+    @property
+    def should_show_dimensions(self) -> bool:
+        return self.fmt.should_show_dimensions
+
+    @property
+    def show_row_idx_names(self) -> bool:
+        return self.fmt.show_row_idx_names
+
+    @property
+    def show_col_idx_names(self) -> bool:
+        return self.fmt.show_col_idx_names
+
+    @property
+    def row_levels(self) -> int:
+        if self.fmt.index:
+            return self.frame.index.nlevels
+        elif self.show_col_idx_names:
+            return 1
+        return 0
+
+    def _get_columns_formatted_values(self) -> Iterable:
+        return self.columns
+
+    @property
+    def is_truncated(self) -> bool:
+        return self.fmt.is_truncated
+
+    @property
+    def ncols(self) -> int:
+        return len(self.fmt.tr_frame.columns)
+
+    def write(self, s: Any, indent: int=0) -> None:
+        rs = pprint_thing(s)
+        self.elements.append(' ' * indent + rs)
+
+    def write_th(self, s: Any, header: bool=False, indent: int=0, tags: str | None=None) -> None:
+        col_space = self.col_space.get(s, None)
+        if header and col_space is not None:
+            tags = tags or ''
+            tags += f'style="min-width: {col_space};"'
+        self._write_cell(s, kind='th', indent=indent, tags=tags)
+
+    def write_td(self, s: Any, indent: int=0, tags: str | None=None) -> None:
+        self._write_cell(s, kind='td', indent=indent, tags=tags)
+
+    def _write_cell(self, s: Any, kind: str='td', indent: int=0, tags: str | None=None) -> None:
+        if tags is not None:
+            start_tag = f'<{kind} {tags}>'
+        else:
+            start_tag = f'<{kind}>'
+        if self.escape:
+            esc = {'&': '&amp;', '<': '&lt;', '>': '&gt;'}
+        else:
+            esc = {}
+        rs = pprint_thing(s, escape_chars=esc).strip()
+        if self.render_links and is_url(rs):
+            rs_unescaped = pprint_thing(s, escape_chars={}).strip()
+            start_tag += f'<a href="{rs_unescaped}" target="_blank">'
+            end_a = '</a>'
+        else:
+            end_a = ''
+        self.write(f'{start_tag}{rs}{end_a}</{kind}>', indent)
+
+    def write_tr(self, line: Iterable, indent: int=0, indent_delta: int=0, header: bool=False, align: str | None=None, tags: dict[int, str] | None=None, nindex_levels: int=0) -> None:
+        if tags is None:
+            tags = {}
+        if align is None:
+            self.write('<tr>', indent)
+        else:
+            self.write(f'<tr style="text-align: {align};">', indent)
+        indent += indent_delta
+        for (i, s) in enumerate(line):
+            val_tag = tags.get(i, None)
+            if header or (self.bold_rows and i < nindex_levels):
+                self.write_th(s, indent=indent, header=header, tags=val_tag)
+            else:
+                self.write_td(s, indent, tags=val_tag)
+        indent -= indent_delta
+        self.write('</tr>', indent)
+
+    def _write_table(self, indent: int=0) -> None:
+        _classes = ['dataframe']
+        use_mathjax = get_option('display.html.use_mathjax')
+        if not use_mathjax:
+            _classes.append('tex2jax_ignore')
+        if self.classes is not None:
+            if isinstance(self.classes, str):
+                self.classes = self.classes.split()
+            if not isinstance(self.classes, (list, tuple)):
+                raise TypeError(f'classes must be a string, list, or tuple, not {type(self.classes)}')
+            _classes.extend(self.classes)
+        if self.table_id is None:
+            id_section = ''
+        else:
+            id_section = f' id="{self.table_id}"'
+        if self.border is None:
+            border_attr = ''
+        else:
+            border_attr = f' border="{self.border}"'
+        self.write(f'''<table{border_attr} class="{' '.join(_classes)}"{id_section}>''', indent)
+        if self.fmt.header or self.show_row_idx_names:
+            self._write_header(indent + self.indent_delta)
+        self._write_body(indent + self.indent_delta)
+        self.write('</table>', indent)
+
+    def _write_col_header(self, indent: int) -> None:
+        row: list[Hashable]
+        is_truncated_horizontally = self.fmt.is_truncated_horizontally
+        if isinstance(self.columns, MultiIndex):
+            template = 'colspan="{span:d}" halign="left"'
+            sentinel: lib.NoDefault | bool
+            if self.fmt.sparsify:
+                sentinel = lib.no_default
+            else:
+                sentinel = False
+            levels = self.columns._format_multi(sparsify=sentinel, include_names=False)
+            level_lengths = get_level_lengths(levels, sentinel)
+            inner_lvl = len(level_lengths) - 1
+            for (lnum, (records, values)) in enumerate(zip(level_lengths, levels)):
+                if is_truncated_horizontally:
+                    ins_col = self.fmt.tr_col_num
+                    if self.fmt.sparsify:
+                        recs_new = {}
+                        for (tag, span) in list(records.items()):
+                            if tag >= ins_col:
+                                recs_new[tag + 1] = span
+                            elif tag + span > ins_col:
+                                recs_new[tag] = span + 1
+                                if lnum == inner_lvl:
+                                    values = values[:ins_col] + ('...',) + values[ins_col:]
+                                else:
+                                    values = values[:ins_col] + (values[ins_col - 1],) + values[ins_col:]
+                            else:
+                                recs_new[tag] = span
+                            if tag + span == ins_col:
+                                recs_new[ins_col] = 1
+                                values = values[:ins_col] + ('...',) + values[ins_col:]
+                        records = recs_new
+                        inner_lvl = len(level_lengths) - 1
+                        if lnum == inner_lvl:
+                            records[ins_col] = 1
+                    else:
+                        recs_new = {}
+                        for (tag, span) in list(records.items()):
+                            if tag >= ins_col:
+                                recs_new[tag + 1] = span
+                            else:
+                                recs_new[tag] = span
+                        recs_new[ins_col] = 1
+                        records = recs_new
+                        values = values[:ins_col] + ['...'] + values[ins_col:]
+                row = [''] * (self.row_levels - 1)
+                if self.fmt.index or self.show_col_idx_names:
+                    if self.fmt.show_index_names:
+                        name = self.columns.names[lnum]
+                        row.append(pprint_thing(name or ''))
+                    else:
+                        row.append('')
+                tags = {}
+                j = len(row)
+                for (i, v) in enumerate(values):
+                    if i in records:
+                        if records[i] > 1:
+                            tags[j] = template.format(span=records[i])
+                    else:
+                        continue
+                    j += 1
+                    row.append(v)
+                self.write_tr(row, indent, self.indent_delta, tags=tags, header=True)
+        else:
+            row = [''] * (self.row_levels - 1)
+            if self.fmt.index or self.show_col_idx_names:
+                if self.fmt.show_index_names:
+                    row.append(self.columns.name or '')
+                else:
+                    row.append('')
+            row.extend(self._get_columns_formatted_values())
+            align = self.fmt.justify
+            if is_truncated_horizontally:
+                ins_col = self.row_levels + self.fmt.tr_col_num
+                row.insert(ins_col, '...')
+            self.write_tr(row, indent, self.indent_delta, header=True, align=align)
+
+    def _write_row_header(self, indent: int) -> None:
+        is_truncated_horizontally = self.fmt.is_truncated_horizontally
+        row = [x if x is not None else '' for x in self.frame.index.names] + [''] * (self.ncols + (1 if is_truncated_horizontally else 0))
+        self.write_tr(row, indent, self.indent_delta, header=True)
+
+    def _write_header(self, indent: int) -> None:
+        self.write('<thead>', indent)
+        if self.fmt.header:
+            self._write_col_header(indent + self.indent_delta)
+        if self.show_row_idx_names:
+            self._write_row_header(indent + self.indent_delta)
+        self.write('</thead>', indent)
+
+    def _get_formatted_values(self) -> dict[int, list[str]]:
+        with option_context('display.max_colwidth', None):
+            fmt_values = {i: self.fmt.format_col(i) for i in range(self.ncols)}
+        return fmt_values
+
+    def _write_body(self, indent: int) -> None:
+        self.write('<tbody>', indent)
+        fmt_values = self._get_formatted_values()
+        if self.fmt.index and isinstance(self.frame.index, MultiIndex):
+            self._write_hierarchical_rows(fmt_values, indent + self.indent_delta)
+        else:
+            self._write_regular_rows(fmt_values, indent + self.indent_delta)
+        self.write('</tbody>', indent)
+
+    def _write_regular_rows(self, fmt_values: Mapping[int, list[str]], indent: int) -> None:
+        is_truncated_horizontally = self.fmt.is_truncated_horizontally
+        is_truncated_vertically = self.fmt.is_truncated_vertically
+        nrows = len(self.fmt.tr_frame)
+        if self.fmt.index:
+            fmt = self.fmt._get_formatter('__index__')
+            if fmt is not None:
+                index_values = self.fmt.tr_frame.index.map(fmt)
+            else:
+                index_values = self.fmt.tr_frame.index._format_flat(include_name=False)
+        row: list[str] = []
+        for i in range(nrows):
+            if is_truncated_vertically and i == self.fmt.tr_row_num:
+                str_sep_row = ['...'] * len(row)
+                self.write_tr(str_sep_row, indent, self.indent_delta, tags=None, nindex_levels=self.row_levels)
+            row = []
+            if self.fmt.index:
+                row.append(index_values[i])
+            elif self.show_col_idx_names:
+                row.append('')
+            row.extend((fmt_values[j][i] for j in range(self.ncols)))
+            if is_truncated_horizontally:
+                dot_col_ix = self.fmt.tr_col_num + self.row_levels
+                row.insert(dot_col_ix, '...')
+            self.write_tr(row, indent, self.indent_delta, tags=None, nindex_levels=self.row_levels)
+
+    def _write_hierarchical_rows(self, fmt_values: Mapping[int, list[str]], indent: int) -> None:
+        template = 'rowspan="{span}" valign="top"'
+        is_truncated_horizontally = self.fmt.is_truncated_horizontally
+        is_truncated_vertically = self.fmt.is_truncated_vertically
+        frame = self.fmt.tr_frame
+        nrows = len(frame)
+        assert isinstance(frame.index, MultiIndex)
+        idx_values = frame.index._format_multi(sparsify=False, include_names=False)
+        idx_values = list(zip(*idx_values))
+        if self.fmt.sparsify:
+            sentinel = lib.no_default
+            levels = frame.index._format_multi(sparsify=sentinel, include_names=False)
+            level_lengths = get_level_lengths(levels, sentinel)
+            inner_lvl = len(level_lengths) - 1
+            if is_truncated_vertically:
+                ins_row = self.fmt.tr_row_num
+                inserted = False
+                for (lnum, records) in enumerate(level_lengths):
+                    rec_new = {}
+                    for (tag, span) in list(records.items()):
+                        if tag >= ins_row:
+                            rec_new[tag + 1] = span
+                        elif tag + span > ins_row:
+                            rec_new[tag] = span + 1
+                            if not inserted:
+                                dot_row = list(idx_values[ins_row - 1])
+                                dot_row[-1] = '...'
+                                idx_values.insert(ins_row, tuple(dot_row))
+                                inserted = True
+                            else:
+                                dot_row = list(idx_values[ins_row])
+                                dot_row[inner_lvl - lnum] = '...'
+                                idx_values[ins_row] = tuple(dot_row)
+                        else:
+                            rec_new[tag] = span
+                        if tag + span == ins_row:
+                            rec_new[ins_row] = 1
+                            if lnum == 0:
+                                idx_values.insert(ins_row, tuple(['...'] * len(level_lengths)))
+                            elif inserted:
+                                dot_row = list(idx_values[ins_row])
+                                dot_row[inner_lvl - lnum] = '...'
+                                idx_values[ins_row] = tuple(dot_row)
+                    level_lengths[lnum] = rec_new
+                level_lengths[inner_lvl][ins_row] = 1
+                for ix_col in fmt_values:
+                    fmt_values[ix_col].insert(ins_row, '...')
+                nrows += 1
+            for i in range(nrows):
+                row = []
+                tags = {}
+                sparse_offset = 0
+                j = 0
+                for (records, v) in zip(level_lengths, idx_values[i]):
+                    if i in records:
+                        if records[i] > 1:
+                            tags[j] = template.format(span=records[i])
+                    else:
+                        sparse_offset += 1
+                        continue
+                    j += 1
+                    row.append(v)
+                row.extend((fmt_values[j][i] for j in range(self.ncols)))
+                if is_truncated_horizontally:
+                    row.insert(self.row_levels - sparse_offset + self.fmt.tr_col_num, '...')
+                self.write_tr(row, indent, self.indent_delta, tags=tags, nindex_levels=len(levels) - sparse_offset)
+        else:
+            row = []
+            for i in range(len(frame)):
+                if is_truncated_vertically and i == self.fmt.tr_row_num:
+                    str_sep_row = ['...'] * len(row)
+                    self.write_tr(str_sep_row, indent, self.indent_delta, tags=None, nindex_levels=self.row_levels)
+                idx_values = list(zip(*frame.index._format_multi(sparsify=False, include_names=False)))
+                row = []
+                row.extend(idx_values[i])
+                row.extend((fmt_values[j][i] for j in range(self.ncols)))
+                if is_truncated_horizontally:
+                    row.insert(self.row_levels + self.fmt.tr_col_num, '...')
+                self.write_tr(row, indent, self.indent_delta, tags=None, nindex_levels=frame.index.nlevels)
+
+class NotebookFormatter(HTMLFormatter):
+
+    def _get_formatted_values(self) -> dict[int, list[str]]:
+        return {i: self.fmt.format_col(i) for i in range(self.ncols)}
+
+    def _get_columns_formatted_values(self) -> list[str]:
+        return self.columns._format_flat(include_name=False)
+
+    def write_style(self) -> None:
+        template_first = '            <style scoped>'
+        template_last = '            </style>'
+        template_select = '                .dataframe %s {\n                    %s: %s;\n                }'
+        element_props = [('tbody tr th:only-of-type', 'vertical-align', 'middle'), ('tbody tr th', 'vertical-align', 'top')]
+        if isinstance(self.columns, MultiIndex):
+            element_props.append(('thead tr th', 'text-align', 'left'))
+            if self.show_row_idx_names:
+                element_props.append(('thead tr:last-of-type th', 'text-align', 'right'))
+        else:
+            element_props.append(('thead th', 'text-align', 'right'))
+        template_mid = '\n\n'.join((template_select % t for t in element_props))
+        template = dedent(f'{template_first}\n{template_mid}\n{template_last}')
+        self.write(template)
+
+    def render(self) -> list[str]:
+        self.write('<div>')
+        self.write_style()
+        super().render()
+        self.write('</div>')
+        return self.elements
+
+# File: pandas-main/pandas/io/formats/info.py
+from __future__ import annotations
+from abc import ABC, abstractmethod
+import sys
+from textwrap import dedent
+from typing import TYPE_CHECKING
+from pandas._config import get_option
+from pandas.io.formats import format as fmt
+from pandas.io.formats.printing import pprint_thing
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator, Mapping, Sequence
+    from pandas._typing import Dtype, WriteBuffer
+    from pandas import DataFrame, Index, Series
+frame_max_cols_sub = dedent('    max_cols : int, optional\n        When to switch from the verbose to the truncated output. If the\n        DataFrame has more than `max_cols` columns, the truncated output\n        is used. By default, the setting in\n        ``pandas.options.display.max_info_columns`` is used.')
+show_counts_sub = dedent('    show_counts : bool, optional\n        Whether to show the non-null counts. By default, this is shown\n        only if the DataFrame is smaller than\n        ``pandas.options.display.max_info_rows`` and\n        ``pandas.options.display.max_info_columns``. A value of True always\n        shows the counts, and False never shows the counts.')
+frame_examples_sub = dedent('    >>> int_values = [1, 2, 3, 4, 5]\n    >>> text_values = [\'alpha\', \'beta\', \'gamma\', \'delta\', \'epsilon\']\n    >>> float_values = [0.0, 0.25, 0.5, 0.75, 1.0]\n    >>> df = pd.DataFrame({"int_col": int_values, "text_col": text_values,\n    ...                   "float_col": float_values})\n    >>> df\n        int_col text_col  float_col\n    0        1    alpha       0.00\n    1        2     beta       0.25\n    2        3    gamma       0.50\n    3        4    delta       0.75\n    4        5  epsilon       1.00\n\n    Prints information of all columns:\n\n    >>> df.info(verbose=True)\n    <class \'pandas.DataFrame\'>\n    RangeIndex: 5 entries, 0 to 4\n    Data columns (total 3 columns):\n     #   Column     Non-Null Count  Dtype\n    ---  ------     --------------  -----\n     0   int_col    5 non-null      int64\n     1   text_col   5 non-null      object\n     2   float_col  5 non-null      float64\n    dtypes: float64(1), int64(1), object(1)\n    memory usage: 248.0+ bytes\n\n    Prints a summary of columns count and its dtypes but not per column\n    information:\n\n    >>> df.info(verbose=False)\n    <class \'pandas.DataFrame\'>\n    RangeIndex: 5 entries, 0 to 4\n    Columns: 3 entries, int_col to float_col\n    dtypes: float64(1), int64(1), object(1)\n    memory usage: 248.0+ bytes\n\n    Pipe output of DataFrame.info to buffer instead of sys.stdout, get\n    buffer content and writes to a text file:\n\n    >>> import io\n    >>> buffer = io.StringIO()\n    >>> df.info(buf=buffer)\n    >>> s = buffer.getvalue()\n    >>> with open("df_info.txt", "w",\n    ...           encoding="utf-8") as f:  # doctest: +SKIP\n    ...     f.write(s)\n    260\n\n    The `memory_usage` parameter allows deep introspection mode, specially\n    useful for big DataFrames and fine-tune memory optimization:\n\n    >>> random_strings_array = np.random.choice([\'a\', \'b\', \'c\'], 10 ** 6)\n    >>> df = pd.DataFrame({\n    ...     \'column_1\': np.random.choice([\'a\', \'b\', \'c\'], 10 ** 6),\n    ...     \'column_2\': np.random.choice([\'a\', \'b\', \'c\'], 10 ** 6),\n    ...     \'column_3\': np.random.choice([\'a\', \'b\', \'c\'], 10 ** 6)\n    ... })\n    >>> df.info()\n    <class \'pandas.DataFrame\'>\n    RangeIndex: 1000000 entries, 0 to 999999\n    Data columns (total 3 columns):\n     #   Column    Non-Null Count    Dtype\n    ---  ------    --------------    -----\n     0   column_1  1000000 non-null  object\n     1   column_2  1000000 non-null  object\n     2   column_3  1000000 non-null  object\n    dtypes: object(3)\n    memory usage: 22.9+ MB\n\n    >>> df.info(memory_usage=\'deep\')\n    <class \'pandas.DataFrame\'>\n    RangeIndex: 1000000 entries, 0 to 999999\n    Data columns (total 3 columns):\n     #   Column    Non-Null Count    Dtype\n    ---  ------    --------------    -----\n     0   column_1  1000000 non-null  object\n     1   column_2  1000000 non-null  object\n     2   column_3  1000000 non-null  object\n    dtypes: object(3)\n    memory usage: 165.9 MB')
+frame_see_also_sub = dedent('    DataFrame.describe: Generate descriptive statistics of DataFrame\n        columns.\n    DataFrame.memory_usage: Memory usage of DataFrame columns.')
+frame_sub_kwargs = {'klass': 'DataFrame', 'type_sub': ' and columns', 'max_cols_sub': frame_max_cols_sub, 'show_counts_sub': show_counts_sub, 'examples_sub': frame_examples_sub, 'see_also_sub': frame_see_also_sub, 'version_added_sub': ''}
+series_examples_sub = dedent('    >>> int_values = [1, 2, 3, 4, 5]\n    >>> text_values = [\'alpha\', \'beta\', \'gamma\', \'delta\', \'epsilon\']\n    >>> s = pd.Series(text_values, index=int_values)\n    >>> s.info()\n    <class \'pandas.core.series.Series\'>\n    Index: 5 entries, 1 to 5\n    Series name: None\n    Non-Null Count  Dtype\n    --------------  -----\n    5 non-null      object\n    dtypes: object(1)\n    memory usage: 80.0+ bytes\n\n    Prints a summary excluding information about its values:\n\n    >>> s.info(verbose=False)\n    <class \'pandas.core.series.Series\'>\n    Index: 5 entries, 1 to 5\n    dtypes: object(1)\n    memory usage: 80.0+ bytes\n\n    Pipe output of Series.info to buffer instead of sys.stdout, get\n    buffer content and writes to a text file:\n\n    >>> import io\n    >>> buffer = io.StringIO()\n    >>> s.info(buf=buffer)\n    >>> s = buffer.getvalue()\n    >>> with open("df_info.txt", "w",\n    ...           encoding="utf-8") as f:  # doctest: +SKIP\n    ...     f.write(s)\n    260\n\n    The `memory_usage` parameter allows deep introspection mode, specially\n    useful for big Series and fine-tune memory optimization:\n\n    >>> random_strings_array = np.random.choice([\'a\', \'b\', \'c\'], 10 ** 6)\n    >>> s = pd.Series(np.random.choice([\'a\', \'b\', \'c\'], 10 ** 6))\n    >>> s.info()\n    <class \'pandas.core.series.Series\'>\n    RangeIndex: 1000000 entries, 0 to 999999\n    Series name: None\n    Non-Null Count    Dtype\n    --------------    -----\n    1000000 non-null  object\n    dtypes: object(1)\n    memory usage: 7.6+ MB\n\n    >>> s.info(memory_usage=\'deep\')\n    <class \'pandas.core.series.Series\'>\n    RangeIndex: 1000000 entries, 0 to 999999\n    Series name: None\n    Non-Null Count    Dtype\n    --------------    -----\n    1000000 non-null  object\n    dtypes: object(1)\n    memory usage: 55.3 MB')
+series_see_also_sub = dedent('    Series.describe: Generate descriptive statistics of Series.\n    Series.memory_usage: Memory usage of Series.')
+series_sub_kwargs = {'klass': 'Series', 'type_sub': '', 'max_cols_sub': '', 'show_counts_sub': show_counts_sub, 'examples_sub': series_examples_sub, 'see_also_sub': series_see_also_sub, 'version_added_sub': '\n.. versionadded:: 1.4.0\n'}
+INFO_DOCSTRING = dedent('\n    Print a concise summary of a {klass}.\n\n    This method prints information about a {klass} including\n    the index dtype{type_sub}, non-null values and memory usage.\n    {version_added_sub}\n    Parameters\n    ----------\n    verbose : bool, optional\n        Whether to print the full summary. By default, the setting in\n        ``pandas.options.display.max_info_columns`` is followed.\n    buf : writable buffer, defaults to sys.stdout\n        Where to send the output. By default, the output is printed to\n        sys.stdout. Pass a writable buffer if you need to further process\n        the output.\n    {max_cols_sub}\n    memory_usage : bool, str, optional\n        Specifies whether total memory usage of the {klass}\n        elements (including the index) should be displayed. By default,\n        this follows the ``pandas.options.display.memory_usage`` setting.\n\n        True always show memory usage. False never shows memory usage.\n        A value of \'deep\' is equivalent to "True with deep introspection".\n        Memory usage is shown in human-readable units (base-2\n        representation). Without deep introspection a memory estimation is\n        made based in column dtype and number of rows assuming values\n        consume the same memory amount for corresponding dtypes. With deep\n        memory introspection, a real memory usage calculation is performed\n        at the cost of computational resources. See the\n        :ref:`Frequently Asked Questions <df-memory-usage>` for more\n        details.\n    {show_counts_sub}\n\n    Returns\n    -------\n    None\n        This method prints a summary of a {klass} and returns None.\n\n    See Also\n    --------\n    {see_also_sub}\n\n    Examples\n    --------\n    {examples_sub}\n    ')
+
+def _put_str(s: str | Dtype, space: int) -> str:
+    return str(s)[:space].ljust(space)
+
+def _sizeof_fmt(num: float, size_qualifier: str) -> str:
+    for x in ['bytes', 'KB', 'MB', 'GB', 'TB']:
+        if num < 1024.0:
+            return f'{num:3.1f}{size_qualifier} {x}'
+        num /= 1024.0
+    return f'{num:3.1f}{size_qualifier} PB'
+
+def _initialize_memory_usage(memory_usage: bool | str | None=None) -> bool | str:
+    if memory_usage is None:
+        memory_usage = get_option('display.memory_usage')
+    return memory_usage
+
+class _BaseInfo(ABC):
+    data: DataFrame | Series
+    memory_usage: bool | str
+
+    @property
+    @abstractmethod
+    def dtypes(self) -> Iterable[Dtype]:
+
+    @property
+    @abstractmethod
+    def dtype_counts(self) -> Mapping[str, int]:
+
+    @property
+    @abstractmethod
+    def non_null_counts(self) -> list[int] | Series:
+
+    @property
+    @abstractmethod
+    def memory_usage_bytes(self) -> int:
+
+    @property
+    def memory_usage_string(self) -> str:
+        return f'{_sizeof_fmt(self.memory_usage_bytes, self.size_qualifier)}\n'
+
+    @property
+    def size_qualifier(self) -> str:
+        size_qualifier = ''
+        if self.memory_usage:
+            if self.memory_usage != 'deep':
+                if 'object' in self.dtype_counts or self.data.index._is_memory_usage_qualified:
+                    size_qualifier = '+'
+        return size_qualifier
+
+    @abstractmethod
+    def render(self, *, buf: WriteBuffer[str] | None, max_cols: int | None, verbose: bool | None, show_counts: bool | None) -> None:
+        pass
+
+class DataFrameInfo(_BaseInfo):
+
+    def __init__(self, data: DataFrame, memory_usage: bool | str | None=None) -> None:
+        self.data: DataFrame = data
+        self.memory_usage = _initialize_memory_usage(memory_usage)
+
+    @property
+    def dtype_counts(self) -> Mapping[str, int]:
+        return _get_dataframe_dtype_counts(self.data)
+
+    @property
+    def dtypes(self) -> Iterable[Dtype]:
+        return self.data.dtypes
+
+    @property
+    def ids(self) -> Index:
+        return self.data.columns
+
+    @property
+    def col_count(self) -> int:
+        return len(self.ids)
+
+    @property
+    def non_null_counts(self) -> Series:
+        return self.data.count()
+
+    @property
+    def memory_usage_bytes(self) -> int:
+        deep = self.memory_usage == 'deep'
+        return self.data.memory_usage(index=True, deep=deep).sum()
+
+    def render(self, *, buf: WriteBuffer[str] | None, max_cols: int | None, verbose: bool | None, show_counts: bool | None) -> None:
+        printer = _DataFrameInfoPrinter(info=self, max_cols=max_cols, verbose=verbose, show_counts=show_counts)
+        printer.to_buffer(buf)
+
+class SeriesInfo(_BaseInfo):
+
+    def __init__(self, data: Series, memory_usage: bool | str | None=None) -> None:
+        self.data: Series = data
+        self.memory_usage = _initialize_memory_usage(memory_usage)
+
+    def render(self, *, buf: WriteBuffer[str] | None=None, max_cols: int | None=None, verbose: bool | None=None, show_counts: bool | None=None) -> None:
+        if max_cols is not None:
+            raise ValueError('Argument `max_cols` can only be passed in DataFrame.info, not Series.info')
+        printer = _SeriesInfoPrinter(info=self, verbose=verbose, show_counts=show_counts)
+        printer.to_buffer(buf)
+
+    @property
+    def non_null_counts(self) -> list[int]:
+        return [self.data.count()]
+
+    @property
+    def dtypes(self) -> Iterable[Dtype]:
+        return [self.data.dtypes]
+
+    @property
+    def dtype_counts(self) -> Mapping[str, int]:
+        from pandas.core.frame import DataFrame
+        return _get_dataframe_dtype_counts(DataFrame(self.data))
+
+    @property
+    def memory_usage_bytes(self) -> int:
+        deep = self.memory_usage == 'deep'
+        return self.data.memory_usage(index=True, deep=deep)
+
+class _InfoPrinterAbstract:
+
+    def to_buffer(self, buf: WriteBuffer[str] | None=None) -> None:
+        table_builder = self._create_table_builder()
+        lines = table_builder.get_lines()
+        if buf is None:
+            buf = sys.stdout
+        fmt.buffer_put_lines(buf, lines)
+
+    @abstractmethod
+    def _create_table_builder(self) -> _TableBuilderAbstract:
+
+class _DataFrameInfoPrinter(_InfoPrinterAbstract):
+
+    def __init__(self, info: DataFrameInfo, max_cols: int | None=None, verbose: bool | None=None, show_counts: bool | None=None) -> None:
+        self.info = info
+        self.data = info.data
+        self.verbose = verbose
+        self.max_cols = self._initialize_max_cols(max_cols)
+        self.show_counts = self._initialize_show_counts(show_counts)
+
+    @property
+    def max_rows(self) -> int:
+        return get_option('display.max_info_rows')
+
+    @property
+    def exceeds_info_cols(self) -> bool:
+        return bool(self.col_count > self.max_cols)
+
+    @property
+    def exceeds_info_rows(self) -> bool:
+        return bool(len(self.data) > self.max_rows)
+
+    @property
+    def col_count(self) -> int:
+        return self.info.col_count
+
+    def _initialize_max_cols(self, max_cols: int | None) -> int:
+        if max_cols is None:
+            return get_option('display.max_info_columns')
+        return max_cols
+
+    def _initialize_show_counts(self, show_counts: bool | None) -> bool:
+        if show_counts is None:
+            return bool(not self.exceeds_info_cols and (not self.exceeds_info_rows))
+        else:
+            return show_counts
+
+    def _create_table_builder(self) -> _DataFrameTableBuilder:
+        if self.verbose:
+            return _DataFrameTableBuilderVerbose(info=self.info, with_counts=self.show_counts)
+        elif self.verbose is False:
+            return _DataFrameTableBuilderNonVerbose(info=self.info)
+        elif self.exceeds_info_cols:
+            return _DataFrameTableBuilderNonVerbose(info=self.info)
+        else:
+            return _DataFrameTableBuilderVerbose(info=self.info, with_counts=self.show_counts)
+
+class _SeriesInfoPrinter(_InfoPrinterAbstract):
+
+    def __init__(self, info: SeriesInfo, verbose: bool | None=None, show_counts: bool | None=None) -> None:
+        self.info = info
+        self.data = info.data
+        self.verbose = verbose
+        self.show_counts = self._initialize_show_counts(show_counts)
+
+    def _create_table_builder(self) -> _SeriesTableBuilder:
+        if self.verbose or self.verbose is None:
+            return _SeriesTableBuilderVerbose(info=self.info, with_counts=self.show_counts)
+        else:
+            return _SeriesTableBuilderNonVerbose(info=self.info)
+
+    def _initialize_show_counts(self, show_counts: bool | None) -> bool:
+        if show_counts is None:
+            return True
+        else:
+            return show_counts
+
+class _TableBuilderAbstract(ABC):
+    _lines: list[str]
+    info: _BaseInfo
+
+    @abstractmethod
+    def get_lines(self) -> list[str]:
+
+    @property
+    def data(self) -> DataFrame | Series:
+        return self.info.data
+
+    @property
+    def dtypes(self) -> Iterable[Dtype]:
+        return self.info.dtypes
+
+    @property
+    def dtype_counts(self) -> Mapping[str, int]:
+        return self.info.dtype_counts
+
+    @property
+    def display_memory_usage(self) -> bool:
+        return bool(self.info.memory_usage)
+
+    @property
+    def memory_usage_string(self) -> str:
+        return self.info.memory_usage_string
+
+    @property
+    def non_null_counts(self) -> list[int] | Series:
+        return self.info.non_null_counts
+
+    def add_object_type_line(self) -> None:
+        self._lines.append(str(type(self.data)))
+
+    def add_index_range_line(self) -> None:
+        self._lines.append(self.data.index._summary())
+
+    def add_dtypes_line(self) -> None:
+        collected_dtypes = [f'{key}({val:d})' for (key, val) in sorted(self.dtype_counts.items())]
+        self._lines.append(f"dtypes: {', '.join(collected_dtypes)}")
+
+class _DataFrameTableBuilder(_TableBuilderAbstract):
+
+    def __init__(self, *, info: DataFrameInfo) -> None:
+        self.info: DataFrameInfo = info
+
+    def get_lines(self) -> list[str]:
+        self._lines = []
+        if self.col_count == 0:
+            self._fill_empty_info()
+        else:
+            self._fill_non_empty_info()
+        return self._lines
+
+    def _fill_empty_info(self) -> None:
+        self.add_object_type_line()
+        self.add_index_range_line()
+        self._lines.append(f'Empty {type(self.data).__name__}\n')
+
+    @abstractmethod
+    def _fill_non_empty_info(self) -> None:
+
+    @property
+    def data(self) -> DataFrame:
+        return self.info.data
+
+    @property
+    def ids(self) -> Index:
+        return self.info.ids
+
+    @property
+    def col_count(self) -> int:
+        return self.info.col_count
+
+    def add_memory_usage_line(self) -> None:
+        self._lines.append(f'memory usage: {self.memory_usage_string}')
+
+class _DataFrameTableBuilderNonVerbose(_DataFrameTableBuilder):
+
+    def _fill_non_empty_info(self) -> None:
+        self.add_object_type_line()
+        self.add_index_range_line()
+        self.add_columns_summary_line()
+        self.add_dtypes_line()
+        if self.display_memory_usage:
+            self.add_memory_usage_line()
+
+    def add_columns_summary_line(self) -> None:
+        self._lines.append(self.ids._summary(name='Columns'))
+
+class _TableBuilderVerboseMixin(_TableBuilderAbstract):
+    SPACING: str = ' ' * 2
+    strrows: Sequence[Sequence[str]]
+    gross_column_widths: Sequence[int]
+    with_counts: bool
+
+    @property
+    @abstractmethod
+    def headers(self) -> Sequence[str]:
+
+    @property
+    def header_column_widths(self) -> Sequence[int]:
+        return [len(col) for col in self.headers]
+
+    def _get_gross_column_widths(self) -> Sequence[int]:
+        body_column_widths = self._get_body_column_widths()
+        return [max(*widths) for widths in zip(self.header_column_widths, body_column_widths)]
+
+    def _get_body_column_widths(self) -> Sequence[int]:
+        strcols: Sequence[Sequence[str]] = list(zip(*self.strrows))
+        return [max((len(x) for x in col)) for col in strcols]
+
+    def _gen_rows(self) -> Iterator[Sequence[str]]:
+        if self.with_counts:
+            return self._gen_rows_with_counts()
+        else:
+            return self._gen_rows_without_counts()
+
+    @abstractmethod
+    def _gen_rows_with_counts(self) -> Iterator[Sequence[str]]:
+
+    @abstractmethod
+    def _gen_rows_without_counts(self) -> Iterator[Sequence[str]]:
+
+    def add_header_line(self) -> None:
+        header_line = self.SPACING.join([_put_str(header, col_width) for (header, col_width) in zip(self.headers, self.gross_column_widths)])
+        self._lines.append(header_line)
+
+    def add_separator_line(self) -> None:
+        separator_line = self.SPACING.join([_put_str('-' * header_colwidth, gross_colwidth) for (header_colwidth, gross_colwidth) in zip(self.header_column_widths, self.gross_column_widths)])
+        self._lines.append(separator_line)
+
+    def add_body_lines(self) -> None:
+        for row in self.strrows:
+            body_line = self.SPACING.join([_put_str(col, gross_colwidth) for (col, gross_colwidth) in zip(row, self.gross_column_widths)])
+            self._lines.append(body_line)
+
+    def _gen_non_null_counts(self) -> Iterator[str]:
+        for count in self.non_null_counts:
+            yield f'{count} non-null'
+
+    def _gen_dtypes(self) -> Iterator[str]:
+        for dtype in self.dtypes:
+            yield pprint_thing(dtype)
+
+class _DataFrameTableBuilderVerbose(_DataFrameTableBuilder, _TableBuilderVerboseMixin):
+
+    def __init__(self, *, info: DataFrameInfo, with_counts: bool) -> None:
+        self.info = info
+        self.with_counts = with_counts
+        self.strrows: Sequence[Sequence[str]] = list(self._gen_rows())
+        self.gross_column_widths: Sequence[int] = self._get_gross_column_widths()
+
+    def _fill_non_empty_info(self) -> None:
+        self.add_object_type_line()
+        self.add_index_range_line()
+        self.add_columns_summary_line()
+        self.add_header_line()
+        self.add_separator_line()
+        self.add_body_lines()
+        self.add_dtypes_line()
+        if self.display_memory_usage:
+            self.add_memory_usage_line()
+
+    @property
+    def headers(self) -> Sequence[str]:
+        if self.with_counts:
+            return [' # ', 'Column', 'Non-Null Count', 'Dtype']
+        return [' # ', 'Column', 'Dtype']
+
+    def add_columns_summary_line(self) -> None:
+        self._lines.append(f'Data columns (total {self.col_count} columns):')
+
+    def _gen_rows_without_counts(self) -> Iterator[Sequence[str]]:
+        yield from zip(self._gen_line_numbers(), self._gen_columns(), self._gen_dtypes())
+
+    def _gen_rows_with_counts(self) -> Iterator[Sequence[str]]:
+        yield from zip(self._gen_line_numbers(), self._gen_columns(), self._gen_non_null_counts(), self._gen_dtypes())
+
+    def _gen_line_numbers(self) -> Iterator[str]:
+        for (i, _) in enumerate(self.ids):
+            yield f' {i}'
+
+    def _gen_columns(self) -> Iterator[str]:
+        for col in self.ids:
+            yield pprint_thing(col)
+
+class _SeriesTableBuilder(_TableBuilderAbstract):
+
+    def __init__(self, *, info: SeriesInfo) -> None:
+        self.info: SeriesInfo = info
+
+    def get_lines(self) -> list[str]:
+        self._lines = []
+        self._fill_non_empty_info()
+        return self._lines
+
+    @property
+    def data(self) -> Series:
+        return self.info.data
+
+    def add_memory_usage_line(self) -> None:
+        self._lines.append(f'memory usage: {self.memory_usage_string}')
+
+    @abstractmethod
+    def _fill_non_empty_info(self) -> None:
+
+class _SeriesTableBuilderNonVerbose(_SeriesTableBuilder):
+
+    def _fill_non_empty_info(self) -> None:
+        self.add_object_type_line()
+        self.add_index_range_line()
+        self.add_dtypes_line()
+        if self.display_memory_usage:
+            self.add_memory_usage_line()
+
+class _SeriesTableBuilderVerbose(_SeriesTableBuilder, _TableBuilderVerboseMixin):
+
+    def __init__(self, *, info: SeriesInfo, with_counts: bool) -> None:
+        self.info = info
+        self.with_counts = with_counts
+        self.strrows: Sequence[Sequence[str]] = list(self._gen_rows())
+        self.gross_column_widths: Sequence[int] = self._get_gross_column_widths()
+
+    def _fill_non_empty_info(self) -> None:
+        self.add_object_type_line()
+        self.add_index_range_line()
+        self.add_series_name_line()
+        self.add_header_line()
+        self.add_separator_line()
+        self.add_body_lines()
+        self.add_dtypes_line()
+        if self.display_memory_usage:
+            self.add_memory_usage_line()
+
+    def add_series_name_line(self) -> None:
+        self._lines.append(f'Series name: {self.data.name}')
+
+    @property
+    def headers(self) -> Sequence[str]:
+        if self.with_counts:
+            return ['Non-Null Count', 'Dtype']
+        return ['Dtype']
+
+    def _gen_rows_without_counts(self) -> Iterator[Sequence[str]]:
+        yield from self._gen_dtypes()
+
+    def _gen_rows_with_counts(self) -> Iterator[Sequence[str]]:
+        yield from zip(self._gen_non_null_counts(), self._gen_dtypes())
+
+def _get_dataframe_dtype_counts(df: DataFrame) -> Mapping[str, int]:
+    return df.dtypes.value_counts().groupby(lambda x: x.name).sum()
+
+# File: pandas-main/pandas/io/formats/printing.py
+""""""
+from __future__ import annotations
+from collections.abc import Callable, Iterable, Mapping, Sequence
+import sys
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+from unicodedata import east_asian_width
+from pandas._config import get_option
+from pandas.core.dtypes.inference import is_sequence
+from pandas.io.formats.console import get_console_size
+if TYPE_CHECKING:
+    from pandas._typing import ListLike
+EscapeChars = Union[Mapping[str, str], Iterable[str]]
+_KT = TypeVar('_KT')
+_VT = TypeVar('_VT')
+
+def adjoin(space: int, *lists: list[str], **kwargs: Any) -> str:
+    strlen = kwargs.pop('strlen', len)
+    justfunc = kwargs.pop('justfunc', _adj_justify)
+    newLists = []
+    lengths = [max(map(strlen, x)) + space for x in lists[:-1]]
+    lengths.append(max(map(len, lists[-1])))
+    maxLen = max(map(len, lists))
+    for (i, lst) in enumerate(lists):
+        nl = justfunc(lst, lengths[i], mode='left')
+        nl = [' ' * lengths[i]] * (maxLen - len(lst)) + nl
+        newLists.append(nl)
+    toJoin = zip(*newLists)
+    return '\n'.join((''.join(lines) for lines in toJoin))
+
+def _adj_justify(texts: Iterable[str], max_len: int, mode: str='right') -> list[str]:
+    if mode == 'left':
+        return [x.ljust(max_len) for x in texts]
+    elif mode == 'center':
+        return [x.center(max_len) for x in texts]
+    else:
+        return [x.rjust(max_len) for x in texts]
+
+def _pprint_seq(seq: ListLike, _nest_lvl: int=0, max_seq_items: int | None=None, **kwds: Any) -> str:
+    if isinstance(seq, set):
+        fmt = '{{{body}}}'
+    else:
+        fmt = '[{body}]' if hasattr(seq, '__setitem__') else '({body})'
+    if max_seq_items is False:
+        max_items = None
+    else:
+        max_items = max_seq_items or get_option('max_seq_items') or len(seq)
+    s = iter(seq)
+    r = []
+    max_items_reached = False
+    for (i, item) in enumerate(s):
+        if max_items is not None and i >= max_items:
+            max_items_reached = True
+            break
+        r.append(pprint_thing(item, _nest_lvl + 1, max_seq_items=max_seq_items, **kwds))
+    body = ', '.join(r)
+    if max_items_reached:
+        body += ', ...'
+    elif isinstance(seq, tuple) and len(seq) == 1:
+        body += ','
+    return fmt.format(body=body)
+
+def _pprint_dict(seq: Mapping, _nest_lvl: int=0, max_seq_items: int | None=None, **kwds: Any) -> str:
+    fmt = '{{{things}}}'
+    pairs = []
+    pfmt = '{key}: {val}'
+    if max_seq_items is False:
+        nitems = len(seq)
+    else:
+        nitems = max_seq_items or get_option('max_seq_items') or len(seq)
+    for (k, v) in list(seq.items())[:nitems]:
+        pairs.append(pfmt.format(key=pprint_thing(k, _nest_lvl + 1, max_seq_items=max_seq_items, **kwds), val=pprint_thing(v, _nest_lvl + 1, max_seq_items=max_seq_items, **kwds)))
+    if nitems < len(seq):
+        return fmt.format(things=', '.join(pairs) + ', ...')
+    else:
+        return fmt.format(things=', '.join(pairs))
+
+def pprint_thing(thing: object, _nest_lvl: int=0, escape_chars: EscapeChars | None=None, default_escapes: bool=False, quote_strings: bool=False, max_seq_items: int | None=None) -> str:
+
+    def as_escaped_string(thing: Any, escape_chars: EscapeChars | None=escape_chars) -> str:
+        translate = {'\t': '\\t', '\n': '\\n', '\r': '\\r'}
+        if isinstance(escape_chars, Mapping):
+            if default_escapes:
+                translate.update(escape_chars)
+            else:
+                translate = escape_chars
+            escape_chars = list(escape_chars.keys())
+        else:
+            escape_chars = escape_chars or ()
+        result = str(thing)
+        for c in escape_chars:
+            result = result.replace(c, translate[c])
+        return result
+    if hasattr(thing, '__next__'):
+        return str(thing)
+    elif isinstance(thing, Mapping) and _nest_lvl < get_option('display.pprint_nest_depth'):
+        result = _pprint_dict(thing, _nest_lvl, quote_strings=True, max_seq_items=max_seq_items)
+    elif is_sequence(thing) and _nest_lvl < get_option('display.pprint_nest_depth'):
+        result = _pprint_seq(thing, _nest_lvl, escape_chars=escape_chars, quote_strings=quote_strings, max_seq_items=max_seq_items)
+    elif isinstance(thing, str) and quote_strings:
+        result = f"'{as_escaped_string(thing)}'"
+    else:
+        result = as_escaped_string(thing)
+    return result
+
+def pprint_thing_encoded(object: object, encoding: str='utf-8', errors: str='replace') -> bytes:
+    value = pprint_thing(object)
+    return value.encode(encoding, errors)
+
+def enable_data_resource_formatter(enable: bool) -> None:
+    if 'IPython' not in sys.modules:
+        return
+    from IPython import get_ipython
+    ip = get_ipython()
+    if ip is None:
+        return
+    formatters = ip.display_formatter.formatters
+    mimetype = 'application/vnd.dataresource+json'
+    if enable:
+        if mimetype not in formatters:
+            from IPython.core.formatters import BaseFormatter
+            from traitlets import ObjectName
+
+            class TableSchemaFormatter(BaseFormatter):
+                print_method = ObjectName('_repr_data_resource_')
+                _return_type = (dict,)
+            formatters[mimetype] = TableSchemaFormatter()
+        formatters[mimetype].enabled = True
+    elif mimetype in formatters:
+        formatters[mimetype].enabled = False
+
+def default_pprint(thing: Any, max_seq_items: int | None=None) -> str:
+    return pprint_thing(thing, escape_chars=('\t', '\r', '\n'), quote_strings=True, max_seq_items=max_seq_items)
+
+def format_object_summary(obj: ListLike, formatter: Callable, is_justify: bool=True, name: str | None=None, indent_for_name: bool=True, line_break_each_value: bool=False) -> str:
+    (display_width, _) = get_console_size()
+    if display_width is None:
+        display_width = get_option('display.width') or 80
+    if name is None:
+        name = type(obj).__name__
+    if indent_for_name:
+        name_len = len(name)
+        space1 = f"\n{' ' * (name_len + 1)}"
+        space2 = f"\n{' ' * (name_len + 2)}"
+    else:
+        space1 = '\n'
+        space2 = '\n '
+    n = len(obj)
+    if line_break_each_value:
+        sep = ',\n ' + ' ' * len(name)
+    else:
+        sep = ','
+    max_seq_items = get_option('display.max_seq_items') or n
+    is_truncated = n > max_seq_items
+    adj = get_adjustment()
+
+    def _extend_line(s: str, line: str, value: str, display_width: int, next_line_prefix: str) -> tuple[str, str]:
+        if adj.len(line.rstrip()) + adj.len(value.rstrip()) >= display_width:
+            s += line.rstrip()
+            line = next_line_prefix
+        line += value
+        return (s, line)
+
+    def best_len(values: list[str]) -> int:
+        if values:
+            return max((adj.len(x) for x in values))
+        else:
+            return 0
+    close = ', '
+    if n == 0:
+        summary = f'[]{close}'
+    elif n == 1 and (not line_break_each_value):
+        first = formatter(obj[0])
+        summary = f'[{first}]{close}'
+    elif n == 2 and (not line_break_each_value):
+        first = formatter(obj[0])
+        last = formatter(obj[-1])
+        summary = f'[{first}, {last}]{close}'
+    else:
+        if max_seq_items == 1:
+            head = []
+            tail = [formatter(x) for x in obj[-1:]]
+        elif n > max_seq_items:
+            n = min(max_seq_items // 2, 10)
+            head = [formatter(x) for x in obj[:n]]
+            tail = [formatter(x) for x in obj[-n:]]
+        else:
+            head = []
+            tail = [formatter(x) for x in obj]
+        if is_justify:
+            if line_break_each_value:
+                (head, tail) = _justify(head, tail)
+            elif is_truncated or not (len(', '.join(head)) < display_width and len(', '.join(tail)) < display_width):
+                max_length = max(best_len(head), best_len(tail))
+                head = [x.rjust(max_length) for x in head]
+                tail = [x.rjust(max_length) for x in tail]
+        if line_break_each_value:
+            max_space = display_width - len(space2)
+            value = tail[0]
+            max_items = 1
+            for num_items in reversed(range(1, len(value) + 1)):
+                pprinted_seq = _pprint_seq(value, max_seq_items=num_items)
+                if len(pprinted_seq) < max_space:
+                    max_items = num_items
+                    break
+            head = [_pprint_seq(x, max_seq_items=max_items) for x in head]
+            tail = [_pprint_seq(x, max_seq_items=max_items) for x in tail]
+        summary = ''
+        line = space2
+        for head_value in head:
+            word = head_value + sep + ' '
+            (summary, line) = _extend_line(summary, line, word, display_width, space2)
+        if is_truncated:
+            summary += line.rstrip() + space2 + '...'
+            line = space2
+        for tail_item in tail[:-1]:
+            word = tail_item + sep + ' '
+            (summary, line) = _extend_line(summary, line, word, display_width, space2)
+        (summary, line) = _extend_line(summary, line, tail[-1], display_width - 2, space2)
+        summary += line
+        close = ']' + close.rstrip(' ')
+        summary += close
+        if len(summary) > display_width or line_break_each_value:
+            summary += space1
+        else:
+            summary += ' '
+        summary = '[' + summary[len(space2):]
+    return summary
+
+def _justify(head: list[Sequence[str]], tail: list[Sequence[str]]) -> tuple[list[tuple[str, ...]], list[tuple[str, ...]]]:
+    combined = head + tail
+    max_length = [0] * len(combined[0])
+    for inner_seq in combined:
+        length = [len(item) for item in inner_seq]
+        max_length = [max(x, y) for (x, y) in zip(max_length, length)]
+    head_tuples = [tuple((x.rjust(max_len) for (x, max_len) in zip(seq, max_length))) for seq in head]
+    tail_tuples = [tuple((x.rjust(max_len) for (x, max_len) in zip(seq, max_length))) for seq in tail]
+    return (head_tuples, tail_tuples)
+
+class PrettyDict(dict[_KT, _VT]):
+
+    def __repr__(self) -> str:
+        return pprint_thing(self)
+
+class _TextAdjustment:
+
+    def __init__(self) -> None:
+        self.encoding = get_option('display.encoding')
+
+    def len(self, text: str) -> int:
+        return len(text)
+
+    def justify(self, texts: Any, max_len: int, mode: str='right') -> list[str]:
+        if mode == 'left':
+            return [x.ljust(max_len) for x in texts]
+        elif mode == 'center':
+            return [x.center(max_len) for x in texts]
+        else:
+            return [x.rjust(max_len) for x in texts]
+
+    def adjoin(self, space: int, *lists: Any, **kwargs: Any) -> str:
+        return adjoin(space, *lists, strlen=self.len, justfunc=self.justify, **kwargs)
+
+class _EastAsianTextAdjustment(_TextAdjustment):
+
+    def __init__(self) -> None:
+        super().__init__()
+        if get_option('display.unicode.ambiguous_as_wide'):
+            self.ambiguous_width = 2
+        else:
+            self.ambiguous_width = 1
+        self._EAW_MAP = {'Na': 1, 'N': 1, 'W': 2, 'F': 2, 'H': 1}
+
+    def len(self, text: str) -> int:
+        if not isinstance(text, str):
+            return len(text)
+        return sum((self._EAW_MAP.get(east_asian_width(c), self.ambiguous_width) for c in text))
+
+    def justify(self, texts: Iterable[str], max_len: int, mode: str='right') -> list[str]:
+
+        def _get_pad(t: str) -> int:
+            return max_len - self.len(t) + len(t)
+        if mode == 'left':
+            return [x.ljust(_get_pad(x)) for x in texts]
+        elif mode == 'center':
+            return [x.center(_get_pad(x)) for x in texts]
+        else:
+            return [x.rjust(_get_pad(x)) for x in texts]
+
+def get_adjustment() -> _TextAdjustment:
+    use_east_asian_width = get_option('display.unicode.east_asian_width')
+    if use_east_asian_width:
+        return _EastAsianTextAdjustment()
+    else:
+        return _TextAdjustment()
+
+# File: pandas-main/pandas/io/formats/string.py
+""""""
+from __future__ import annotations
+from shutil import get_terminal_size
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas.io.formats.printing import pprint_thing
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from pandas.io.formats.format import DataFrameFormatter
+
+class StringFormatter:
+
+    def __init__(self, fmt: DataFrameFormatter, line_width: int | None=None) -> None:
+        self.fmt = fmt
+        self.adj = fmt.adj
+        self.frame = fmt.frame
+        self.line_width = line_width
+
+    def to_string(self) -> str:
+        text = self._get_string_representation()
+        if self.fmt.should_show_dimensions:
+            text = f'{text}{self.fmt.dimensions_info}'
+        return text
+
+    def _get_strcols(self) -> list[list[str]]:
+        strcols = self.fmt.get_strcols()
+        if self.fmt.is_truncated:
+            strcols = self._insert_dot_separators(strcols)
+        return strcols
+
+    def _get_string_representation(self) -> str:
+        if self.fmt.frame.empty:
+            return self._empty_info_line
+        strcols = self._get_strcols()
+        if self.line_width is None:
+            return self.adj.adjoin(1, *strcols)
+        if self._need_to_wrap_around:
+            return self._join_multiline(strcols)
+        return self._fit_strcols_to_terminal_width(strcols)
+
+    @property
+    def _empty_info_line(self) -> str:
+        return f'Empty {type(self.frame).__name__}\nColumns: {pprint_thing(self.frame.columns)}\nIndex: {pprint_thing(self.frame.index)}'
+
+    @property
+    def _need_to_wrap_around(self) -> bool:
+        return bool(self.fmt.max_cols is None or self.fmt.max_cols > 0)
+
+    def _insert_dot_separators(self, strcols: list[list[str]]) -> list[list[str]]:
+        str_index = self.fmt._get_formatted_index(self.fmt.tr_frame)
+        index_length = len(str_index)
+        if self.fmt.is_truncated_horizontally:
+            strcols = self._insert_dot_separator_horizontal(strcols, index_length)
+        if self.fmt.is_truncated_vertically:
+            strcols = self._insert_dot_separator_vertical(strcols, index_length)
+        return strcols
+
+    @property
+    def _adjusted_tr_col_num(self) -> int:
+        return self.fmt.tr_col_num + 1 if self.fmt.index else self.fmt.tr_col_num
+
+    def _insert_dot_separator_horizontal(self, strcols: list[list[str]], index_length: int) -> list[list[str]]:
+        strcols.insert(self._adjusted_tr_col_num, [' ...'] * index_length)
+        return strcols
+
+    def _insert_dot_separator_vertical(self, strcols: list[list[str]], index_length: int) -> list[list[str]]:
+        n_header_rows = index_length - len(self.fmt.tr_frame)
+        row_num = self.fmt.tr_row_num
+        for (ix, col) in enumerate(strcols):
+            cwidth = self.adj.len(col[row_num])
+            if self.fmt.is_truncated_horizontally:
+                is_dot_col = ix == self._adjusted_tr_col_num
+            else:
+                is_dot_col = False
+            if cwidth > 3 or is_dot_col:
+                dots = '...'
+            else:
+                dots = '..'
+            if ix == 0 and self.fmt.index:
+                dot_mode = 'left'
+            elif is_dot_col:
+                cwidth = 4
+                dot_mode = 'right'
+            else:
+                dot_mode = 'right'
+            dot_str = self.adj.justify([dots], cwidth, mode=dot_mode)[0]
+            col.insert(row_num + n_header_rows, dot_str)
+        return strcols
+
+    def _join_multiline(self, strcols_input: Iterable[list[str]]) -> str:
+        lwidth = self.line_width
+        adjoin_width = 1
+        strcols = list(strcols_input)
+        if self.fmt.index:
+            idx = strcols.pop(0)
+            lwidth -= np.array([self.adj.len(x) for x in idx]).max() + adjoin_width
+        col_widths = [np.array([self.adj.len(x) for x in col]).max() if len(col) > 0 else 0 for col in strcols]
+        assert lwidth is not None
+        col_bins = _binify(col_widths, lwidth)
+        nbins = len(col_bins)
+        str_lst = []
+        start = 0
+        for (i, end) in enumerate(col_bins):
+            row = strcols[start:end]
+            if self.fmt.index:
+                row.insert(0, idx)
+            if nbins > 1:
+                nrows = len(row[-1])
+                if end <= len(strcols) and i < nbins - 1:
+                    row.append([' \\'] + ['  '] * (nrows - 1))
+                else:
+                    row.append([' '] * nrows)
+            str_lst.append(self.adj.adjoin(adjoin_width, *row))
+            start = end
+        return '\n\n'.join(str_lst)
+
+    def _fit_strcols_to_terminal_width(self, strcols: list[list[str]]) -> str:
+        from pandas import Series
+        lines = self.adj.adjoin(1, *strcols).split('\n')
+        max_len = Series(lines).str.len().max()
+        (width, _) = get_terminal_size()
+        dif = max_len - width
+        adj_dif = dif + 1
+        col_lens = Series([Series(ele).str.len().max() for ele in strcols])
+        n_cols = len(col_lens)
+        counter = 0
+        while adj_dif > 0 and n_cols > 1:
+            counter += 1
+            mid = round(n_cols / 2)
+            mid_ix = col_lens.index[mid]
+            col_len = col_lens[mid_ix]
+            adj_dif -= col_len + 1
+            col_lens = col_lens.drop(mid_ix)
+            n_cols = len(col_lens)
+        max_cols_fitted = n_cols - self.fmt.index
+        max_cols_fitted = max(max_cols_fitted, 2)
+        self.fmt.max_cols_fitted = max_cols_fitted
+        self.fmt.truncate()
+        strcols = self._get_strcols()
+        return self.adj.adjoin(1, *strcols)
+
+def _binify(cols: list[int], line_width: int) -> list[int]:
+    adjoin_width = 1
+    bins = []
+    curr_width = 0
+    i_last_column = len(cols) - 1
+    for (i, w) in enumerate(cols):
+        w_adjoined = w + adjoin_width
+        curr_width += w_adjoined
+        if i_last_column == i:
+            wrap = curr_width + 1 > line_width and i > 0
+        else:
+            wrap = curr_width + 2 > line_width and i > 0
+        if wrap:
+            bins.append(i)
+            curr_width = w_adjoined
+    bins.append(len(cols))
+    return bins
+
+# File: pandas-main/pandas/io/formats/style.py
+""""""
+from __future__ import annotations
+import copy
+from functools import partial
+import operator
+import textwrap
+from typing import TYPE_CHECKING, overload
+import numpy as np
+from pandas._config import get_option
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._decorators import Substitution, doc
+import pandas as pd
+from pandas import IndexSlice, RangeIndex
+import pandas.core.common as com
+from pandas.core.frame import DataFrame, Series
+from pandas.core.generic import NDFrame
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.formats.format import save_to_buffer
+jinja2 = import_optional_dependency('jinja2', extra='DataFrame.style requires jinja2.')
+from pandas.io.formats.style_render import CSSProperties, CSSStyles, ExtFormatter, StylerRenderer, Subset, Tooltips, format_table_styles, maybe_convert_css_to_tuples, non_reducing_slice, refactor_levels
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Sequence
+    from matplotlib.colors import Colormap
+    from pandas._typing import Any, Axis, AxisInt, Concatenate, ExcelWriterMergeCells, FilePath, IndexLabel, IntervalClosedType, Level, P, QuantileInterpolation, Scalar, Self, StorageOptions, T, WriteBuffer, WriteExcelBuffer
+    from pandas import ExcelWriter
+subset_args = 'subset : label, array-like, IndexSlice, optional\n            A valid 2d input to `DataFrame.loc[<subset>]`, or, in the case of a 1d input\n            or single key, to `DataFrame.loc[:, <subset>]` where the columns are\n            prioritised, to limit ``data`` to *before* applying the function.'
+properties_args = 'props : str, default None\n           CSS properties to use for highlighting. If ``props`` is given, ``color``\n           is not used.'
+coloring_args = "color : str, default '{default}'\n           Background color to use for highlighting."
+buffering_args = 'buf : str, path object, file-like object, optional\n         String, path object (implementing ``os.PathLike[str]``), or file-like\n         object implementing a string ``write()`` function. If ``None``, the result is\n         returned as a string.'
+encoding_args = 'encoding : str, optional\n              Character encoding setting for file output (and meta tags if available).\n              Defaults to ``pandas.options.styler.render.encoding`` value of "utf-8".'
+
+class Styler(StylerRenderer):
+
+    def __init__(self, data: DataFrame | Series, precision: int | None=None, table_styles: CSSStyles | None=None, uuid: str | None=None, caption: str | tuple | list | None=None, table_attributes: str | None=None, cell_ids: bool=True, na_rep: str | None=None, uuid_len: int=5, decimal: str | None=None, thousands: str | None=None, escape: str | None=None, formatter: ExtFormatter | None=None) -> None:
+        super().__init__(data=data, uuid=uuid, uuid_len=uuid_len, table_styles=table_styles, table_attributes=table_attributes, caption=caption, cell_ids=cell_ids, precision=precision)
+        thousands = thousands or get_option('styler.format.thousands')
+        decimal = decimal or get_option('styler.format.decimal')
+        na_rep = na_rep or get_option('styler.format.na_rep')
+        escape = escape or get_option('styler.format.escape')
+        formatter = formatter or get_option('styler.format.formatter')
+        self.format(formatter=formatter, precision=precision, na_rep=na_rep, escape=escape, decimal=decimal, thousands=thousands)
+
+    def concat(self, other: Styler) -> Styler:
+        if not isinstance(other, Styler):
+            raise TypeError('`other` must be of type `Styler`')
+        if not self.data.columns.equals(other.data.columns):
+            raise ValueError('`other.data` must have same columns as `Styler.data`')
+        if not self.data.index.nlevels == other.data.index.nlevels:
+            raise ValueError('number of index levels must be same in `other` as in `Styler`. See documentation for suggestions.')
+        self.concatenated.append(other)
+        return self
+
+    def _repr_html_(self) -> str | None:
+        if get_option('styler.render.repr') == 'html':
+            return self.to_html()
+        return None
+
+    def _repr_latex_(self) -> str | None:
+        if get_option('styler.render.repr') == 'latex':
+            return self.to_latex()
+        return None
+
+    def set_tooltips(self, ttips: DataFrame, props: CSSProperties | None=None, css_class: str | None=None, as_title_attribute: bool=False) -> Styler:
+        if not self.cell_ids:
+            raise NotImplementedError("Tooltips can only render with 'cell_ids' is True.")
+        if not ttips.index.is_unique or not ttips.columns.is_unique:
+            raise KeyError('Tooltips render only if `ttips` has unique index and columns.')
+        if self.tooltips is None:
+            self.tooltips = Tooltips()
+        self.tooltips.tt_data = ttips
+        if not as_title_attribute:
+            if props:
+                self.tooltips.class_properties = props
+            if css_class:
+                self.tooltips.class_name = css_class
+        else:
+            self.tooltips.as_title_attribute = as_title_attribute
+        return self
+
+    @doc(NDFrame.to_excel, klass='Styler', storage_options=_shared_docs['storage_options'], storage_options_versionadded='1.5.0', encoding_parameter=textwrap.dedent('        encoding : str or None, default None\n            Unused parameter, present for compatibility.\n        '), verbose_parameter=textwrap.dedent('        verbose : str, default True\n            Optional unused parameter, present for compatibility.\n        '), extra_parameters='')
+    def to_excel(self, excel_writer: FilePath | WriteExcelBuffer | ExcelWriter, sheet_name: str='Sheet1', na_rep: str='', float_format: str | None=None, columns: Sequence[Hashable] | None=None, header: Sequence[Hashable] | bool=True, index: bool=True, index_label: IndexLabel | None=None, startrow: int=0, startcol: int=0, engine: str | None=None, merge_cells: ExcelWriterMergeCells=True, encoding: str | None=None, inf_rep: str='inf', verbose: bool=True, freeze_panes: tuple[int, int] | None=None, storage_options: StorageOptions | None=None) -> None:
+        from pandas.io.formats.excel import ExcelFormatter
+        formatter = ExcelFormatter(self, na_rep=na_rep, cols=columns, header=header, float_format=float_format, index=index, index_label=index_label, merge_cells=merge_cells, inf_rep=inf_rep)
+        formatter.write(excel_writer, sheet_name=sheet_name, startrow=startrow, startcol=startcol, freeze_panes=freeze_panes, engine=engine, storage_options=storage_options)
+
+    @overload
+    def to_latex(self, buf: FilePath | WriteBuffer[str], *, column_format: str | None=..., position: str | None=..., position_float: str | None=..., hrules: bool | None=..., clines: str | None=..., label: str | None=..., caption: str | tuple | None=..., sparse_index: bool | None=..., sparse_columns: bool | None=..., multirow_align: str | None=..., multicol_align: str | None=..., siunitx: bool=..., environment: str | None=..., encoding: str | None=..., convert_css: bool=...) -> None:
+        ...
+
+    @overload
+    def to_latex(self, buf: None=..., *, column_format: str | None=..., position: str | None=..., position_float: str | None=..., hrules: bool | None=..., clines: str | None=..., label: str | None=..., caption: str | tuple | None=..., sparse_index: bool | None=..., sparse_columns: bool | None=..., multirow_align: str | None=..., multicol_align: str | None=..., siunitx: bool=..., environment: str | None=..., encoding: str | None=..., convert_css: bool=...) -> str:
+        ...
+
+    def to_latex(self, buf: FilePath | WriteBuffer[str] | None=None, *, column_format: str | None=None, position: str | None=None, position_float: str | None=None, hrules: bool | None=None, clines: str | None=None, label: str | None=None, caption: str | tuple | None=None, sparse_index: bool | None=None, sparse_columns: bool | None=None, multirow_align: str | None=None, multicol_align: str | None=None, siunitx: bool=False, environment: str | None=None, encoding: str | None=None, convert_css: bool=False) -> str | None:
+        obj = self._copy(deepcopy=True)
+        table_selectors = [style['selector'] for style in self.table_styles] if self.table_styles is not None else []
+        if column_format is not None:
+            obj.set_table_styles([{'selector': 'column_format', 'props': f':{column_format}'}], overwrite=False)
+        elif 'column_format' in table_selectors:
+            pass
+        else:
+            _original_columns = self.data.columns
+            self.data.columns = RangeIndex(stop=len(self.data.columns))
+            numeric_cols = self.data._get_numeric_data().columns.to_list()
+            self.data.columns = _original_columns
+            column_format = ''
+            for level in range(self.index.nlevels):
+                column_format += '' if self.hide_index_[level] else 'l'
+            for (ci, _) in enumerate(self.data.columns):
+                if ci not in self.hidden_columns:
+                    column_format += ('r' if not siunitx else 'S') if ci in numeric_cols else 'l'
+            obj.set_table_styles([{'selector': 'column_format', 'props': f':{column_format}'}], overwrite=False)
+        if position:
+            obj.set_table_styles([{'selector': 'position', 'props': f':{position}'}], overwrite=False)
+        if position_float:
+            if environment == 'longtable':
+                raise ValueError("`position_float` cannot be used in 'longtable' `environment`")
+            if position_float not in ['raggedright', 'raggedleft', 'centering']:
+                raise ValueError(f"`position_float` should be one of 'raggedright', 'raggedleft', 'centering', got: '{position_float}'")
+            obj.set_table_styles([{'selector': 'position_float', 'props': f':{position_float}'}], overwrite=False)
+        hrules = get_option('styler.latex.hrules') if hrules is None else hrules
+        if hrules:
+            obj.set_table_styles([{'selector': 'toprule', 'props': ':toprule'}, {'selector': 'midrule', 'props': ':midrule'}, {'selector': 'bottomrule', 'props': ':bottomrule'}], overwrite=False)
+        if label:
+            obj.set_table_styles([{'selector': 'label', 'props': f":{{{label.replace(':', '§')}}}"}], overwrite=False)
+        if caption:
+            obj.set_caption(caption)
+        if sparse_index is None:
+            sparse_index = get_option('styler.sparse.index')
+        if sparse_columns is None:
+            sparse_columns = get_option('styler.sparse.columns')
+        environment = environment or get_option('styler.latex.environment')
+        multicol_align = multicol_align or get_option('styler.latex.multicol_align')
+        multirow_align = multirow_align or get_option('styler.latex.multirow_align')
+        latex = obj._render_latex(sparse_index=sparse_index, sparse_columns=sparse_columns, multirow_align=multirow_align, multicol_align=multicol_align, environment=environment, convert_css=convert_css, siunitx=siunitx, clines=clines)
+        encoding = encoding or get_option('styler.render.encoding') if isinstance(buf, str) else encoding
+        return save_to_buffer(latex, buf=buf, encoding=encoding)
+
+    @overload
+    def to_html(self, buf: FilePath | WriteBuffer[str], *, table_uuid: str | None=..., table_attributes: str | None=..., sparse_index: bool | None=..., sparse_columns: bool | None=..., bold_headers: bool=..., caption: str | None=..., max_rows: int | None=..., max_columns: int | None=..., encoding: str | None=..., doctype_html: bool=..., exclude_styles: bool=..., **kwargs) -> None:
+        ...
+
+    @overload
+    def to_html(self, buf: None=..., *, table_uuid: str | None=..., table_attributes: str | None=..., sparse_index: bool | None=..., sparse_columns: bool | None=..., bold_headers: bool=..., caption: str | None=..., max_rows: int | None=..., max_columns: int | None=..., encoding: str | None=..., doctype_html: bool=..., exclude_styles: bool=..., **kwargs) -> str:
+        ...
+
+    @Substitution(buf=buffering_args, encoding=encoding_args)
+    def to_html(self, buf: FilePath | WriteBuffer[str] | None=None, *, table_uuid: str | None=None, table_attributes: str | None=None, sparse_index: bool | None=None, sparse_columns: bool | None=None, bold_headers: bool=False, caption: str | None=None, max_rows: int | None=None, max_columns: int | None=None, encoding: str | None=None, doctype_html: bool=False, exclude_styles: bool=False, **kwargs) -> str | None:
+        obj = self._copy(deepcopy=True)
+        if table_uuid:
+            obj.set_uuid(table_uuid)
+        if table_attributes:
+            obj.set_table_attributes(table_attributes)
+        if sparse_index is None:
+            sparse_index = get_option('styler.sparse.index')
+        if sparse_columns is None:
+            sparse_columns = get_option('styler.sparse.columns')
+        if bold_headers:
+            obj.set_table_styles([{'selector': 'th', 'props': 'font-weight: bold;'}], overwrite=False)
+        if caption is not None:
+            obj.set_caption(caption)
+        html = obj._render_html(sparse_index=sparse_index, sparse_columns=sparse_columns, max_rows=max_rows, max_cols=max_columns, exclude_styles=exclude_styles, encoding=encoding or get_option('styler.render.encoding'), doctype_html=doctype_html, **kwargs)
+        return save_to_buffer(html, buf=buf, encoding=encoding if buf is not None else None)
+
+    @overload
+    def to_string(self, buf: FilePath | WriteBuffer[str], *, encoding: str | None=..., sparse_index: bool | None=..., sparse_columns: bool | None=..., max_rows: int | None=..., max_columns: int | None=..., delimiter: str=...) -> None:
+        ...
+
+    @overload
+    def to_string(self, buf: None=..., *, encoding: str | None=..., sparse_index: bool | None=..., sparse_columns: bool | None=..., max_rows: int | None=..., max_columns: int | None=..., delimiter: str=...) -> str:
+        ...
+
+    @Substitution(buf=buffering_args, encoding=encoding_args)
+    def to_string(self, buf: FilePath | WriteBuffer[str] | None=None, *, encoding: str | None=None, sparse_index: bool | None=None, sparse_columns: bool | None=None, max_rows: int | None=None, max_columns: int | None=None, delimiter: str=' ') -> str | None:
+        obj = self._copy(deepcopy=True)
+        if sparse_index is None:
+            sparse_index = get_option('styler.sparse.index')
+        if sparse_columns is None:
+            sparse_columns = get_option('styler.sparse.columns')
+        text = obj._render_string(sparse_columns=sparse_columns, sparse_index=sparse_index, max_rows=max_rows, max_cols=max_columns, delimiter=delimiter)
+        return save_to_buffer(text, buf=buf, encoding=encoding if buf is not None else None)
+
+    def set_td_classes(self, classes: DataFrame) -> Styler:
+        if not classes.index.is_unique or not classes.columns.is_unique:
+            raise KeyError('Classes render only if `classes` has unique index and columns.')
+        classes = classes.reindex_like(self.data)
+        for (r, row_tup) in enumerate(classes.itertuples()):
+            for (c, value) in enumerate(row_tup[1:]):
+                if not (pd.isna(value) or value == ''):
+                    self.cell_context[r, c] = str(value)
+        return self
+
+    def _update_ctx(self, attrs: DataFrame) -> None:
+        if not self.index.is_unique or not self.columns.is_unique:
+            raise KeyError('`Styler.apply` and `.map` are not compatible with non-unique index or columns.')
+        for cn in attrs.columns:
+            j = self.columns.get_loc(cn)
+            ser = attrs[cn]
+            for (rn, c) in ser.items():
+                if not c or pd.isna(c):
+                    continue
+                css_list = maybe_convert_css_to_tuples(c)
+                i = self.index.get_loc(rn)
+                self.ctx[i, j].extend(css_list)
+
+    def _update_ctx_header(self, attrs: DataFrame, axis: AxisInt) -> None:
+        for j in attrs.columns:
+            ser = attrs[j]
+            for (i, c) in ser.items():
+                if not c:
+                    continue
+                css_list = maybe_convert_css_to_tuples(c)
+                if axis == 0:
+                    self.ctx_index[i, j].extend(css_list)
+                else:
+                    self.ctx_columns[j, i].extend(css_list)
+
+    def _copy(self, deepcopy: bool=False) -> Styler:
+        styler = type(self)(self.data)
+        shallow = ['hide_index_', 'hide_columns_', 'hide_column_names', 'hide_index_names', 'table_attributes', 'cell_ids', 'caption', 'uuid', 'uuid_len', 'template_latex', 'template_html_style', 'template_html_table', 'template_html']
+        deep = ['css', 'concatenated', '_display_funcs', '_display_funcs_index', '_display_funcs_columns', '_display_funcs_index_names', '_display_funcs_column_names', 'hidden_rows', 'hidden_columns', 'ctx', 'ctx_index', 'ctx_columns', 'cell_context', '_todo', 'table_styles', 'tooltips']
+        for attr in shallow:
+            setattr(styler, attr, getattr(self, attr))
+        for attr in deep:
+            val = getattr(self, attr)
+            setattr(styler, attr, copy.deepcopy(val) if deepcopy else val)
+        return styler
+
+    def __copy__(self) -> Styler:
+        return self._copy(deepcopy=False)
+
+    def __deepcopy__(self, memo) -> Styler:
+        return self._copy(deepcopy=True)
+
+    def clear(self) -> None:
+        clean_copy = Styler(self.data, uuid=self.uuid)
+        clean_attrs = [a for a in clean_copy.__dict__ if not callable(a)]
+        self_attrs = [a for a in self.__dict__ if not callable(a)]
+        for attr in clean_attrs:
+            setattr(self, attr, getattr(clean_copy, attr))
+        for attr in set(self_attrs).difference(clean_attrs):
+            delattr(self, attr)
+
+    def _apply(self, func: Callable, axis: Axis | None=0, subset: Subset | None=None, **kwargs) -> Styler:
+        subset = slice(None) if subset is None else subset
+        subset = non_reducing_slice(subset)
+        data = self.data.loc[subset]
+        if data.empty:
+            result = DataFrame()
+        elif axis is None:
+            result = func(data, **kwargs)
+            if not isinstance(result, DataFrame):
+                if not isinstance(result, np.ndarray):
+                    raise TypeError(f'Function {func!r} must return a DataFrame or ndarray when passed to `Styler.apply` with axis=None')
+                if data.shape != result.shape:
+                    raise ValueError(f'Function {func!r} returned ndarray with wrong shape.\nResult has shape: {result.shape}\nExpected shape: {data.shape}')
+                result = DataFrame(result, index=data.index, columns=data.columns)
+        else:
+            axis = self.data._get_axis_number(axis)
+            if axis == 0:
+                result = data.apply(func, axis=0, **kwargs)
+            else:
+                result = data.T.apply(func, axis=0, **kwargs).T
+        if isinstance(result, Series):
+            raise ValueError(f'Function {func!r} resulted in the apply method collapsing to a Series.\nUsually, this is the result of the function returning a single value, instead of list-like.')
+        msg = f"Function {func!r} created invalid {{0}} labels.\nUsually, this is the result of the function returning a {('Series' if axis is not None else 'DataFrame')} which contains invalid labels, or returning an incorrectly shaped, list-like object which cannot be mapped to labels, possibly due to applying the function along the wrong axis.\nResult {{0}} has shape: {{1}}\nExpected {{0}} shape:   {{2}}"
+        if not all(result.index.isin(data.index)):
+            raise ValueError(msg.format('index', result.index.shape, data.index.shape))
+        if not all(result.columns.isin(data.columns)):
+            raise ValueError(msg.format('columns', result.columns.shape, data.columns.shape))
+        self._update_ctx(result)
+        return self
+
+    @Substitution(subset=subset_args)
+    def apply(self, func: Callable, axis: Axis | None=0, subset: Subset | None=None, **kwargs) -> Styler:
+        self._todo.append((lambda instance: getattr(instance, '_apply'), (func, axis, subset), kwargs))
+        return self
+
+    def _apply_index(self, func: Callable, axis: Axis=0, level: Level | list[Level] | None=None, method: str='apply', **kwargs) -> Styler:
+        axis = self.data._get_axis_number(axis)
+        obj = self.index if axis == 0 else self.columns
+        levels_ = refactor_levels(level, obj)
+        data = DataFrame(obj.to_list()).loc[:, levels_]
+        if method == 'apply':
+            result = data.apply(func, axis=0, **kwargs)
+        elif method == 'map':
+            result = data.map(func, **kwargs)
+        self._update_ctx_header(result, axis)
+        return self
+
+    @doc(this='apply', wise='level-wise', alt='map', altwise='elementwise', func='take a Series and return a string array of the same length', input_note='the index as a Series, if an Index, or a level of a MultiIndex', output_note='an identically sized array of CSS styles as strings', var='label', ret='np.where(label == "B", "background-color: yellow;", "")', ret2='["background-color: yellow;" if "x" in v else "" for v in label]')
+    def apply_index(self, func: Callable, axis: AxisInt | str=0, level: Level | list[Level] | None=None, **kwargs) -> Styler:
+        self._todo.append((lambda instance: getattr(instance, '_apply_index'), (func, axis, level, 'apply'), kwargs))
+        return self
+
+    @doc(apply_index, this='map', wise='elementwise', alt='apply', altwise='level-wise', func='take a scalar and return a string', input_note='an index value, if an Index, or a level value of a MultiIndex', output_note='CSS styles as a string', var='label', ret='"background-color: yellow;" if label == "B" else None', ret2='"background-color: yellow;" if "x" in label else None')
+    def map_index(self, func: Callable, axis: AxisInt | str=0, level: Level | list[Level] | None=None, **kwargs) -> Styler:
+        self._todo.append((lambda instance: getattr(instance, '_apply_index'), (func, axis, level, 'map'), kwargs))
+        return self
+
+    def _map(self, func: Callable, subset: Subset | None=None, **kwargs) -> Styler:
+        func = partial(func, **kwargs)
+        if subset is None:
+            subset = IndexSlice[:]
+        subset = non_reducing_slice(subset)
+        result = self.data.loc[subset].map(func)
+        self._update_ctx(result)
+        return self
+
+    @Substitution(subset=subset_args)
+    def map(self, func: Callable, subset: Subset | None=None, **kwargs) -> Styler:
+        self._todo.append((lambda instance: getattr(instance, '_map'), (func, subset), kwargs))
+        return self
+
+    def set_table_attributes(self, attributes: str) -> Styler:
+        self.table_attributes = attributes
+        return self
+
+    def export(self) -> dict[str, Any]:
+        return {'apply': copy.copy(self._todo), 'table_attributes': self.table_attributes, 'table_styles': copy.copy(self.table_styles), 'hide_index': all(self.hide_index_), 'hide_columns': all(self.hide_columns_), 'hide_index_names': self.hide_index_names, 'hide_column_names': self.hide_column_names, 'css': copy.copy(self.css)}
+
+    def use(self, styles: dict[str, Any]) -> Styler:
+        self._todo.extend(styles.get('apply', []))
+        table_attributes: str = self.table_attributes or ''
+        obj_table_atts: str = '' if styles.get('table_attributes') is None else str(styles.get('table_attributes'))
+        self.set_table_attributes((table_attributes + ' ' + obj_table_atts).strip())
+        if styles.get('table_styles'):
+            self.set_table_styles(styles.get('table_styles'), overwrite=False)
+        for obj in ['index', 'columns']:
+            hide_obj = styles.get('hide_' + obj)
+            if hide_obj is not None:
+                if isinstance(hide_obj, bool):
+                    n = getattr(self, obj).nlevels
+                    setattr(self, 'hide_' + obj + '_', [hide_obj] * n)
+                else:
+                    setattr(self, 'hide_' + obj + '_', hide_obj)
+        self.hide_index_names = styles.get('hide_index_names', False)
+        self.hide_column_names = styles.get('hide_column_names', False)
+        if styles.get('css'):
+            self.css = styles.get('css')
+        return self
+
+    def set_uuid(self, uuid: str) -> Styler:
+        self.uuid = uuid
+        return self
+
+    def set_caption(self, caption: str | tuple | list) -> Styler:
+        msg = '`caption` must be either a string or 2-tuple of strings.'
+        if isinstance(caption, (list, tuple)):
+            if len(caption) != 2 or not isinstance(caption[0], str) or (not isinstance(caption[1], str)):
+                raise ValueError(msg)
+        elif not isinstance(caption, str):
+            raise ValueError(msg)
+        self.caption = caption
+        return self
+
+    def set_sticky(self, axis: Axis=0, pixel_size: int | None=None, levels: Level | list[Level] | None=None) -> Styler:
+        axis = self.data._get_axis_number(axis)
+        obj = self.data.index if axis == 0 else self.data.columns
+        pixel_size = (75 if axis == 0 else 25) if not pixel_size else pixel_size
+        props = 'position:sticky; background-color:inherit;'
+        if not isinstance(obj, pd.MultiIndex):
+            if axis == 1:
+                styles: CSSStyles = [{'selector': 'thead tr:nth-child(1) th', 'props': props + 'top:0px; z-index:2;'}]
+                if self.index.names[0] is not None:
+                    styles[0]['props'] = props + f'top:0px; z-index:2; height:{pixel_size}px;'
+                    styles.append({'selector': 'thead tr:nth-child(2) th', 'props': props + f'top:{pixel_size}px; z-index:2; height:{pixel_size}px; '})
+            else:
+                styles = [{'selector': 'thead tr th:nth-child(1)', 'props': props + 'left:0px; z-index:3 !important;'}, {'selector': 'tbody tr th:nth-child(1)', 'props': props + 'left:0px; z-index:1;'}]
+        else:
+            range_idx = list(range(obj.nlevels))
+            levels_: list[int] = refactor_levels(levels, obj) if levels else range_idx
+            levels_ = sorted(levels_)
+            if axis == 1:
+                styles = []
+                for (i, level) in enumerate(levels_):
+                    styles.append({'selector': f'thead tr:nth-child({level + 1}) th', 'props': props + f'top:{i * pixel_size}px; height:{pixel_size}px; z-index:2;'})
+                if not all((name is None for name in self.index.names)):
+                    styles.append({'selector': f'thead tr:nth-child({obj.nlevels + 1}) th', 'props': props + f'top:{len(levels_) * pixel_size}px; height:{pixel_size}px; z-index:2;'})
+            else:
+                styles = []
+                for (i, level) in enumerate(levels_):
+                    props_ = props + f'left:{i * pixel_size}px; min-width:{pixel_size}px; max-width:{pixel_size}px; '
+                    styles.extend([{'selector': f'thead tr th:nth-child({level + 1})', 'props': props_ + 'z-index:3 !important;'}, {'selector': f'tbody tr th.level{level}', 'props': props_ + 'z-index:1;'}])
+        return self.set_table_styles(styles, overwrite=False)
+
+    def set_table_styles(self, table_styles: dict[Any, CSSStyles] | CSSStyles | None=None, axis: AxisInt=0, overwrite: bool=True, css_class_names: dict[str, str] | None=None) -> Styler:
+        if css_class_names is not None:
+            self.css = {**self.css, **css_class_names}
+        if table_styles is None:
+            return self
+        elif isinstance(table_styles, dict):
+            axis = self.data._get_axis_number(axis)
+            obj = self.data.index if axis == 1 else self.data.columns
+            idf = f".{self.css['row']}" if axis == 1 else f".{self.css['col']}"
+            table_styles = [{'selector': str(s['selector']) + idf + str(idx), 'props': maybe_convert_css_to_tuples(s['props'])} for (key, styles) in table_styles.items() for idx in obj.get_indexer_for([key]) for s in format_table_styles(styles)]
+        else:
+            table_styles = [{'selector': s['selector'], 'props': maybe_convert_css_to_tuples(s['props'])} for s in table_styles]
+        if not overwrite and self.table_styles is not None:
+            self.table_styles.extend(table_styles)
+        else:
+            self.table_styles = table_styles
+        return self
+
+    def hide(self, subset: Subset | None=None, axis: Axis=0, level: Level | list[Level] | None=None, names: bool=False) -> Styler:
+        axis = self.data._get_axis_number(axis)
+        if axis == 0:
+            (obj, objs, alt) = ('index', 'index', 'rows')
+        else:
+            (obj, objs, alt) = ('column', 'columns', 'columns')
+        if level is not None and subset is not None:
+            raise ValueError('`subset` and `level` cannot be passed simultaneously')
+        if subset is None:
+            if level is None and names:
+                setattr(self, f'hide_{obj}_names', True)
+                return self
+            levels_ = refactor_levels(level, getattr(self, objs))
+            setattr(self, f'hide_{objs}_', [lev in levels_ for lev in range(getattr(self, objs).nlevels)])
+        else:
+            if axis == 0:
+                subset_ = IndexSlice[subset, :]
+            else:
+                subset_ = IndexSlice[:, subset]
+            subset = non_reducing_slice(subset_)
+            hide = self.data.loc[subset]
+            h_els = getattr(self, objs).get_indexer_for(getattr(hide, objs))
+            setattr(self, f'hidden_{alt}', h_els)
+        if names:
+            setattr(self, f'hide_{obj}_names', True)
+        return self
+
+    def _get_numeric_subset_default(self):
+        return self.data.columns.isin(self.data.select_dtypes(include=np.number))
+
+    @doc(name='background', alt='text', image_prefix='bg', text_threshold='text_color_threshold : float or int\n\n            Luminance threshold for determining text color in [0, 1]. Facilitates text\n\n            visibility across varying background colors. All text is dark if 0, and\n\n            light if 1, defaults to 0.408.')
+    @Substitution(subset=subset_args)
+    def background_gradient(self, cmap: str | Colormap='PuBu', low: float=0, high: float=0, axis: Axis | None=0, subset: Subset | None=None, text_color_threshold: float=0.408, vmin: float | None=None, vmax: float | None=None, gmap: Sequence | None=None) -> Styler:
+        if subset is None and gmap is None:
+            subset = self._get_numeric_subset_default()
+        self.apply(_background_gradient, cmap=cmap, subset=subset, axis=axis, low=low, high=high, text_color_threshold=text_color_threshold, vmin=vmin, vmax=vmax, gmap=gmap)
+        return self
+
+    @doc(background_gradient, name='text', alt='background', image_prefix='tg', text_threshold='')
+    def text_gradient(self, cmap: str | Colormap='PuBu', low: float=0, high: float=0, axis: Axis | None=0, subset: Subset | None=None, vmin: float | None=None, vmax: float | None=None, gmap: Sequence | None=None) -> Styler:
+        if subset is None and gmap is None:
+            subset = self._get_numeric_subset_default()
+        return self.apply(_background_gradient, cmap=cmap, subset=subset, axis=axis, low=low, high=high, vmin=vmin, vmax=vmax, gmap=gmap, text_only=True)
+
+    @Substitution(subset=subset_args)
+    def set_properties(self, subset: Subset | None=None, **kwargs) -> Styler:
+        values = ''.join([f'{p}: {v};' for (p, v) in kwargs.items()])
+        return self.map(lambda x: values, subset=subset)
+
+    @Substitution(subset=subset_args)
+    def bar(self, subset: Subset | None=None, axis: Axis | None=0, *, color: str | list | tuple | None=None, cmap: Any | None=None, width: float=100, height: float=100, align: str | float | Callable='mid', vmin: float | None=None, vmax: float | None=None, props: str='width: 10em;') -> Styler:
+        if color is None and cmap is None:
+            color = '#d65f5f'
+        elif color is not None and cmap is not None:
+            raise ValueError('`color` and `cmap` cannot both be given')
+        elif color is not None:
+            if isinstance(color, (list, tuple)) and len(color) > 2 or not isinstance(color, (str, list, tuple)):
+                raise ValueError("`color` must be string or list or tuple of 2 strings,(eg: color=['#d65f5f', '#5fba7d'])")
+        if not 0 <= width <= 100:
+            raise ValueError(f'`width` must be a value in [0, 100], got {width}')
+        if not 0 <= height <= 100:
+            raise ValueError(f'`height` must be a value in [0, 100], got {height}')
+        if subset is None:
+            subset = self._get_numeric_subset_default()
+        self.apply(_bar, subset=subset, axis=axis, align=align, colors=color, cmap=cmap, width=width / 100, height=height / 100, vmin=vmin, vmax=vmax, base_css=props)
+        return self
+
+    @Substitution(subset=subset_args, props=properties_args, color=coloring_args.format(default='red'))
+    def highlight_null(self, color: str='red', subset: Subset | None=None, props: str | None=None) -> Styler:
+
+        def f(data: DataFrame, props: str) -> np.ndarray:
+            return np.where(pd.isna(data).to_numpy(), props, '')
+        if props is None:
+            props = f'background-color: {color};'
+        return self.apply(f, axis=None, subset=subset, props=props)
+
+    @Substitution(subset=subset_args, color=coloring_args.format(default='yellow'), props=properties_args)
+    def highlight_max(self, subset: Subset | None=None, color: str='yellow', axis: Axis | None=0, props: str | None=None) -> Styler:
+        if props is None:
+            props = f'background-color: {color};'
+        return self.apply(partial(_highlight_value, op='max'), axis=axis, subset=subset, props=props)
+
+    @Substitution(subset=subset_args, color=coloring_args.format(default='yellow'), props=properties_args)
+    def highlight_min(self, subset: Subset | None=None, color: str='yellow', axis: Axis | None=0, props: str | None=None) -> Styler:
+        if props is None:
+            props = f'background-color: {color};'
+        return self.apply(partial(_highlight_value, op='min'), axis=axis, subset=subset, props=props)
+
+    @Substitution(subset=subset_args, color=coloring_args.format(default='yellow'), props=properties_args)
+    def highlight_between(self, subset: Subset | None=None, color: str='yellow', axis: Axis | None=0, left: Scalar | Sequence | None=None, right: Scalar | Sequence | None=None, inclusive: IntervalClosedType='both', props: str | None=None) -> Styler:
+        if props is None:
+            props = f'background-color: {color};'
+        return self.apply(_highlight_between, axis=axis, subset=subset, props=props, left=left, right=right, inclusive=inclusive)
+
+    @Substitution(subset=subset_args, color=coloring_args.format(default='yellow'), props=properties_args)
+    def highlight_quantile(self, subset: Subset | None=None, color: str='yellow', axis: Axis | None=0, q_left: float=0.0, q_right: float=1.0, interpolation: QuantileInterpolation='linear', inclusive: IntervalClosedType='both', props: str | None=None) -> Styler:
+        subset_ = slice(None) if subset is None else subset
+        subset_ = non_reducing_slice(subset_)
+        data = self.data.loc[subset_]
+        quantiles = [q_left, q_right]
+        if axis is None:
+            q = Series(data.to_numpy().ravel()).quantile(q=quantiles, interpolation=interpolation)
+            axis_apply: int | None = None
+        else:
+            axis = self.data._get_axis_number(axis)
+            q = data.quantile(axis=axis, numeric_only=False, q=quantiles, interpolation=interpolation)
+            axis_apply = 1 - axis
+        if props is None:
+            props = f'background-color: {color};'
+        return self.apply(_highlight_between, axis=axis_apply, subset=subset, props=props, left=q.iloc[0], right=q.iloc[1], inclusive=inclusive)
+
+    @classmethod
+    def from_custom_template(cls, searchpath: Sequence[str], html_table: str | None=None, html_style: str | None=None) -> type[Styler]:
+        loader = jinja2.ChoiceLoader([jinja2.FileSystemLoader(searchpath), cls.loader])
+
+        class MyStyler(cls):
+            env = jinja2.Environment(loader=loader)
+            if html_table:
+                template_html_table = env.get_template(html_table)
+            if html_style:
+                template_html_style = env.get_template(html_style)
+        return MyStyler
+
+    @overload
+    def pipe(self, func: Callable[Concatenate[Self, P], T], *args: P.args, **kwargs: P.kwargs) -> T:
+        ...
+
+    @overload
+    def pipe(self, func: tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T:
+        ...
+
+    def pipe(self, func: Callable[Concatenate[Self, P], T] | tuple[Callable[..., T], str], *args: Any, **kwargs: Any) -> T:
+        return com.pipe(self, func, *args, **kwargs)
+
+def _validate_apply_axis_arg(arg: NDFrame | Sequence | np.ndarray, arg_name: str, dtype: Any | None, data: NDFrame) -> np.ndarray:
+    dtype = {'dtype': dtype} if dtype else {}
+    if isinstance(arg, Series) and isinstance(data, DataFrame):
+        raise ValueError(f"'{arg_name}' is a Series but underlying data for operations is a DataFrame since 'axis=None'")
+    if isinstance(arg, DataFrame) and isinstance(data, Series):
+        raise ValueError(f"'{arg_name}' is a DataFrame but underlying data for operations is a Series with 'axis in [0,1]'")
+    if isinstance(arg, (Series, DataFrame)):
+        arg = arg.reindex_like(data).to_numpy(**dtype)
+    else:
+        arg = np.asarray(arg, **dtype)
+        assert isinstance(arg, np.ndarray)
+        if arg.shape != data.shape:
+            raise ValueError(f"supplied '{arg_name}' is not correct shape for data over selected 'axis': got {arg.shape}, expected {data.shape}")
+    return arg
+
+def _background_gradient(data, cmap: str | Colormap='PuBu', low: float=0, high: float=0, text_color_threshold: float=0.408, vmin: float | None=None, vmax: float | None=None, gmap: Sequence | np.ndarray | DataFrame | Series | None=None, text_only: bool=False) -> list[str] | DataFrame:
+    if gmap is None:
+        gmap = data.to_numpy(dtype=float, na_value=np.nan)
+    else:
+        gmap = _validate_apply_axis_arg(gmap, 'gmap', float, data)
+    smin = np.nanmin(gmap) if vmin is None else vmin
+    smax = np.nanmax(gmap) if vmax is None else vmax
+    rng = smax - smin
+    _matplotlib = import_optional_dependency('matplotlib', extra='Styler.background_gradient requires matplotlib.')
+    norm = _matplotlib.colors.Normalize(smin - rng * low, smax + rng * high)
+    if cmap is None:
+        rgbas = _matplotlib.colormaps[_matplotlib.rcParams['image.cmap']](norm(gmap))
+    else:
+        rgbas = _matplotlib.colormaps.get_cmap(cmap)(norm(gmap))
+
+    def relative_luminance(rgba) -> float:
+        (r, g, b) = (x / 12.92 if x <= 0.04045 else ((x + 0.055) / 1.055) ** 2.4 for x in rgba[:3])
+        return 0.2126 * r + 0.7152 * g + 0.0722 * b
+
+    def css(rgba, text_only) -> str:
+        if not text_only:
+            dark = relative_luminance(rgba) < text_color_threshold
+            text_color = '#f1f1f1' if dark else '#000000'
+            return f'background-color: {_matplotlib.colors.rgb2hex(rgba)};color: {text_color};'
+        else:
+            return f'color: {_matplotlib.colors.rgb2hex(rgba)};'
+    if data.ndim == 1:
+        return [css(rgba, text_only) for rgba in rgbas]
+    else:
+        return DataFrame([[css(rgba, text_only) for rgba in row] for row in rgbas], index=data.index, columns=data.columns)
+
+def _highlight_between(data: NDFrame, props: str, left: Scalar | Sequence | np.ndarray | NDFrame | None=None, right: Scalar | Sequence | np.ndarray | NDFrame | None=None, inclusive: bool | str=True) -> np.ndarray:
+    if np.iterable(left) and (not isinstance(left, str)):
+        left = _validate_apply_axis_arg(left, 'left', None, data)
+    if np.iterable(right) and (not isinstance(right, str)):
+        right = _validate_apply_axis_arg(right, 'right', None, data)
+    if inclusive == 'both':
+        ops = (operator.ge, operator.le)
+    elif inclusive == 'neither':
+        ops = (operator.gt, operator.lt)
+    elif inclusive == 'left':
+        ops = (operator.ge, operator.lt)
+    elif inclusive == 'right':
+        ops = (operator.gt, operator.le)
+    else:
+        raise ValueError(f"'inclusive' values can be 'both', 'left', 'right', or 'neither' got {inclusive}")
+    g_left = ops[0](data, left) if left is not None else np.full(data.shape, True, dtype=bool)
+    if isinstance(g_left, (DataFrame, Series)):
+        g_left = g_left.where(pd.notna(g_left), False)
+    l_right = ops[1](data, right) if right is not None else np.full(data.shape, True, dtype=bool)
+    if isinstance(l_right, (DataFrame, Series)):
+        l_right = l_right.where(pd.notna(l_right), False)
+    return np.where(g_left & l_right, props, '')
+
+def _highlight_value(data: DataFrame | Series, op: str, props: str) -> np.ndarray:
+    value = getattr(data, op)(skipna=True)
+    if isinstance(data, DataFrame):
+        value = getattr(value, op)(skipna=True)
+    cond = data == value
+    cond = cond.where(pd.notna(cond), False)
+    return np.where(cond, props, '')
+
+def _bar(data: NDFrame, align: str | float | Callable, colors: str | list | tuple, cmap: Any, width: float, height: float, vmin: float | None, vmax: float | None, base_css: str):
+
+    def css_bar(start: float, end: float, color: str) -> str:
+        cell_css = base_css
+        if end > start:
+            cell_css += 'background: linear-gradient(90deg,'
+            if start > 0:
+                cell_css += f' transparent {start * 100:.1f}%, {color} {start * 100:.1f}%,'
+            cell_css += f' {color} {end * 100:.1f}%, transparent {end * 100:.1f}%)'
+        return cell_css
+
+    def css_calc(x, left: float, right: float, align: str, color: str | list | tuple):
+        if pd.isna(x):
+            return base_css
+        if isinstance(color, (list, tuple)):
+            color = color[0] if x < 0 else color[1]
+        assert isinstance(color, str)
+        x = left if x < left else x
+        x = right if x > right else x
+        start: float = 0
+        end: float = 1
+        if align == 'left':
+            end = (x - left) / (right - left)
+        elif align == 'right':
+            start = (x - left) / (right - left)
+        else:
+            z_frac: float = 0.5
+            if align == 'zero':
+                limit: float = max(abs(left), abs(right))
+                (left, right) = (-limit, limit)
+            elif align == 'mid':
+                mid: float = (left + right) / 2
+                z_frac = -mid / (right - left) + 0.5 if mid < 0 else -left / (right - left)
+            if x < 0:
+                (start, end) = ((x - left) / (right - left), z_frac)
+            else:
+                (start, end) = (z_frac, (x - left) / (right - left))
+        ret = css_bar(start * width, end * width, color)
+        if height < 1 and 'background: linear-gradient(' in ret:
+            return ret + f' no-repeat center; background-size: 100% {height * 100:.1f}%;'
+        else:
+            return ret
+    values = data.to_numpy()
+    left = np.nanmin(data.min(skipna=True)) if vmin is None else vmin
+    right = np.nanmax(data.max(skipna=True)) if vmax is None else vmax
+    z: float = 0
+    if align == 'mid':
+        if left >= 0:
+            (align, left) = ('left', 0 if vmin is None else vmin)
+        elif right <= 0:
+            (align, right) = ('right', 0 if vmax is None else vmax)
+    elif align == 'mean':
+        (z, align) = (np.nanmean(values), 'zero')
+    elif callable(align):
+        (z, align) = (align(values), 'zero')
+    elif isinstance(align, (float, int)):
+        (z, align) = (float(align), 'zero')
+    elif align not in ('left', 'right', 'zero'):
+        raise ValueError("`align` should be in {'left', 'right', 'mid', 'mean', 'zero'} or be a value defining the center line or a callable that returns a float")
+    rgbas = None
+    if cmap is not None:
+        _matplotlib = import_optional_dependency('matplotlib', extra='Styler.bar requires matplotlib.')
+        cmap = _matplotlib.colormaps[cmap] if isinstance(cmap, str) else cmap
+        norm = _matplotlib.colors.Normalize(left, right)
+        rgbas = cmap(norm(values))
+        if data.ndim == 1:
+            rgbas = [_matplotlib.colors.rgb2hex(rgba) for rgba in rgbas]
+        else:
+            rgbas = [[_matplotlib.colors.rgb2hex(rgba) for rgba in row] for row in rgbas]
+    assert isinstance(align, str)
+    if data.ndim == 1:
+        return [css_calc(x - z, left - z, right - z, align, colors if rgbas is None else rgbas[i]) for (i, x) in enumerate(values)]
+    else:
+        return np.array([[css_calc(x - z, left - z, right - z, align, colors if rgbas is None else rgbas[i][j]) for (j, x) in enumerate(row)] for (i, row) in enumerate(values)])
+
+# File: pandas-main/pandas/io/formats/style_render.py
+from __future__ import annotations
+from collections import defaultdict
+from collections.abc import Callable, Sequence
+from functools import partial
+import re
+from typing import TYPE_CHECKING, Any, DefaultDict, Optional, TypedDict, Union
+from uuid import uuid4
+import numpy as np
+from pandas._config import get_option
+from pandas._libs import lib
+from pandas.compat._optional import import_optional_dependency
+from pandas.core.dtypes.common import is_complex, is_float, is_integer
+from pandas.core.dtypes.generic import ABCSeries
+from pandas import DataFrame, Index, IndexSlice, MultiIndex, Series, isna
+from pandas.api.types import is_list_like
+import pandas.core.common as com
+if TYPE_CHECKING:
+    from pandas._typing import Axis, Level
+jinja2 = import_optional_dependency('jinja2', extra='DataFrame.style requires jinja2.')
+from markupsafe import escape as escape_html
+BaseFormatter = Union[str, Callable]
+ExtFormatter = Union[BaseFormatter, dict[Any, Optional[BaseFormatter]]]
+CSSPair = tuple[str, Union[str, float]]
+CSSList = list[CSSPair]
+CSSProperties = Union[str, CSSList]
+
+class CSSDict(TypedDict):
+    selector: str
+    props: CSSProperties
+CSSStyles = list[CSSDict]
+Subset = Union[slice, Sequence, Index]
+
+class StylerRenderer:
+    loader = jinja2.PackageLoader('pandas', 'io/formats/templates')
+    env = jinja2.Environment(loader=loader, trim_blocks=True)
+    template_html = env.get_template('html.tpl')
+    template_html_table = env.get_template('html_table.tpl')
+    template_html_style = env.get_template('html_style.tpl')
+    template_latex = env.get_template('latex.tpl')
+    template_string = env.get_template('string.tpl')
+
+    def __init__(self, data: DataFrame | Series, uuid: str | None=None, uuid_len: int=5, table_styles: CSSStyles | None=None, table_attributes: str | None=None, caption: str | tuple | list | None=None, cell_ids: bool=True, precision: int | None=None) -> None:
+        if isinstance(data, Series):
+            data = data.to_frame()
+        if not isinstance(data, DataFrame):
+            raise TypeError('``data`` must be a Series or DataFrame')
+        self.data: DataFrame = data
+        self.index: Index = data.index
+        self.columns: Index = data.columns
+        if not isinstance(uuid_len, int) or uuid_len < 0:
+            raise TypeError('``uuid_len`` must be an integer in range [0, 32].')
+        self.uuid = uuid or uuid4().hex[:min(32, uuid_len)]
+        self.uuid_len = len(self.uuid)
+        self.table_styles = table_styles
+        self.table_attributes = table_attributes
+        self.caption = caption
+        self.cell_ids = cell_ids
+        self.css = {'row_heading': 'row_heading', 'col_heading': 'col_heading', 'index_name': 'index_name', 'col': 'col', 'row': 'row', 'col_trim': 'col_trim', 'row_trim': 'row_trim', 'level': 'level', 'data': 'data', 'blank': 'blank', 'foot': 'foot'}
+        self.concatenated: list[StylerRenderer] = []
+        self.hide_index_names: bool = False
+        self.hide_column_names: bool = False
+        self.hide_index_: list = [False] * self.index.nlevels
+        self.hide_columns_: list = [False] * self.columns.nlevels
+        self.hidden_rows: Sequence[int] = []
+        self.hidden_columns: Sequence[int] = []
+        self.ctx: DefaultDict[tuple[int, int], CSSList] = defaultdict(list)
+        self.ctx_index: DefaultDict[tuple[int, int], CSSList] = defaultdict(list)
+        self.ctx_columns: DefaultDict[tuple[int, int], CSSList] = defaultdict(list)
+        self.cell_context: DefaultDict[tuple[int, int], str] = defaultdict(str)
+        self._todo: list[tuple[Callable, tuple, dict]] = []
+        self.tooltips: Tooltips | None = None
+        precision = get_option('styler.format.precision') if precision is None else precision
+        self._display_funcs: DefaultDict[tuple[int, int], Callable[[Any], str]] = defaultdict(lambda : partial(_default_formatter, precision=precision))
+        self._display_funcs_index: DefaultDict[tuple[int, int], Callable[[Any], str]] = defaultdict(lambda : partial(_default_formatter, precision=precision))
+        self._display_funcs_index_names: DefaultDict[int, Callable[[Any], str]] = defaultdict(lambda : partial(_default_formatter, precision=precision))
+        self._display_funcs_columns: DefaultDict[tuple[int, int], Callable[[Any], str]] = defaultdict(lambda : partial(_default_formatter, precision=precision))
+        self._display_funcs_column_names: DefaultDict[int, Callable[[Any], str]] = defaultdict(lambda : partial(_default_formatter, precision=precision))
+
+    def _render(self, sparse_index: bool, sparse_columns: bool, max_rows: int | None=None, max_cols: int | None=None, blank: str=''):
+        self._compute()
+        dxs = []
+        ctx_len = len(self.index)
+        for (i, concatenated) in enumerate(self.concatenated):
+            concatenated.hide_index_ = self.hide_index_
+            concatenated.hidden_columns = self.hidden_columns
+            foot = f"{self.css['foot']}{i}"
+            concatenated.css = {**self.css, 'data': f'{foot}_data', 'row_heading': f'{foot}_row_heading', 'row': f'{foot}_row', 'foot': f'{foot}_foot'}
+            dx = concatenated._render(sparse_index, sparse_columns, max_rows, max_cols, blank)
+            dxs.append(dx)
+            for ((r, c), v) in concatenated.ctx.items():
+                self.ctx[r + ctx_len, c] = v
+            for ((r, c), v) in concatenated.ctx_index.items():
+                self.ctx_index[r + ctx_len, c] = v
+            ctx_len += len(concatenated.index)
+        d = self._translate(sparse_index, sparse_columns, max_rows, max_cols, blank, dxs)
+        return d
+
+    def _render_html(self, sparse_index: bool, sparse_columns: bool, max_rows: int | None=None, max_cols: int | None=None, **kwargs) -> str:
+        d = self._render(sparse_index, sparse_columns, max_rows, max_cols, '&nbsp;')
+        d.update(kwargs)
+        return self.template_html.render(**d, html_table_tpl=self.template_html_table, html_style_tpl=self.template_html_style)
+
+    def _render_latex(self, sparse_index: bool, sparse_columns: bool, clines: str | None, **kwargs) -> str:
+        d = self._render(sparse_index, sparse_columns, None, None)
+        self._translate_latex(d, clines=clines)
+        self.template_latex.globals['parse_wrap'] = _parse_latex_table_wrapping
+        self.template_latex.globals['parse_table'] = _parse_latex_table_styles
+        self.template_latex.globals['parse_cell'] = _parse_latex_cell_styles
+        self.template_latex.globals['parse_header'] = _parse_latex_header_span
+        d.update(kwargs)
+        return self.template_latex.render(**d)
+
+    def _render_string(self, sparse_index: bool, sparse_columns: bool, max_rows: int | None=None, max_cols: int | None=None, **kwargs) -> str:
+        d = self._render(sparse_index, sparse_columns, max_rows, max_cols)
+        d.update(kwargs)
+        return self.template_string.render(**d)
+
+    def _compute(self):
+        self.ctx.clear()
+        self.ctx_index.clear()
+        self.ctx_columns.clear()
+        r = self
+        for (func, args, kwargs) in self._todo:
+            r = func(self)(*args, **kwargs)
+        return r
+
+    def _translate(self, sparse_index: bool, sparse_cols: bool, max_rows: int | None=None, max_cols: int | None=None, blank: str='&nbsp;', dxs: list[dict] | None=None):
+        if dxs is None:
+            dxs = []
+        self.css['blank_value'] = blank
+        d = {'uuid': self.uuid, 'table_styles': format_table_styles(self.table_styles or []), 'caption': self.caption}
+        max_elements = get_option('styler.render.max_elements')
+        max_rows = max_rows if max_rows else get_option('styler.render.max_rows')
+        max_cols = max_cols if max_cols else get_option('styler.render.max_columns')
+        (max_rows, max_cols) = _get_trimming_maximums(len(self.data.index), len(self.data.columns), max_elements, max_rows, max_cols)
+        self.cellstyle_map_columns: DefaultDict[tuple[CSSPair, ...], list[str]] = defaultdict(list)
+        head = self._translate_header(sparse_cols, max_cols)
+        d.update({'head': head})
+        idx_lengths = _get_level_lengths(self.index, sparse_index, max_rows, self.hidden_rows)
+        d.update({'index_lengths': idx_lengths})
+        self.cellstyle_map: DefaultDict[tuple[CSSPair, ...], list[str]] = defaultdict(list)
+        self.cellstyle_map_index: DefaultDict[tuple[CSSPair, ...], list[str]] = defaultdict(list)
+        body: list = self._translate_body(idx_lengths, max_rows, max_cols)
+        d.update({'body': body})
+        ctx_maps = {'cellstyle': 'cellstyle_map', 'cellstyle_index': 'cellstyle_map_index', 'cellstyle_columns': 'cellstyle_map_columns'}
+        for (k, attr) in ctx_maps.items():
+            map = [{'props': list(props), 'selectors': selectors} for (props, selectors) in getattr(self, attr).items()]
+            d.update({k: map})
+        for dx in dxs:
+            d['body'].extend(dx['body'])
+            d['cellstyle'].extend(dx['cellstyle'])
+            d['cellstyle_index'].extend(dx['cellstyle_index'])
+        table_attr = self.table_attributes
+        if not get_option('styler.html.mathjax'):
+            table_attr = table_attr or ''
+            if 'class="' in table_attr:
+                table_attr = table_attr.replace('class="', 'class="tex2jax_ignore ')
+            else:
+                table_attr += ' class="tex2jax_ignore"'
+        d.update({'table_attributes': table_attr})
+        if self.tooltips:
+            d = self.tooltips._translate(self, d)
+        return d
+
+    def _translate_header(self, sparsify_cols: bool, max_cols: int):
+        col_lengths = _get_level_lengths(self.columns, sparsify_cols, max_cols, self.hidden_columns)
+        clabels = self.data.columns.tolist()
+        if self.data.columns.nlevels == 1:
+            clabels = [[x] for x in clabels]
+        clabels = list(zip(*clabels))
+        head = []
+        for (r, hide) in enumerate(self.hide_columns_):
+            if hide or not clabels:
+                continue
+            header_row = self._generate_col_header_row((r, clabels), max_cols, col_lengths)
+            head.append(header_row)
+        if self.data.index.names and com.any_not_none(*self.data.index.names) and (not all(self.hide_index_)) and (not self.hide_index_names):
+            index_names_row = self._generate_index_names_row(clabels, max_cols, col_lengths)
+            head.append(index_names_row)
+        return head
+
+    def _generate_col_header_row(self, iter: Sequence, max_cols: int, col_lengths: dict):
+        (r, clabels) = iter
+        index_blanks = [_element('th', self.css['blank'], self.css['blank_value'], True)] * (self.index.nlevels - sum(self.hide_index_) - 1)
+        name = self.data.columns.names[r]
+        is_display = name is not None and (not self.hide_column_names)
+        value = name if is_display else self.css['blank_value']
+        display_value = self._display_funcs_column_names[r](value) if is_display else None
+        column_name = [_element('th', f"{self.css['blank']} {self.css['level']}{r}" if name is None else f"{self.css['index_name']} {self.css['level']}{r}", value, not all(self.hide_index_), display_value=display_value)]
+        column_headers: list = []
+        visible_col_count: int = 0
+        for (c, value) in enumerate(clabels[r]):
+            header_element_visible = _is_visible(c, r, col_lengths)
+            if header_element_visible:
+                visible_col_count += col_lengths.get((r, c), 0)
+            if self._check_trim(visible_col_count, max_cols, column_headers, 'th', f"{self.css['col_heading']} {self.css['level']}{r} {self.css['col_trim']}"):
+                break
+            header_element = _element('th', f"{self.css['col_heading']} {self.css['level']}{r} {self.css['col']}{c}", value, header_element_visible, display_value=self._display_funcs_columns[r, c](value), attributes=f'colspan="{col_lengths.get((r, c), 0)}"' if col_lengths.get((r, c), 0) > 1 else '')
+            if self.cell_ids:
+                header_element['id'] = f"{self.css['level']}{r}_{self.css['col']}{c}"
+            if header_element_visible and (r, c) in self.ctx_columns and self.ctx_columns[r, c]:
+                header_element['id'] = f"{self.css['level']}{r}_{self.css['col']}{c}"
+                self.cellstyle_map_columns[tuple(self.ctx_columns[r, c])].append(f"{self.css['level']}{r}_{self.css['col']}{c}")
+            column_headers.append(header_element)
+        return index_blanks + column_name + column_headers
+
+    def _generate_index_names_row(self, iter: Sequence, max_cols: int, col_lengths: dict):
+        clabels = iter
+        index_names = [_element('th', f"{self.css['index_name']} {self.css['level']}{c}", self.css['blank_value'] if name is None else name, not self.hide_index_[c], display_value=None if name is None else self._display_funcs_index_names[c](name)) for (c, name) in enumerate(self.data.index.names)]
+        column_blanks: list = []
+        visible_col_count: int = 0
+        if clabels:
+            last_level = self.columns.nlevels - 1
+            for (c, value) in enumerate(clabels[last_level]):
+                header_element_visible = _is_visible(c, last_level, col_lengths)
+                if header_element_visible:
+                    visible_col_count += 1
+                if self._check_trim(visible_col_count, max_cols, column_blanks, 'th', f"{self.css['blank']} {self.css['col']}{c} {self.css['col_trim']}", self.css['blank_value']):
+                    break
+                column_blanks.append(_element('th', f"{self.css['blank']} {self.css['col']}{c}", self.css['blank_value'], c not in self.hidden_columns))
+        return index_names + column_blanks
+
+    def _translate_body(self, idx_lengths: dict, max_rows: int, max_cols: int):
+        rlabels = self.data.index.tolist()
+        if not isinstance(self.data.index, MultiIndex):
+            rlabels = [[x] for x in rlabels]
+        body: list = []
+        visible_row_count: int = 0
+        for (r, row_tup) in [z for z in enumerate(self.data.itertuples()) if z[0] not in self.hidden_rows]:
+            visible_row_count += 1
+            if self._check_trim(visible_row_count, max_rows, body, 'row'):
+                break
+            body_row = self._generate_body_row((r, row_tup, rlabels), max_cols, idx_lengths)
+            body.append(body_row)
+        return body
+
+    def _check_trim(self, count: int, max: int, obj: list, element: str, css: str | None=None, value: str='...') -> bool:
+        if count > max:
+            if element == 'row':
+                obj.append(self._generate_trimmed_row(max))
+            else:
+                obj.append(_element(element, css, value, True, attributes=''))
+            return True
+        return False
+
+    def _generate_trimmed_row(self, max_cols: int) -> list:
+        index_headers = [_element('th', f"{self.css['row_heading']} {self.css['level']}{c} {self.css['row_trim']}", '...', not self.hide_index_[c], attributes='') for c in range(self.data.index.nlevels)]
+        data: list = []
+        visible_col_count: int = 0
+        for (c, _) in enumerate(self.columns):
+            data_element_visible = c not in self.hidden_columns
+            if data_element_visible:
+                visible_col_count += 1
+            if self._check_trim(visible_col_count, max_cols, data, 'td', f"{self.css['data']} {self.css['row_trim']} {self.css['col_trim']}"):
+                break
+            data.append(_element('td', f"{self.css['data']} {self.css['col']}{c} {self.css['row_trim']}", '...', data_element_visible, attributes=''))
+        return index_headers + data
+
+    def _generate_body_row(self, iter: tuple, max_cols: int, idx_lengths: dict):
+        (r, row_tup, rlabels) = iter
+        index_headers = []
+        for (c, value) in enumerate(rlabels[r]):
+            header_element_visible = _is_visible(r, c, idx_lengths) and (not self.hide_index_[c])
+            header_element = _element('th', f"{self.css['row_heading']} {self.css['level']}{c} {self.css['row']}{r}", value, header_element_visible, display_value=self._display_funcs_index[r, c](value), attributes=f'rowspan="{idx_lengths.get((c, r), 0)}"' if idx_lengths.get((c, r), 0) > 1 else '')
+            if self.cell_ids:
+                header_element['id'] = f"{self.css['level']}{c}_{self.css['row']}{r}"
+            if header_element_visible and (r, c) in self.ctx_index and self.ctx_index[r, c]:
+                header_element['id'] = f"{self.css['level']}{c}_{self.css['row']}{r}"
+                self.cellstyle_map_index[tuple(self.ctx_index[r, c])].append(f"{self.css['level']}{c}_{self.css['row']}{r}")
+            index_headers.append(header_element)
+        data: list = []
+        visible_col_count: int = 0
+        for (c, value) in enumerate(row_tup[1:]):
+            data_element_visible = c not in self.hidden_columns and r not in self.hidden_rows
+            if data_element_visible:
+                visible_col_count += 1
+            if self._check_trim(visible_col_count, max_cols, data, 'td', f"{self.css['data']} {self.css['row']}{r} {self.css['col_trim']}"):
+                break
+            cls = ''
+            if (r, c) in self.cell_context:
+                cls = ' ' + self.cell_context[r, c]
+            data_element = _element('td', f"{self.css['data']} {self.css['row']}{r} {self.css['col']}{c}{cls}", value, data_element_visible, attributes='', display_value=self._display_funcs[r, c](value))
+            if self.cell_ids:
+                data_element['id'] = f"{self.css['row']}{r}_{self.css['col']}{c}"
+            if data_element_visible and (r, c) in self.ctx and self.ctx[r, c]:
+                data_element['id'] = f"{self.css['row']}{r}_{self.css['col']}{c}"
+                self.cellstyle_map[tuple(self.ctx[r, c])].append(f"{self.css['row']}{r}_{self.css['col']}{c}")
+            data.append(data_element)
+        return index_headers + data
+
+    def _translate_latex(self, d: dict, clines: str | None) -> None:
+        index_levels = self.index.nlevels
+        visible_index_level_n = index_levels - sum(self.hide_index_)
+        d['head'] = [[{**col, 'cellstyle': self.ctx_columns[r, c - visible_index_level_n]} for (c, col) in enumerate(row) if col['is_visible']] for (r, row) in enumerate(d['head'])]
+
+        def _concatenated_visible_rows(obj, n, row_indices):
+            row_indices.extend([r + n for r in range(len(obj.index)) if r not in obj.hidden_rows])
+            n += len(obj.index)
+            for concatenated in obj.concatenated:
+                n = _concatenated_visible_rows(concatenated, n, row_indices)
+            return n
+
+        def concatenated_visible_rows(obj):
+            row_indices: list[int] = []
+            _concatenated_visible_rows(obj, 0, row_indices)
+            return row_indices
+        body = []
+        for (r, row) in zip(concatenated_visible_rows(self), d['body']):
+            if all(self.hide_index_):
+                row_body_headers = []
+            else:
+                row_body_headers = [{**col, 'display_value': col['display_value'] if col['is_visible'] else '', 'cellstyle': self.ctx_index[r, c]} for (c, col) in enumerate(row[:index_levels]) if col['type'] == 'th' and (not self.hide_index_[c])]
+            row_body_cells = [{**col, 'cellstyle': self.ctx[r, c]} for (c, col) in enumerate(row[index_levels:]) if col['is_visible'] and col['type'] == 'td']
+            body.append(row_body_headers + row_body_cells)
+        d['body'] = body
+        if clines not in [None, 'all;data', 'all;index', 'skip-last;data', 'skip-last;index']:
+            raise ValueError(f"`clines` value of {clines} is invalid. Should either be None or one of 'all;data', 'all;index', 'skip-last;data', 'skip-last;index'.")
+        if clines is not None:
+            data_len = len(row_body_cells) if 'data' in clines and d['body'] else 0
+            d['clines'] = defaultdict(list)
+            visible_row_indexes: list[int] = [r for r in range(len(self.data.index)) if r not in self.hidden_rows]
+            visible_index_levels: list[int] = [i for i in range(index_levels) if not self.hide_index_[i]]
+            for (rn, r) in enumerate(visible_row_indexes):
+                for (lvln, lvl) in enumerate(visible_index_levels):
+                    if lvl == index_levels - 1 and 'skip-last' in clines:
+                        continue
+                    idx_len = d['index_lengths'].get((lvl, r), None)
+                    if idx_len is not None:
+                        d['clines'][rn + idx_len].append(f'\\cline{{{lvln + 1}-{len(visible_index_levels) + data_len}}}')
+
+    def format(self, formatter: ExtFormatter | None=None, subset: Subset | None=None, na_rep: str | None=None, precision: int | None=None, decimal: str='.', thousands: str | None=None, escape: str | None=None, hyperlinks: str | None=None) -> StylerRenderer:
+        if all((formatter is None, subset is None, precision is None, decimal == '.', thousands is None, na_rep is None, escape is None, hyperlinks is None)):
+            self._display_funcs.clear()
+            return self
+        subset = slice(None) if subset is None else subset
+        subset = non_reducing_slice(subset)
+        data = self.data.loc[subset]
+        if not isinstance(formatter, dict):
+            formatter = {col: formatter for col in data.columns}
+        cis = self.columns.get_indexer_for(data.columns)
+        ris = self.index.get_indexer_for(data.index)
+        for ci in cis:
+            format_func = _maybe_wrap_formatter(formatter.get(self.columns[ci]), na_rep=na_rep, precision=precision, decimal=decimal, thousands=thousands, escape=escape, hyperlinks=hyperlinks)
+            for ri in ris:
+                self._display_funcs[ri, ci] = format_func
+        return self
+
+    def format_index(self, formatter: ExtFormatter | None=None, axis: Axis=0, level: Level | list[Level] | None=None, na_rep: str | None=None, precision: int | None=None, decimal: str='.', thousands: str | None=None, escape: str | None=None, hyperlinks: str | None=None) -> StylerRenderer:
+        axis = self.data._get_axis_number(axis)
+        if axis == 0:
+            (display_funcs_, obj) = (self._display_funcs_index, self.index)
+        else:
+            (display_funcs_, obj) = (self._display_funcs_columns, self.columns)
+        levels_ = refactor_levels(level, obj)
+        if all((formatter is None, level is None, precision is None, decimal == '.', thousands is None, na_rep is None, escape is None, hyperlinks is None)):
+            display_funcs_.clear()
+            return self
+        if not isinstance(formatter, dict):
+            formatter = {level: formatter for level in levels_}
+        else:
+            formatter = {obj._get_level_number(level): formatter_ for (level, formatter_) in formatter.items()}
+        for lvl in levels_:
+            format_func = _maybe_wrap_formatter(formatter.get(lvl), na_rep=na_rep, precision=precision, decimal=decimal, thousands=thousands, escape=escape, hyperlinks=hyperlinks)
+            for idx in [(i, lvl) if axis == 0 else (lvl, i) for i in range(len(obj))]:
+                display_funcs_[idx] = format_func
+        return self
+
+    def relabel_index(self, labels: Sequence | Index, axis: Axis=0, level: Level | list[Level] | None=None) -> StylerRenderer:
+        axis = self.data._get_axis_number(axis)
+        if axis == 0:
+            (display_funcs_, obj) = (self._display_funcs_index, self.index)
+            (hidden_labels, hidden_lvls) = (self.hidden_rows, self.hide_index_)
+        else:
+            (display_funcs_, obj) = (self._display_funcs_columns, self.columns)
+            (hidden_labels, hidden_lvls) = (self.hidden_columns, self.hide_columns_)
+        visible_len = len(obj) - len(set(hidden_labels))
+        if len(labels) != visible_len:
+            raise ValueError(f'``labels`` must be of length equal to the number of visible labels along ``axis`` ({visible_len}).')
+        if level is None:
+            level = [i for i in range(obj.nlevels) if not hidden_lvls[i]]
+        levels_ = refactor_levels(level, obj)
+
+        def alias_(x, value):
+            if isinstance(value, str):
+                return value.format(x)
+            return value
+        for (ai, i) in enumerate([i for i in range(len(obj)) if i not in hidden_labels]):
+            if len(levels_) == 1:
+                idx = (i, levels_[0]) if axis == 0 else (levels_[0], i)
+                display_funcs_[idx] = partial(alias_, value=labels[ai])
+            else:
+                for (aj, lvl) in enumerate(levels_):
+                    idx = (i, lvl) if axis == 0 else (lvl, i)
+                    display_funcs_[idx] = partial(alias_, value=labels[ai][aj])
+        return self
+
+    def format_index_names(self, formatter: ExtFormatter | None=None, axis: Axis=0, level: Level | list[Level] | None=None, na_rep: str | None=None, precision: int | None=None, decimal: str='.', thousands: str | None=None, escape: str | None=None, hyperlinks: str | None=None) -> StylerRenderer:
+        axis = self.data._get_axis_number(axis)
+        if axis == 0:
+            (display_funcs_, obj) = (self._display_funcs_index_names, self.index)
+        else:
+            (display_funcs_, obj) = (self._display_funcs_column_names, self.columns)
+        levels_ = refactor_levels(level, obj)
+        if all((formatter is None, level is None, precision is None, decimal == '.', thousands is None, na_rep is None, escape is None, hyperlinks is None)):
+            display_funcs_.clear()
+            return self
+        if not isinstance(formatter, dict):
+            formatter = {level: formatter for level in levels_}
+        else:
+            formatter = {obj._get_level_number(level): formatter_ for (level, formatter_) in formatter.items()}
+        for lvl in levels_:
+            format_func = _maybe_wrap_formatter(formatter.get(lvl), na_rep=na_rep, precision=precision, decimal=decimal, thousands=thousands, escape=escape, hyperlinks=hyperlinks)
+            display_funcs_[lvl] = format_func
+        return self
+
+def _element(html_element: str, html_class: str | None, value: Any, is_visible: bool, **kwargs) -> dict:
+    if 'display_value' not in kwargs or kwargs['display_value'] is None:
+        kwargs['display_value'] = value
+    return {'type': html_element, 'value': value, 'class': html_class, 'is_visible': is_visible, **kwargs}
+
+def _get_trimming_maximums(rn, cn, max_elements, max_rows=None, max_cols=None, scaling_factor: float=0.8) -> tuple[int, int]:
+
+    def scale_down(rn, cn):
+        if cn >= rn:
+            return (rn, int(cn * scaling_factor))
+        else:
+            return (int(rn * scaling_factor), cn)
+    if max_rows:
+        rn = max_rows if rn > max_rows else rn
+    if max_cols:
+        cn = max_cols if cn > max_cols else cn
+    while rn * cn > max_elements:
+        (rn, cn) = scale_down(rn, cn)
+    return (rn, cn)
+
+def _get_level_lengths(index: Index, sparsify: bool, max_index: int, hidden_elements: Sequence[int] | None=None):
+    if isinstance(index, MultiIndex):
+        levels = index._format_multi(sparsify=lib.no_default, include_names=False)
+    else:
+        levels = index._format_flat(include_name=False)
+    if hidden_elements is None:
+        hidden_elements = []
+    lengths = {}
+    if not isinstance(index, MultiIndex):
+        for (i, value) in enumerate(levels):
+            if i not in hidden_elements:
+                lengths[0, i] = 1
+        return lengths
+    for (i, lvl) in enumerate(levels):
+        visible_row_count = 0
+        for (j, row) in enumerate(lvl):
+            if visible_row_count > max_index:
+                break
+            if not sparsify:
+                if j not in hidden_elements:
+                    lengths[i, j] = 1
+                    visible_row_count += 1
+            elif row is not lib.no_default and j not in hidden_elements:
+                last_label = j
+                lengths[i, last_label] = 1
+                visible_row_count += 1
+            elif row is not lib.no_default:
+                last_label = j
+                lengths[i, last_label] = 0
+            elif j not in hidden_elements:
+                visible_row_count += 1
+                if visible_row_count > max_index:
+                    break
+                if lengths[i, last_label] == 0:
+                    last_label = j
+                    lengths[i, last_label] = 1
+                else:
+                    lengths[i, last_label] += 1
+    non_zero_lengths = {element: length for (element, length) in lengths.items() if length >= 1}
+    return non_zero_lengths
+
+def _is_visible(idx_row, idx_col, lengths) -> bool:
+    return (idx_col, idx_row) in lengths
+
+def format_table_styles(styles: CSSStyles) -> CSSStyles:
+    return [{'selector': selector, 'props': css_dict['props']} for css_dict in styles for selector in css_dict['selector'].split(',')]
+
+def _default_formatter(x: Any, precision: int, thousands: bool=False) -> Any:
+    if is_float(x) or is_complex(x):
+        return f'{x:,.{precision}f}' if thousands else f'{x:.{precision}f}'
+    elif is_integer(x):
+        return f'{x:,}' if thousands else str(x)
+    return x
+
+def _wrap_decimal_thousands(formatter: Callable, decimal: str, thousands: str | None) -> Callable:
+
+    def wrapper(x):
+        if is_float(x) or is_integer(x) or is_complex(x):
+            if decimal != '.' and thousands is not None and (thousands != ','):
+                return formatter(x).replace(',', '§_§-').replace('.', decimal).replace('§_§-', thousands)
+            elif decimal != '.' and (thousands is None or thousands == ','):
+                return formatter(x).replace('.', decimal)
+            elif decimal == '.' and thousands is not None and (thousands != ','):
+                return formatter(x).replace(',', thousands)
+        return formatter(x)
+    return wrapper
+
+def _str_escape(x, escape):
+    if isinstance(x, str):
+        if escape == 'html':
+            return escape_html(x)
+        elif escape == 'latex':
+            return _escape_latex(x)
+        elif escape == 'latex-math':
+            return _escape_latex_math(x)
+        else:
+            raise ValueError(f"`escape` only permitted in {{'html', 'latex', 'latex-math'}}, got {escape}")
+    return x
+
+def _render_href(x, format):
+    if isinstance(x, str):
+        if format == 'html':
+            href = '<a href="{0}" target="_blank">{0}</a>'
+        elif format == 'latex':
+            href = '\\href{{{0}}}{{{0}}}'
+        else:
+            raise ValueError("``hyperlinks`` format can only be 'html' or 'latex'")
+        pat = "((http|ftp)s?:\\/\\/|www.)[\\w/\\-?=%.:@]+\\.[\\w/\\-&?=%.,':;~!@#$*()\\[\\]]+"
+        return re.sub(pat, lambda m: href.format(m.group(0)), x)
+    return x
+
+def _maybe_wrap_formatter(formatter: BaseFormatter | None=None, na_rep: str | None=None, precision: int | None=None, decimal: str='.', thousands: str | None=None, escape: str | None=None, hyperlinks: str | None=None) -> Callable:
+    if isinstance(formatter, str):
+        func_0 = lambda x: formatter.format(x)
+    elif callable(formatter):
+        func_0 = formatter
+    elif formatter is None:
+        precision = get_option('styler.format.precision') if precision is None else precision
+        func_0 = partial(_default_formatter, precision=precision, thousands=thousands is not None)
+    else:
+        raise TypeError(f"'formatter' expected str or callable, got {type(formatter)}")
+    if escape is not None:
+        func_1 = lambda x: func_0(_str_escape(x, escape=escape))
+    else:
+        func_1 = func_0
+    if decimal != '.' or (thousands is not None and thousands != ','):
+        func_2 = _wrap_decimal_thousands(func_1, decimal=decimal, thousands=thousands)
+    else:
+        func_2 = func_1
+    if hyperlinks is not None:
+        func_3 = lambda x: func_2(_render_href(x, format=hyperlinks))
+    else:
+        func_3 = func_2
+    if na_rep is None:
+        return func_3
+    else:
+        return lambda x: na_rep if isna(x) is True else func_3(x)
+
+def non_reducing_slice(slice_: Subset):
+    kinds = (ABCSeries, np.ndarray, Index, list, str)
+    if isinstance(slice_, kinds):
+        slice_ = IndexSlice[:, slice_]
+
+    def pred(part) -> bool:
+        if isinstance(part, tuple):
+            return any((isinstance(s, slice) or is_list_like(s) for s in part))
+        else:
+            return isinstance(part, slice) or is_list_like(part)
+    if not is_list_like(slice_):
+        if not isinstance(slice_, slice):
+            slice_ = [[slice_]]
+        else:
+            slice_ = [slice_]
+    else:
+        slice_ = [p if pred(p) else [p] for p in slice_]
+    return tuple(slice_)
+
+def maybe_convert_css_to_tuples(style: CSSProperties) -> CSSList:
+    if isinstance(style, str):
+        s = style.split(';')
+        try:
+            return [(x.split(':')[0].strip(), x.split(':')[1].strip()) for x in s if x.strip() != '']
+        except IndexError as err:
+            raise ValueError(f"Styles supplied as string must follow CSS rule formats, for example 'attr: val;'. '{style}' was given.") from err
+    return style
+
+def refactor_levels(level: Level | list[Level] | None, obj: Index) -> list[int]:
+    if level is None:
+        levels_: list[int] = list(range(obj.nlevels))
+    elif isinstance(level, int):
+        levels_ = [level]
+    elif isinstance(level, str):
+        levels_ = [obj._get_level_number(level)]
+    elif isinstance(level, list):
+        levels_ = [obj._get_level_number(lev) if not isinstance(lev, int) else lev for lev in level]
+    else:
+        raise ValueError('`level` must be of type `int`, `str` or list of such')
+    return levels_
+
+class Tooltips:
+
+    def __init__(self, css_props: CSSProperties=[('visibility', 'hidden'), ('position', 'absolute'), ('z-index', 1), ('background-color', 'black'), ('color', 'white'), ('transform', 'translate(-20px, -20px)')], css_name: str='pd-t', tooltips: DataFrame=DataFrame(), as_title_attribute: bool=False) -> None:
+        self.class_name = css_name
+        self.class_properties = css_props
+        self.tt_data = tooltips
+        self.table_styles: CSSStyles = []
+        self.as_title_attribute = as_title_attribute
+
+    @property
+    def _class_styles(self):
+        return [{'selector': f'.{self.class_name}', 'props': maybe_convert_css_to_tuples(self.class_properties)}]
+
+    def _pseudo_css(self, uuid: str, name: str, row: int, col: int, text: str) -> list[CSSDict]:
+        selector_id = '#T_' + uuid + '_row' + str(row) + '_col' + str(col)
+        return [{'selector': selector_id + f':hover .{name}', 'props': [('visibility', 'visible')]}, {'selector': selector_id + f' .{name}::after', 'props': [('content', f'"{text}"')]}]
+
+    def _translate(self, styler: StylerRenderer, d: dict):
+        self.tt_data = self.tt_data.reindex_like(styler.data)
+        if self.tt_data.empty:
+            return d
+        mask = self.tt_data.isna() | self.tt_data.eq('')
+        if not self.as_title_attribute:
+            name = self.class_name
+            self.table_styles = [style for sublist in [self._pseudo_css(styler.uuid, name, i, j, str(self.tt_data.iloc[i, j])) for i in range(len(self.tt_data.index)) for j in range(len(self.tt_data.columns)) if not (mask.iloc[i, j] or i in styler.hidden_rows or j in styler.hidden_columns)] for style in sublist]
+            if self.table_styles:
+                for row in d['body']:
+                    for item in row:
+                        if item['type'] == 'td':
+                            item['display_value'] = str(item['display_value']) + f'<span class="{self.class_name}"></span>'
+                d['table_styles'].extend(self._class_styles)
+                d['table_styles'].extend(self.table_styles)
+        else:
+            index_offset = self.tt_data.index.nlevels
+            body = d['body']
+            for i in range(len(self.tt_data.index)):
+                for j in range(len(self.tt_data.columns)):
+                    if not mask.iloc[i, j] or i in styler.hidden_rows or j in styler.hidden_columns:
+                        row = body[i]
+                        item = row[j + index_offset]
+                        value = self.tt_data.iloc[i, j]
+                        item['attributes'] += f' title="{value}"'
+        return d
+
+def _parse_latex_table_wrapping(table_styles: CSSStyles, caption: str | None) -> bool:
+    IGNORED_WRAPPERS = ['toprule', 'midrule', 'bottomrule', 'column_format']
+    return table_styles is not None and any((d['selector'] not in IGNORED_WRAPPERS for d in table_styles)) or caption is not None
+
+def _parse_latex_table_styles(table_styles: CSSStyles, selector: str) -> str | None:
+    for style in table_styles[::-1]:
+        if style['selector'] == selector:
+            return str(style['props'][0][1]).replace('§', ':')
+    return None
+
+def _parse_latex_cell_styles(latex_styles: CSSList, display_value: str, convert_css: bool=False) -> str:
+    if convert_css:
+        latex_styles = _parse_latex_css_conversion(latex_styles)
+    for (command, options) in latex_styles[::-1]:
+        formatter = {'--wrap': f'{{\\{command}--to_parse {display_value}}}', '--nowrap': f'\\{command}--to_parse {display_value}', '--lwrap': f'{{\\{command}--to_parse}} {display_value}', '--rwrap': f'\\{command}--to_parse{{{display_value}}}', '--dwrap': f'{{\\{command}--to_parse}}{{{display_value}}}'}
+        display_value = f'\\{command}{options} {display_value}'
+        for arg in ['--nowrap', '--wrap', '--lwrap', '--rwrap', '--dwrap']:
+            if arg in str(options):
+                display_value = formatter[arg].replace('--to_parse', _parse_latex_options_strip(value=options, arg=arg))
+                break
+    return display_value
+
+def _parse_latex_header_span(cell: dict[str, Any], multirow_align: str, multicol_align: str, wrap: bool=False, convert_css: bool=False) -> str:
+    display_val = _parse_latex_cell_styles(cell['cellstyle'], cell['display_value'], convert_css)
+    if 'attributes' in cell:
+        attrs = cell['attributes']
+        if 'colspan="' in attrs:
+            colspan = attrs[attrs.find('colspan="') + 9:]
+            colspan = int(colspan[:colspan.find('"')])
+            if 'naive-l' == multicol_align:
+                out = f'{{{display_val}}}' if wrap else f'{display_val}'
+                blanks = ' & {}' if wrap else ' &'
+                return out + blanks * (colspan - 1)
+            elif 'naive-r' == multicol_align:
+                out = f'{{{display_val}}}' if wrap else f'{display_val}'
+                blanks = '{} & ' if wrap else '& '
+                return blanks * (colspan - 1) + out
+            return f'\\multicolumn{{{colspan}}}{{{multicol_align}}}{{{display_val}}}'
+        elif 'rowspan="' in attrs:
+            if multirow_align == 'naive':
+                return display_val
+            rowspan = attrs[attrs.find('rowspan="') + 9:]
+            rowspan = int(rowspan[:rowspan.find('"')])
+            return f'\\multirow[{multirow_align}]{{{rowspan}}}{{*}}{{{display_val}}}'
+    if wrap:
+        return f'{{{display_val}}}'
+    else:
+        return display_val
+
+def _parse_latex_options_strip(value: str | float, arg: str) -> str:
+    return str(value).replace(arg, '').replace('/*', '').replace('*/', '').strip()
+
+def _parse_latex_css_conversion(styles: CSSList) -> CSSList:
+
+    def font_weight(value, arg) -> tuple[str, str] | None:
+        if value in ('bold', 'bolder'):
+            return ('bfseries', f'{arg}')
+        return None
+
+    def font_style(value, arg) -> tuple[str, str] | None:
+        if value == 'italic':
+            return ('itshape', f'{arg}')
+        if value == 'oblique':
+            return ('slshape', f'{arg}')
+        return None
+
+    def color(value, user_arg, command, comm_arg):
+        arg = user_arg if user_arg != '' else comm_arg
+        if value[0] == '#' and len(value) == 7:
+            return (command, f'[HTML]{{{value[1:].upper()}}}{arg}')
+        if value[0] == '#' and len(value) == 4:
+            val = f'{value[1].upper() * 2}{value[2].upper() * 2}{value[3].upper() * 2}'
+            return (command, f'[HTML]{{{val}}}{arg}')
+        elif value[:3] == 'rgb':
+            r = re.findall('(?<=\\()[0-9\\s%]+(?=,)', value)[0].strip()
+            r = float(r[:-1]) / 100 if '%' in r else int(r) / 255
+            g = re.findall('(?<=,)[0-9\\s%]+(?=,)', value)[0].strip()
+            g = float(g[:-1]) / 100 if '%' in g else int(g) / 255
+            if value[3] == 'a':
+                b = re.findall('(?<=,)[0-9\\s%]+(?=,)', value)[1].strip()
+            else:
+                b = re.findall('(?<=,)[0-9\\s%]+(?=\\))', value)[0].strip()
+            b = float(b[:-1]) / 100 if '%' in b else int(b) / 255
+            return (command, f'[rgb]{{{r:.3f}, {g:.3f}, {b:.3f}}}{arg}')
+        else:
+            return (command, f'{{{value}}}{arg}')
+    CONVERTED_ATTRIBUTES: dict[str, Callable] = {'font-weight': font_weight, 'background-color': partial(color, command='cellcolor', comm_arg='--lwrap'), 'color': partial(color, command='color', comm_arg=''), 'font-style': font_style}
+    latex_styles: CSSList = []
+    for (attribute, value) in styles:
+        if isinstance(value, str) and '--latex' in value:
+            latex_styles.append((attribute, value.replace('--latex', '')))
+        if attribute in CONVERTED_ATTRIBUTES:
+            arg = ''
+            for x in ['--wrap', '--nowrap', '--lwrap', '--dwrap', '--rwrap']:
+                if x in str(value):
+                    (arg, value) = (x, _parse_latex_options_strip(value, x))
+                    break
+            latex_style = CONVERTED_ATTRIBUTES[attribute](value, arg)
+            if latex_style is not None:
+                latex_styles.extend([latex_style])
+    return latex_styles
+
+def _escape_latex(s: str) -> str:
+    return s.replace('\\', 'ab2§=§8yz').replace('ab2§=§8yz ', 'ab2§=§8yz\\space ').replace('&', '\\&').replace('%', '\\%').replace('$', '\\$').replace('#', '\\#').replace('_', '\\_').replace('{', '\\{').replace('}', '\\}').replace('~ ', '~\\space ').replace('~', '\\textasciitilde ').replace('^ ', '^\\space ').replace('^', '\\textasciicircum ').replace('ab2§=§8yz', '\\textbackslash ')
+
+def _math_mode_with_dollar(s: str) -> str:
+    s = s.replace('\\$', 'rt8§=§7wz')
+    pattern = re.compile('\\$.*?\\$')
+    pos = 0
+    ps = pattern.search(s, pos)
+    res = []
+    while ps:
+        res.append(_escape_latex(s[pos:ps.span()[0]]))
+        res.append(ps.group())
+        pos = ps.span()[1]
+        ps = pattern.search(s, pos)
+    res.append(_escape_latex(s[pos:len(s)]))
+    return ''.join(res).replace('rt8§=§7wz', '\\$')
+
+def _math_mode_with_parentheses(s: str) -> str:
+    s = s.replace('\\(', 'LEFT§=§6yzLEFT').replace('\\)', 'RIGHTab5§=§RIGHT')
+    res = []
+    for item in re.split('LEFT§=§6yz|ab5§=§RIGHT', s):
+        if item.startswith('LEFT') and item.endswith('RIGHT'):
+            res.append(item.replace('LEFT', '\\(').replace('RIGHT', '\\)'))
+        elif 'LEFT' in item and 'RIGHT' in item:
+            res.append(_escape_latex(item).replace('LEFT', '\\(').replace('RIGHT', '\\)'))
+        else:
+            res.append(_escape_latex(item).replace('LEFT', '\\textbackslash (').replace('RIGHT', '\\textbackslash )'))
+    return ''.join(res)
+
+def _escape_latex_math(s: str) -> str:
+    s = s.replace('\\$', 'rt8§=§7wz')
+    ps_d = re.compile('\\$.*?\\$').search(s, 0)
+    ps_p = re.compile('\\(.*?\\)').search(s, 0)
+    mode = []
+    if ps_d:
+        mode.append(ps_d.span()[0])
+    if ps_p:
+        mode.append(ps_p.span()[0])
+    if len(mode) == 0:
+        return _escape_latex(s.replace('rt8§=§7wz', '\\$'))
+    if s[mode[0]] == '$':
+        return _math_mode_with_dollar(s.replace('rt8§=§7wz', '\\$'))
+    if s[mode[0] - 1:mode[0] + 1] == '\\(':
+        return _math_mode_with_parentheses(s.replace('rt8§=§7wz', '\\$'))
+    else:
+        return _escape_latex(s.replace('rt8§=§7wz', '\\$'))
+
+# File: pandas-main/pandas/io/formats/xml.py
+""""""
+from __future__ import annotations
+import codecs
+import io
+from typing import TYPE_CHECKING, Any, final
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import cache_readonly, doc
+from pandas.core.dtypes.common import is_list_like
+from pandas.core.dtypes.missing import isna
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.common import get_handle
+from pandas.io.xml import get_data_from_filepath
+if TYPE_CHECKING:
+    from pandas._typing import CompressionOptions, FilePath, ReadBuffer, StorageOptions, WriteBuffer
+    from pandas import DataFrame
+
+@doc(storage_options=_shared_docs['storage_options'], compression_options=_shared_docs['compression_options'] % 'path_or_buffer')
+class _BaseXMLFormatter:
+
+    def __init__(self, frame: DataFrame, path_or_buffer: FilePath | WriteBuffer[bytes] | WriteBuffer[str] | None=None, index: bool=True, root_name: str | None='data', row_name: str | None='row', na_rep: str | None=None, attr_cols: list[str] | None=None, elem_cols: list[str] | None=None, namespaces: dict[str | None, str] | None=None, prefix: str | None=None, encoding: str='utf-8', xml_declaration: bool | None=True, pretty_print: bool | None=True, stylesheet: FilePath | ReadBuffer[str] | ReadBuffer[bytes] | None=None, compression: CompressionOptions='infer', storage_options: StorageOptions | None=None) -> None:
+        self.frame = frame
+        self.path_or_buffer = path_or_buffer
+        self.index = index
+        self.root_name = root_name
+        self.row_name = row_name
+        self.na_rep = na_rep
+        self.attr_cols = attr_cols
+        self.elem_cols = elem_cols
+        self.namespaces = namespaces
+        self.prefix = prefix
+        self.encoding = encoding
+        self.xml_declaration = xml_declaration
+        self.pretty_print = pretty_print
+        self.stylesheet = stylesheet
+        self.compression: CompressionOptions = compression
+        self.storage_options = storage_options
+        self.orig_cols = self.frame.columns.tolist()
+        self.frame_dicts = self._process_dataframe()
+        self._validate_columns()
+        self._validate_encoding()
+        self.prefix_uri = self._get_prefix_uri()
+        self._handle_indexes()
+
+    def _build_tree(self) -> bytes:
+        raise AbstractMethodError(self)
+
+    @final
+    def _validate_columns(self) -> None:
+        if self.attr_cols and (not is_list_like(self.attr_cols)):
+            raise TypeError(f'{type(self.attr_cols).__name__} is not a valid type for attr_cols')
+        if self.elem_cols and (not is_list_like(self.elem_cols)):
+            raise TypeError(f'{type(self.elem_cols).__name__} is not a valid type for elem_cols')
+
+    @final
+    def _validate_encoding(self) -> None:
+        codecs.lookup(self.encoding)
+
+    @final
+    def _process_dataframe(self) -> dict[int | str, dict[str, Any]]:
+        df = self.frame
+        if self.index:
+            df = df.reset_index()
+        if self.na_rep is not None:
+            df = df.fillna(self.na_rep)
+        return df.to_dict(orient='index')
+
+    @final
+    def _handle_indexes(self) -> None:
+        if not self.index:
+            return
+        first_key = next(iter(self.frame_dicts))
+        indexes: list[str] = [x for x in self.frame_dicts[first_key].keys() if x not in self.orig_cols]
+        if self.attr_cols:
+            self.attr_cols = indexes + self.attr_cols
+        if self.elem_cols:
+            self.elem_cols = indexes + self.elem_cols
+
+    def _get_prefix_uri(self) -> str:
+        raise AbstractMethodError(self)
+
+    @final
+    def _other_namespaces(self) -> dict:
+        nmsp_dict: dict[str, str] = {}
+        if self.namespaces:
+            nmsp_dict = {f"xmlns{(p if p == '' else f':{p}')}": n for (p, n) in self.namespaces.items() if n != self.prefix_uri[1:-1]}
+        return nmsp_dict
+
+    @final
+    def _build_attribs(self, d: dict[str, Any], elem_row: Any) -> Any:
+        if not self.attr_cols:
+            return elem_row
+        for col in self.attr_cols:
+            attr_name = self._get_flat_col_name(col)
+            try:
+                if not isna(d[col]):
+                    elem_row.attrib[attr_name] = str(d[col])
+            except KeyError as err:
+                raise KeyError(f'no valid column, {col}') from err
+        return elem_row
+
+    @final
+    def _get_flat_col_name(self, col: str | tuple) -> str:
+        flat_col = col
+        if isinstance(col, tuple):
+            flat_col = ''.join([str(c) for c in col]).strip() if '' in col else '_'.join([str(c) for c in col]).strip()
+        return f'{self.prefix_uri}{flat_col}'
+
+    @cache_readonly
+    def _sub_element_cls(self):
+        raise AbstractMethodError(self)
+
+    @final
+    def _build_elems(self, d: dict[str, Any], elem_row: Any) -> None:
+        sub_element_cls = self._sub_element_cls
+        if not self.elem_cols:
+            return
+        for col in self.elem_cols:
+            elem_name = self._get_flat_col_name(col)
+            try:
+                val = None if isna(d[col]) or d[col] == '' else str(d[col])
+                sub_element_cls(elem_row, elem_name).text = val
+            except KeyError as err:
+                raise KeyError(f'no valid column, {col}') from err
+
+    @final
+    def write_output(self) -> str | None:
+        xml_doc = self._build_tree()
+        if self.path_or_buffer is not None:
+            with get_handle(self.path_or_buffer, 'wb', compression=self.compression, storage_options=self.storage_options, is_text=False) as handles:
+                handles.handle.write(xml_doc)
+            return None
+        else:
+            return xml_doc.decode(self.encoding).rstrip()
+
+class EtreeXMLFormatter(_BaseXMLFormatter):
+
+    def _build_tree(self) -> bytes:
+        from xml.etree.ElementTree import Element, SubElement, tostring
+        self.root = Element(f'{self.prefix_uri}{self.root_name}', attrib=self._other_namespaces())
+        for d in self.frame_dicts.values():
+            elem_row = SubElement(self.root, f'{self.prefix_uri}{self.row_name}')
+            if not self.attr_cols and (not self.elem_cols):
+                self.elem_cols = list(d.keys())
+                self._build_elems(d, elem_row)
+            else:
+                elem_row = self._build_attribs(d, elem_row)
+                self._build_elems(d, elem_row)
+        self.out_xml = tostring(self.root, method='xml', encoding=self.encoding, xml_declaration=self.xml_declaration)
+        if self.pretty_print:
+            self.out_xml = self._prettify_tree()
+        if self.stylesheet is not None:
+            raise ValueError('To use stylesheet, you need lxml installed and selected as parser.')
+        return self.out_xml
+
+    def _get_prefix_uri(self) -> str:
+        from xml.etree.ElementTree import register_namespace
+        uri = ''
+        if self.namespaces:
+            for (p, n) in self.namespaces.items():
+                if isinstance(p, str) and isinstance(n, str):
+                    register_namespace(p, n)
+            if self.prefix:
+                try:
+                    uri = f'{{{self.namespaces[self.prefix]}}}'
+                except KeyError as err:
+                    raise KeyError(f'{self.prefix} is not included in namespaces') from err
+            elif '' in self.namespaces:
+                uri = f"{{{self.namespaces['']}}}"
+            else:
+                uri = ''
+        return uri
+
+    @cache_readonly
+    def _sub_element_cls(self):
+        from xml.etree.ElementTree import SubElement
+        return SubElement
+
+    def _prettify_tree(self) -> bytes:
+        from xml.dom.minidom import parseString
+        dom = parseString(self.out_xml)
+        return dom.toprettyxml(indent='  ', encoding=self.encoding)
+
+class LxmlXMLFormatter(_BaseXMLFormatter):
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._convert_empty_str_key()
+
+    def _build_tree(self) -> bytes:
+        from lxml.etree import Element, SubElement, tostring
+        self.root = Element(f'{self.prefix_uri}{self.root_name}', nsmap=self.namespaces)
+        for d in self.frame_dicts.values():
+            elem_row = SubElement(self.root, f'{self.prefix_uri}{self.row_name}')
+            if not self.attr_cols and (not self.elem_cols):
+                self.elem_cols = list(d.keys())
+                self._build_elems(d, elem_row)
+            else:
+                elem_row = self._build_attribs(d, elem_row)
+                self._build_elems(d, elem_row)
+        self.out_xml = tostring(self.root, pretty_print=self.pretty_print, method='xml', encoding=self.encoding, xml_declaration=self.xml_declaration)
+        if self.stylesheet is not None:
+            self.out_xml = self._transform_doc()
+        return self.out_xml
+
+    def _convert_empty_str_key(self) -> None:
+        if self.namespaces and '' in self.namespaces.keys():
+            self.namespaces[None] = self.namespaces.pop('', 'default')
+
+    def _get_prefix_uri(self) -> str:
+        uri = ''
+        if self.namespaces:
+            if self.prefix:
+                try:
+                    uri = f'{{{self.namespaces[self.prefix]}}}'
+                except KeyError as err:
+                    raise KeyError(f'{self.prefix} is not included in namespaces') from err
+            elif '' in self.namespaces:
+                uri = f"{{{self.namespaces['']}}}"
+            else:
+                uri = ''
+        return uri
+
+    @cache_readonly
+    def _sub_element_cls(self):
+        from lxml.etree import SubElement
+        return SubElement
+
+    def _transform_doc(self) -> bytes:
+        from lxml.etree import XSLT, XMLParser, fromstring, parse
+        style_doc = self.stylesheet
+        assert style_doc is not None
+        handle_data = get_data_from_filepath(filepath_or_buffer=style_doc, encoding=self.encoding, compression=self.compression, storage_options=self.storage_options)
+        with handle_data as xml_data:
+            curr_parser = XMLParser(encoding=self.encoding)
+            if isinstance(xml_data, io.StringIO):
+                xsl_doc = fromstring(xml_data.getvalue().encode(self.encoding), parser=curr_parser)
+            else:
+                xsl_doc = parse(xml_data, parser=curr_parser)
+        transformer = XSLT(xsl_doc)
+        new_doc = transformer(self.root)
+        return bytes(new_doc)
+
+# File: pandas-main/pandas/io/html.py
+""""""
+from __future__ import annotations
+from collections import abc
+import errno
+import numbers
+import os
+import re
+from re import Pattern
+from typing import TYPE_CHECKING, Literal, cast
+from pandas._libs import lib
+from pandas.compat._optional import import_optional_dependency
+from pandas.errors import AbstractMethodError, EmptyDataError
+from pandas.util._decorators import doc
+from pandas.util._validators import check_dtype_backend
+from pandas.core.dtypes.common import is_list_like
+from pandas import isna
+from pandas.core.indexes.base import Index
+from pandas.core.indexes.multi import MultiIndex
+from pandas.core.series import Series
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.common import get_handle, is_url, stringify_path, validate_header_arg
+from pandas.io.formats.printing import pprint_thing
+from pandas.io.parsers import TextParser
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+    from pandas._typing import BaseBuffer, DtypeBackend, FilePath, HTMLFlavors, ReadBuffer, StorageOptions
+    from pandas import DataFrame
+_RE_WHITESPACE = re.compile('[\\r\\n]+|\\s{2,}')
+
+def _remove_whitespace(s: str, regex: Pattern=_RE_WHITESPACE) -> str:
+    return regex.sub(' ', s.strip())
+
+def _get_skiprows(skiprows: int | Sequence[int] | slice | None) -> int | Sequence[int]:
+    if isinstance(skiprows, slice):
+        (start, step) = (skiprows.start or 0, skiprows.step or 1)
+        return list(range(start, skiprows.stop, step))
+    elif isinstance(skiprows, numbers.Integral) or is_list_like(skiprows):
+        return cast('int | Sequence[int]', skiprows)
+    elif skiprows is None:
+        return 0
+    raise TypeError(f'{type(skiprows).__name__} is not a valid type for skipping rows')
+
+def _read(obj: FilePath | BaseBuffer, encoding: str | None, storage_options: StorageOptions | None) -> str | bytes:
+    try:
+        with get_handle(obj, 'r', encoding=encoding, storage_options=storage_options) as handles:
+            return handles.handle.read()
+    except OSError as err:
+        if not is_url(obj):
+            raise FileNotFoundError(f'[Errno {errno.ENOENT}] {os.strerror(errno.ENOENT)}: {obj}') from err
+        raise
+
+class _HtmlFrameParser:
+
+    def __init__(self, io: FilePath | ReadBuffer[str] | ReadBuffer[bytes], match: str | Pattern, attrs: dict[str, str] | None, encoding: str, displayed_only: bool, extract_links: Literal[None, 'header', 'footer', 'body', 'all'], storage_options: StorageOptions=None) -> None:
+        self.io = io
+        self.match = match
+        self.attrs = attrs
+        self.encoding = encoding
+        self.displayed_only = displayed_only
+        self.extract_links = extract_links
+        self.storage_options = storage_options
+
+    def parse_tables(self):
+        tables = self._parse_tables(self._build_doc(), self.match, self.attrs)
+        return (self._parse_thead_tbody_tfoot(table) for table in tables)
+
+    def _attr_getter(self, obj, attr):
+        return obj.get(attr)
+
+    def _href_getter(self, obj) -> str | None:
+        raise AbstractMethodError(self)
+
+    def _text_getter(self, obj):
+        raise AbstractMethodError(self)
+
+    def _parse_td(self, obj):
+        raise AbstractMethodError(self)
+
+    def _parse_thead_tr(self, table):
+        raise AbstractMethodError(self)
+
+    def _parse_tbody_tr(self, table):
+        raise AbstractMethodError(self)
+
+    def _parse_tfoot_tr(self, table):
+        raise AbstractMethodError(self)
+
+    def _parse_tables(self, document, match, attrs):
+        raise AbstractMethodError(self)
+
+    def _equals_tag(self, obj, tag) -> bool:
+        raise AbstractMethodError(self)
+
+    def _build_doc(self):
+        raise AbstractMethodError(self)
+
+    def _parse_thead_tbody_tfoot(self, table_html):
+        header_rows = self._parse_thead_tr(table_html)
+        body_rows = self._parse_tbody_tr(table_html)
+        footer_rows = self._parse_tfoot_tr(table_html)
+
+        def row_is_all_th(row):
+            return all((self._equals_tag(t, 'th') for t in self._parse_td(row)))
+        if not header_rows:
+            while body_rows and row_is_all_th(body_rows[0]):
+                header_rows.append(body_rows.pop(0))
+        header = self._expand_colspan_rowspan(header_rows, section='header')
+        body = self._expand_colspan_rowspan(body_rows, section='body')
+        footer = self._expand_colspan_rowspan(footer_rows, section='footer')
+        return (header, body, footer)
+
+    def _expand_colspan_rowspan(self, rows, section: Literal['header', 'footer', 'body']) -> list[list]:
+        all_texts = []
+        text: str | tuple
+        remainder: list[tuple[int, str | tuple, int]] = []
+        for tr in rows:
+            texts = []
+            next_remainder = []
+            index = 0
+            tds = self._parse_td(tr)
+            for td in tds:
+                while remainder and remainder[0][0] <= index:
+                    (prev_i, prev_text, prev_rowspan) = remainder.pop(0)
+                    texts.append(prev_text)
+                    if prev_rowspan > 1:
+                        next_remainder.append((prev_i, prev_text, prev_rowspan - 1))
+                    index += 1
+                text = _remove_whitespace(self._text_getter(td))
+                if self.extract_links in ('all', section):
+                    href = self._href_getter(td)
+                    text = (text, href)
+                rowspan = int(self._attr_getter(td, 'rowspan') or 1)
+                colspan = int(self._attr_getter(td, 'colspan') or 1)
+                for _ in range(colspan):
+                    texts.append(text)
+                    if rowspan > 1:
+                        next_remainder.append((index, text, rowspan - 1))
+                    index += 1
+            for (prev_i, prev_text, prev_rowspan) in remainder:
+                texts.append(prev_text)
+                if prev_rowspan > 1:
+                    next_remainder.append((prev_i, prev_text, prev_rowspan - 1))
+            all_texts.append(texts)
+            remainder = next_remainder
+        while remainder:
+            next_remainder = []
+            texts = []
+            for (prev_i, prev_text, prev_rowspan) in remainder:
+                texts.append(prev_text)
+                if prev_rowspan > 1:
+                    next_remainder.append((prev_i, prev_text, prev_rowspan - 1))
+            all_texts.append(texts)
+            remainder = next_remainder
+        return all_texts
+
+    def _handle_hidden_tables(self, tbl_list, attr_name: str):
+        if not self.displayed_only:
+            return tbl_list
+        return [x for x in tbl_list if 'display:none' not in getattr(x, attr_name).get('style', '').replace(' ', '')]
+
+class _BeautifulSoupHtml5LibFrameParser(_HtmlFrameParser):
+
+    def _parse_tables(self, document, match, attrs):
+        element_name = 'table'
+        tables = document.find_all(element_name, attrs=attrs)
+        if not tables:
+            raise ValueError('No tables found')
+        result = []
+        unique_tables = set()
+        tables = self._handle_hidden_tables(tables, 'attrs')
+        for table in tables:
+            if self.displayed_only:
+                for elem in table.find_all('style'):
+                    elem.decompose()
+                for elem in table.find_all(style=re.compile('display:\\s*none')):
+                    elem.decompose()
+            if table not in unique_tables and table.find(string=match) is not None:
+                result.append(table)
+            unique_tables.add(table)
+        if not result:
+            raise ValueError(f'No tables found matching pattern {match.pattern!r}')
+        return result
+
+    def _href_getter(self, obj) -> str | None:
+        a = obj.find('a', href=True)
+        return None if not a else a['href']
+
+    def _text_getter(self, obj):
+        return obj.text
+
+    def _equals_tag(self, obj, tag) -> bool:
+        return obj.name == tag
+
+    def _parse_td(self, row):
+        return row.find_all(('td', 'th'), recursive=False)
+
+    def _parse_thead_tr(self, table):
+        return table.select('thead tr')
+
+    def _parse_tbody_tr(self, table):
+        from_tbody = table.select('tbody tr')
+        from_root = table.find_all('tr', recursive=False)
+        return from_tbody + from_root
+
+    def _parse_tfoot_tr(self, table):
+        return table.select('tfoot tr')
+
+    def _setup_build_doc(self):
+        raw_text = _read(self.io, self.encoding, self.storage_options)
+        if not raw_text:
+            raise ValueError(f'No text parsed from document: {self.io}')
+        return raw_text
+
+    def _build_doc(self):
+        from bs4 import BeautifulSoup
+        bdoc = self._setup_build_doc()
+        if isinstance(bdoc, bytes) and self.encoding is not None:
+            udoc = bdoc.decode(self.encoding)
+            from_encoding = None
+        else:
+            udoc = bdoc
+            from_encoding = self.encoding
+        soup = BeautifulSoup(udoc, features='html5lib', from_encoding=from_encoding)
+        for br in soup.find_all('br'):
+            br.replace_with('\n' + br.text)
+        return soup
+
+def _build_xpath_expr(attrs) -> str:
+    if 'class_' in attrs:
+        attrs['class'] = attrs.pop('class_')
+    s = ' and '.join([f'@{k}={v!r}' for (k, v) in attrs.items()])
+    return f'[{s}]'
+_re_namespace = {'re': 'http://exslt.org/regular-expressions'}
+
+class _LxmlFrameParser(_HtmlFrameParser):
+
+    def _href_getter(self, obj) -> str | None:
+        href = obj.xpath('.//a/@href')
+        return None if not href else href[0]
+
+    def _text_getter(self, obj):
+        return obj.text_content()
+
+    def _parse_td(self, row):
+        return row.xpath('./td|./th')
+
+    def _parse_tables(self, document, match, kwargs):
+        pattern = match.pattern
+        xpath_expr = f'//table[.//text()[re:test(., {pattern!r})]]'
+        if kwargs:
+            xpath_expr += _build_xpath_expr(kwargs)
+        tables = document.xpath(xpath_expr, namespaces=_re_namespace)
+        tables = self._handle_hidden_tables(tables, 'attrib')
+        if self.displayed_only:
+            for table in tables:
+                for elem in table.xpath('.//style'):
+                    elem.drop_tree()
+                for elem in table.xpath('.//*[@style]'):
+                    if 'display:none' in elem.attrib.get('style', '').replace(' ', ''):
+                        elem.drop_tree()
+        if not tables:
+            raise ValueError(f'No tables found matching regex {pattern!r}')
+        return tables
+
+    def _equals_tag(self, obj, tag) -> bool:
+        return obj.tag == tag
+
+    def _build_doc(self):
+        from lxml.etree import XMLSyntaxError
+        from lxml.html import HTMLParser, parse
+        parser = HTMLParser(recover=True, encoding=self.encoding)
+        if is_url(self.io):
+            with get_handle(self.io, 'r', storage_options=self.storage_options) as f:
+                r = parse(f.handle, parser=parser)
+        else:
+            try:
+                r = parse(self.io, parser=parser)
+            except OSError as err:
+                raise FileNotFoundError(f'[Errno {errno.ENOENT}] {os.strerror(errno.ENOENT)}: {self.io}') from err
+        try:
+            r = r.getroot()
+        except AttributeError:
+            pass
+        else:
+            if not hasattr(r, 'text_content'):
+                raise XMLSyntaxError('no text parsed from document', 0, 0, 0)
+        for br in r.xpath('*//br'):
+            br.tail = '\n' + (br.tail or '')
+        return r
+
+    def _parse_thead_tr(self, table):
+        rows = []
+        for thead in table.xpath('.//thead'):
+            rows.extend(thead.xpath('./tr'))
+            elements_at_root = thead.xpath('./td|./th')
+            if elements_at_root:
+                rows.append(thead)
+        return rows
+
+    def _parse_tbody_tr(self, table):
+        from_tbody = table.xpath('.//tbody//tr')
+        from_root = table.xpath('./tr')
+        return from_tbody + from_root
+
+    def _parse_tfoot_tr(self, table):
+        return table.xpath('.//tfoot//tr')
+
+def _expand_elements(body) -> None:
+    data = [len(elem) for elem in body]
+    lens = Series(data)
+    lens_max = lens.max()
+    not_max = lens[lens != lens_max]
+    empty = ['']
+    for (ind, length) in not_max.items():
+        body[ind] += empty * (lens_max - length)
+
+def _data_to_frame(**kwargs):
+    (head, body, foot) = kwargs.pop('data')
+    header = kwargs.pop('header')
+    kwargs['skiprows'] = _get_skiprows(kwargs['skiprows'])
+    if head:
+        body = head + body
+        if header is None:
+            if len(head) == 1:
+                header = 0
+            else:
+                header = [i for (i, row) in enumerate(head) if any((text for text in row))]
+    if foot:
+        body += foot
+    _expand_elements(body)
+    with TextParser(body, header=header, **kwargs) as tp:
+        return tp.read()
+_valid_parsers = {'lxml': _LxmlFrameParser, None: _LxmlFrameParser, 'html5lib': _BeautifulSoupHtml5LibFrameParser, 'bs4': _BeautifulSoupHtml5LibFrameParser}
+
+def _parser_dispatch(flavor: HTMLFlavors | None) -> type[_HtmlFrameParser]:
+    valid_parsers = list(_valid_parsers.keys())
+    if flavor not in valid_parsers:
+        raise ValueError(f'{flavor!r} is not a valid flavor, valid flavors are {valid_parsers}')
+    if flavor in ('bs4', 'html5lib'):
+        import_optional_dependency('html5lib')
+        import_optional_dependency('bs4')
+    else:
+        import_optional_dependency('lxml.etree')
+    return _valid_parsers[flavor]
+
+def _print_as_set(s) -> str:
+    arg = ', '.join([pprint_thing(el) for el in s])
+    return f'{{{arg}}}'
+
+def _validate_flavor(flavor):
+    if flavor is None:
+        flavor = ('lxml', 'bs4')
+    elif isinstance(flavor, str):
+        flavor = (flavor,)
+    elif isinstance(flavor, abc.Iterable):
+        if not all((isinstance(flav, str) for flav in flavor)):
+            raise TypeError(f'Object of type {type(flavor).__name__!r} is not an iterable of strings')
+    else:
+        msg = repr(flavor) if isinstance(flavor, str) else str(flavor)
+        msg += ' is not a valid flavor'
+        raise ValueError(msg)
+    flavor = tuple(flavor)
+    valid_flavors = set(_valid_parsers)
+    flavor_set = set(flavor)
+    if not flavor_set & valid_flavors:
+        raise ValueError(f'{_print_as_set(flavor_set)} is not a valid set of flavors, valid flavors are {_print_as_set(valid_flavors)}')
+    return flavor
+
+def _parse(flavor, io, match, attrs, encoding, displayed_only, extract_links, storage_options, **kwargs):
+    flavor = _validate_flavor(flavor)
+    compiled_match = re.compile(match)
+    retained = None
+    for flav in flavor:
+        parser = _parser_dispatch(flav)
+        p = parser(io, compiled_match, attrs, encoding, displayed_only, extract_links, storage_options)
+        try:
+            tables = p.parse_tables()
+        except ValueError as caught:
+            if hasattr(io, 'seekable') and io.seekable():
+                io.seek(0)
+            elif hasattr(io, 'seekable') and (not io.seekable()):
+                raise ValueError(f"The flavor {flav} failed to parse your input. Since you passed a non-rewindable file object, we can't rewind it to try another parser. Try read_html() with a different flavor.") from caught
+            retained = caught
+        else:
+            break
+    else:
+        assert retained is not None
+        raise retained
+    ret = []
+    for table in tables:
+        try:
+            df = _data_to_frame(data=table, **kwargs)
+            if extract_links in ('all', 'header') and isinstance(df.columns, MultiIndex):
+                df.columns = Index(((col[0], None if isna(col[1]) else col[1]) for col in df.columns), tupleize_cols=False)
+            ret.append(df)
+        except EmptyDataError:
+            continue
+    return ret
+
+@doc(storage_options=_shared_docs['storage_options'])
+def read_html(io: FilePath | ReadBuffer[str], *, match: str | Pattern='.+', flavor: HTMLFlavors | Sequence[HTMLFlavors] | None=None, header: int | Sequence[int] | None=None, index_col: int | Sequence[int] | None=None, skiprows: int | Sequence[int] | slice | None=None, attrs: dict[str, str] | None=None, parse_dates: bool=False, thousands: str | None=',', encoding: str | None=None, decimal: str='.', converters: dict | None=None, na_values: Iterable[object] | None=None, keep_default_na: bool=True, displayed_only: bool=True, extract_links: Literal[None, 'header', 'footer', 'body', 'all']=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, storage_options: StorageOptions=None) -> list[DataFrame]:
+    if isinstance(skiprows, numbers.Integral) and skiprows < 0:
+        raise ValueError('cannot skip rows starting from the end of the data (you passed a negative value)')
+    if extract_links not in [None, 'header', 'footer', 'body', 'all']:
+        raise ValueError(f'`extract_links` must be one of {{None, "header", "footer", "body", "all"}}, got "{extract_links}"')
+    validate_header_arg(header)
+    check_dtype_backend(dtype_backend)
+    io = stringify_path(io)
+    return _parse(flavor=flavor, io=io, match=match, header=header, index_col=index_col, skiprows=skiprows, parse_dates=parse_dates, thousands=thousands, attrs=attrs, encoding=encoding, decimal=decimal, converters=converters, na_values=na_values, keep_default_na=keep_default_na, displayed_only=displayed_only, extract_links=extract_links, dtype_backend=dtype_backend, storage_options=storage_options)
+
+# File: pandas-main/pandas/io/json/__init__.py
+from pandas.io.json._json import read_json, to_json, ujson_dumps, ujson_loads
+from pandas.io.json._table_schema import build_table_schema
+__all__ = ['ujson_dumps', 'ujson_loads', 'read_json', 'to_json', 'build_table_schema']
+
+# File: pandas-main/pandas/io/json/_json.py
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from collections import abc
+from itertools import islice
+from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar, final, overload
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.json import ujson_dumps, ujson_loads
+from pandas._libs.tslibs import iNaT
+from pandas.compat._optional import import_optional_dependency
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import doc
+from pandas.util._validators import check_dtype_backend
+from pandas.core.dtypes.common import ensure_str, is_string_dtype
+from pandas.core.dtypes.dtypes import PeriodDtype
+from pandas import ArrowDtype, DataFrame, Index, MultiIndex, Series, isna, notna, to_datetime
+from pandas.core.reshape.concat import concat
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.common import IOHandles, dedup_names, get_handle, is_potential_multi_index, stringify_path
+from pandas.io.json._normalize import convert_to_line_delimits
+from pandas.io.json._table_schema import build_table_schema, parse_table_schema, set_default_names
+from pandas.io.parsers.readers import validate_integer
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Mapping
+    from types import TracebackType
+    from pandas._typing import CompressionOptions, DtypeArg, DtypeBackend, FilePath, IndexLabel, JSONEngine, JSONSerializable, ReadBuffer, Self, StorageOptions, WriteBuffer
+    from pandas.core.generic import NDFrame
+FrameSeriesStrT = TypeVar('FrameSeriesStrT', bound=Literal['frame', 'series'])
+
+@overload
+def to_json(path_or_buf: FilePath | WriteBuffer[str] | WriteBuffer[bytes], obj: NDFrame, orient: str | None=..., date_format: str=..., double_precision: int=..., force_ascii: bool=..., date_unit: str=..., default_handler: Callable[[Any], JSONSerializable] | None=..., lines: bool=..., compression: CompressionOptions=..., index: bool | None=..., indent: int=..., storage_options: StorageOptions=..., mode: Literal['a', 'w']=...) -> None:
+    ...
+
+@overload
+def to_json(path_or_buf: None, obj: NDFrame, orient: str | None=..., date_format: str=..., double_precision: int=..., force_ascii: bool=..., date_unit: str=..., default_handler: Callable[[Any], JSONSerializable] | None=..., lines: bool=..., compression: CompressionOptions=..., index: bool | None=..., indent: int=..., storage_options: StorageOptions=..., mode: Literal['a', 'w']=...) -> str:
+    ...
+
+def to_json(path_or_buf: FilePath | WriteBuffer[str] | WriteBuffer[bytes] | None, obj: NDFrame, orient: str | None=None, date_format: str='epoch', double_precision: int=10, force_ascii: bool=True, date_unit: str='ms', default_handler: Callable[[Any], JSONSerializable] | None=None, lines: bool=False, compression: CompressionOptions='infer', index: bool | None=None, indent: int=0, storage_options: StorageOptions | None=None, mode: Literal['a', 'w']='w') -> str | None:
+    if orient in ['records', 'values'] and index is True:
+        raise ValueError("'index=True' is only valid when 'orient' is 'split', 'table', 'index', or 'columns'.")
+    elif orient in ['index', 'columns'] and index is False:
+        raise ValueError("'index=False' is only valid when 'orient' is 'split', 'table', 'records', or 'values'.")
+    elif index is None:
+        index = True
+    if lines and orient != 'records':
+        raise ValueError("'lines' keyword only valid when 'orient' is records")
+    if mode not in ['a', 'w']:
+        msg = f"mode={mode} is not a valid option.Only 'w' and 'a' are currently supported."
+        raise ValueError(msg)
+    if mode == 'a' and (not lines or orient != 'records'):
+        msg = "mode='a' (append) is only supported when lines is True and orient is 'records'"
+        raise ValueError(msg)
+    if orient == 'table' and isinstance(obj, Series):
+        obj = obj.to_frame(name=obj.name or 'values')
+    writer: type[Writer]
+    if orient == 'table' and isinstance(obj, DataFrame):
+        writer = JSONTableWriter
+    elif isinstance(obj, Series):
+        writer = SeriesWriter
+    elif isinstance(obj, DataFrame):
+        writer = FrameWriter
+    else:
+        raise NotImplementedError("'obj' should be a Series or a DataFrame")
+    s = writer(obj, orient=orient, date_format=date_format, double_precision=double_precision, ensure_ascii=force_ascii, date_unit=date_unit, default_handler=default_handler, index=index, indent=indent).write()
+    if lines:
+        s = convert_to_line_delimits(s)
+    if path_or_buf is not None:
+        with get_handle(path_or_buf, mode, compression=compression, storage_options=storage_options) as handles:
+            handles.handle.write(s)
+    else:
+        return s
+    return None
+
+class Writer(ABC):
+    _default_orient: str
+
+    def __init__(self, obj: NDFrame, orient: str | None, date_format: str, double_precision: int, ensure_ascii: bool, date_unit: str, index: bool, default_handler: Callable[[Any], JSONSerializable] | None=None, indent: int=0) -> None:
+        self.obj = obj
+        if orient is None:
+            orient = self._default_orient
+        self.orient = orient
+        self.date_format = date_format
+        self.double_precision = double_precision
+        self.ensure_ascii = ensure_ascii
+        self.date_unit = date_unit
+        self.default_handler = default_handler
+        self.index = index
+        self.indent = indent
+        self._format_axes()
+
+    def _format_axes(self) -> None:
+        raise AbstractMethodError(self)
+
+    def write(self) -> str:
+        iso_dates = self.date_format == 'iso'
+        return ujson_dumps(self.obj_to_write, orient=self.orient, double_precision=self.double_precision, ensure_ascii=self.ensure_ascii, date_unit=self.date_unit, iso_dates=iso_dates, default_handler=self.default_handler, indent=self.indent)
+
+    @property
+    @abstractmethod
+    def obj_to_write(self) -> NDFrame | Mapping[IndexLabel, Any]:
+
+class SeriesWriter(Writer):
+    _default_orient = 'index'
+
+    @property
+    def obj_to_write(self) -> NDFrame | Mapping[IndexLabel, Any]:
+        if not self.index and self.orient == 'split':
+            return {'name': self.obj.name, 'data': self.obj.values}
+        else:
+            return self.obj
+
+    def _format_axes(self) -> None:
+        if not self.obj.index.is_unique and self.orient == 'index':
+            raise ValueError(f"Series index must be unique for orient='{self.orient}'")
+
+class FrameWriter(Writer):
+    _default_orient = 'columns'
+
+    @property
+    def obj_to_write(self) -> NDFrame | Mapping[IndexLabel, Any]:
+        if not self.index and self.orient == 'split':
+            obj_to_write = self.obj.to_dict(orient='split')
+            del obj_to_write['index']
+        else:
+            obj_to_write = self.obj
+        return obj_to_write
+
+    def _format_axes(self) -> None:
+        if not self.obj.index.is_unique and self.orient in ('index', 'columns'):
+            raise ValueError(f"DataFrame index must be unique for orient='{self.orient}'.")
+        if not self.obj.columns.is_unique and self.orient in ('index', 'columns', 'records'):
+            raise ValueError(f"DataFrame columns must be unique for orient='{self.orient}'.")
+
+class JSONTableWriter(FrameWriter):
+    _default_orient = 'records'
+
+    def __init__(self, obj, orient: str | None, date_format: str, double_precision: int, ensure_ascii: bool, date_unit: str, index: bool, default_handler: Callable[[Any], JSONSerializable] | None=None, indent: int=0) -> None:
+        super().__init__(obj, orient, date_format, double_precision, ensure_ascii, date_unit, index, default_handler=default_handler, indent=indent)
+        if date_format != 'iso':
+            msg = f"Trying to write with `orient='table'` and `date_format='{date_format}'`. Table Schema requires dates to be formatted with `date_format='iso'`"
+            raise ValueError(msg)
+        self.schema = build_table_schema(obj, index=self.index)
+        if self.index:
+            obj = set_default_names(obj)
+        if obj.ndim == 2 and isinstance(obj.columns, MultiIndex):
+            raise NotImplementedError("orient='table' is not supported for MultiIndex columns")
+        if obj.ndim == 1 and obj.name in set(obj.index.names) or len(obj.columns.intersection(obj.index.names)):
+            msg = 'Overlapping names between the index and columns'
+            raise ValueError(msg)
+        timedeltas = obj.select_dtypes(include=['timedelta']).columns
+        copied = False
+        if len(timedeltas):
+            obj = obj.copy()
+            copied = True
+            obj[timedeltas] = obj[timedeltas].map(lambda x: x.isoformat())
+        if not self.index:
+            self.obj = obj.reset_index(drop=True)
+        else:
+            if isinstance(obj.index.dtype, PeriodDtype):
+                if not copied:
+                    obj = obj.copy(deep=False)
+                obj.index = obj.index.to_timestamp()
+            self.obj = obj.reset_index(drop=False)
+        self.date_format = 'iso'
+        self.orient = 'records'
+        self.index = index
+
+    @property
+    def obj_to_write(self) -> NDFrame | Mapping[IndexLabel, Any]:
+        return {'schema': self.schema, 'data': self.obj}
+
+@overload
+def read_json(path_or_buf: FilePath | ReadBuffer[str] | ReadBuffer[bytes], *, orient: str | None=..., typ: Literal['frame']=..., dtype: DtypeArg | None=..., convert_axes: bool | None=..., convert_dates: bool | list[str]=..., keep_default_dates: bool=..., precise_float: bool=..., date_unit: str | None=..., encoding: str | None=..., encoding_errors: str | None=..., lines: bool=..., chunksize: int, compression: CompressionOptions=..., nrows: int | None=..., storage_options: StorageOptions=..., dtype_backend: DtypeBackend | lib.NoDefault=..., engine: JSONEngine=...) -> JsonReader[Literal['frame']]:
+    ...
+
+@overload
+def read_json(path_or_buf: FilePath | ReadBuffer[str] | ReadBuffer[bytes], *, orient: str | None=..., typ: Literal['series'], dtype: DtypeArg | None=..., convert_axes: bool | None=..., convert_dates: bool | list[str]=..., keep_default_dates: bool=..., precise_float: bool=..., date_unit: str | None=..., encoding: str | None=..., encoding_errors: str | None=..., lines: bool=..., chunksize: int, compression: CompressionOptions=..., nrows: int | None=..., storage_options: StorageOptions=..., dtype_backend: DtypeBackend | lib.NoDefault=..., engine: JSONEngine=...) -> JsonReader[Literal['series']]:
+    ...
+
+@overload
+def read_json(path_or_buf: FilePath | ReadBuffer[str] | ReadBuffer[bytes], *, orient: str | None=..., typ: Literal['series'], dtype: DtypeArg | None=..., convert_axes: bool | None=..., convert_dates: bool | list[str]=..., keep_default_dates: bool=..., precise_float: bool=..., date_unit: str | None=..., encoding: str | None=..., encoding_errors: str | None=..., lines: bool=..., chunksize: None=..., compression: CompressionOptions=..., nrows: int | None=..., storage_options: StorageOptions=..., dtype_backend: DtypeBackend | lib.NoDefault=..., engine: JSONEngine=...) -> Series:
+    ...
+
+@overload
+def read_json(path_or_buf: FilePath | ReadBuffer[str] | ReadBuffer[bytes], *, orient: str | None=..., typ: Literal['frame']=..., dtype: DtypeArg | None=..., convert_axes: bool | None=..., convert_dates: bool | list[str]=..., keep_default_dates: bool=..., precise_float: bool=..., date_unit: str | None=..., encoding: str | None=..., encoding_errors: str | None=..., lines: bool=..., chunksize: None=..., compression: CompressionOptions=..., nrows: int | None=..., storage_options: StorageOptions=..., dtype_backend: DtypeBackend | lib.NoDefault=..., engine: JSONEngine=...) -> DataFrame:
+    ...
+
+@doc(storage_options=_shared_docs['storage_options'], decompression_options=_shared_docs['decompression_options'] % 'path_or_buf')
+def read_json(path_or_buf: FilePath | ReadBuffer[str] | ReadBuffer[bytes], *, orient: str | None=None, typ: Literal['frame', 'series']='frame', dtype: DtypeArg | None=None, convert_axes: bool | None=None, convert_dates: bool | list[str]=True, keep_default_dates: bool=True, precise_float: bool=False, date_unit: str | None=None, encoding: str | None=None, encoding_errors: str | None='strict', lines: bool=False, chunksize: int | None=None, compression: CompressionOptions='infer', nrows: int | None=None, storage_options: StorageOptions | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, engine: JSONEngine='ujson') -> DataFrame | Series | JsonReader:
+    if orient == 'table' and dtype:
+        raise ValueError("cannot pass both dtype and orient='table'")
+    if orient == 'table' and convert_axes:
+        raise ValueError("cannot pass both convert_axes and orient='table'")
+    check_dtype_backend(dtype_backend)
+    if dtype is None and orient != 'table':
+        dtype = True
+    if convert_axes is None and orient != 'table':
+        convert_axes = True
+    json_reader = JsonReader(path_or_buf, orient=orient, typ=typ, dtype=dtype, convert_axes=convert_axes, convert_dates=convert_dates, keep_default_dates=keep_default_dates, precise_float=precise_float, date_unit=date_unit, encoding=encoding, lines=lines, chunksize=chunksize, compression=compression, nrows=nrows, storage_options=storage_options, encoding_errors=encoding_errors, dtype_backend=dtype_backend, engine=engine)
+    if chunksize:
+        return json_reader
+    else:
+        return json_reader.read()
+
+class JsonReader(abc.Iterator, Generic[FrameSeriesStrT]):
+
+    def __init__(self, filepath_or_buffer, orient, typ: FrameSeriesStrT, dtype, convert_axes: bool | None, convert_dates, keep_default_dates: bool, precise_float: bool, date_unit, encoding, lines: bool, chunksize: int | None, compression: CompressionOptions, nrows: int | None, storage_options: StorageOptions | None=None, encoding_errors: str | None='strict', dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, engine: JSONEngine='ujson') -> None:
+        self.orient = orient
+        self.typ = typ
+        self.dtype = dtype
+        self.convert_axes = convert_axes
+        self.convert_dates = convert_dates
+        self.keep_default_dates = keep_default_dates
+        self.precise_float = precise_float
+        self.date_unit = date_unit
+        self.encoding = encoding
+        self.engine = engine
+        self.compression = compression
+        self.storage_options = storage_options
+        self.lines = lines
+        self.chunksize = chunksize
+        self.nrows_seen = 0
+        self.nrows = nrows
+        self.encoding_errors = encoding_errors
+        self.handles: IOHandles[str] | None = None
+        self.dtype_backend = dtype_backend
+        if self.engine not in {'pyarrow', 'ujson'}:
+            raise ValueError(f'The engine type {self.engine} is currently not supported.')
+        if self.chunksize is not None:
+            self.chunksize = validate_integer('chunksize', self.chunksize, 1)
+            if not self.lines:
+                raise ValueError('chunksize can only be passed if lines=True')
+            if self.engine == 'pyarrow':
+                raise ValueError("currently pyarrow engine doesn't support chunksize parameter")
+        if self.nrows is not None:
+            self.nrows = validate_integer('nrows', self.nrows, 0)
+            if not self.lines:
+                raise ValueError('nrows can only be passed if lines=True')
+        if self.engine == 'pyarrow':
+            if not self.lines:
+                raise ValueError('currently pyarrow engine only supports the line-delimited JSON format')
+            self.data = filepath_or_buffer
+        elif self.engine == 'ujson':
+            data = self._get_data_from_filepath(filepath_or_buffer)
+            if not (self.chunksize or self.nrows):
+                with self:
+                    self.data = data.read()
+            else:
+                self.data = data
+
+    def _get_data_from_filepath(self, filepath_or_buffer):
+        filepath_or_buffer = stringify_path(filepath_or_buffer)
+        try:
+            self.handles = get_handle(filepath_or_buffer, 'r', encoding=self.encoding, compression=self.compression, storage_options=self.storage_options, errors=self.encoding_errors)
+        except OSError as err:
+            raise FileNotFoundError(f'File {filepath_or_buffer} does not exist') from err
+        filepath_or_buffer = self.handles.handle
+        return filepath_or_buffer
+
+    def _combine_lines(self, lines) -> str:
+        return f"[{','.join([line for line in (line.strip() for line in lines) if line])}]"
+
+    @overload
+    def read(self: JsonReader[Literal['frame']]) -> DataFrame:
+        ...
+
+    @overload
+    def read(self: JsonReader[Literal['series']]) -> Series:
+        ...
+
+    @overload
+    def read(self: JsonReader[Literal['frame', 'series']]) -> DataFrame | Series:
+        ...
+
+    def read(self) -> DataFrame | Series:
+        obj: DataFrame | Series
+        with self:
+            if self.engine == 'pyarrow':
+                pyarrow_json = import_optional_dependency('pyarrow.json')
+                pa_table = pyarrow_json.read_json(self.data)
+                mapping: type[ArrowDtype] | None | Callable
+                if self.dtype_backend == 'pyarrow':
+                    mapping = ArrowDtype
+                elif self.dtype_backend == 'numpy_nullable':
+                    from pandas.io._util import _arrow_dtype_mapping
+                    mapping = _arrow_dtype_mapping().get
+                else:
+                    mapping = None
+                return pa_table.to_pandas(types_mapper=mapping)
+            elif self.engine == 'ujson':
+                if self.lines:
+                    if self.chunksize:
+                        obj = concat(self)
+                    elif self.nrows:
+                        lines = list(islice(self.data, self.nrows))
+                        lines_json = self._combine_lines(lines)
+                        obj = self._get_object_parser(lines_json)
+                    else:
+                        data = ensure_str(self.data)
+                        data_lines = data.split('\n')
+                        obj = self._get_object_parser(self._combine_lines(data_lines))
+                else:
+                    obj = self._get_object_parser(self.data)
+                if self.dtype_backend is not lib.no_default:
+                    return obj.convert_dtypes(infer_objects=False, dtype_backend=self.dtype_backend)
+                else:
+                    return obj
+
+    def _get_object_parser(self, json: str) -> DataFrame | Series:
+        typ = self.typ
+        dtype = self.dtype
+        kwargs = {'orient': self.orient, 'dtype': self.dtype, 'convert_axes': self.convert_axes, 'convert_dates': self.convert_dates, 'keep_default_dates': self.keep_default_dates, 'precise_float': self.precise_float, 'date_unit': self.date_unit, 'dtype_backend': self.dtype_backend}
+        if typ == 'frame':
+            return FrameParser(json, **kwargs).parse()
+        elif typ == 'series':
+            if not isinstance(dtype, bool):
+                kwargs['dtype'] = dtype
+            return SeriesParser(json, **kwargs).parse()
+        else:
+            raise ValueError(f"typ={typ!r} must be 'frame' or 'series'.")
+
+    def close(self) -> None:
+        if self.handles is not None:
+            self.handles.close()
+
+    def __iter__(self) -> Self:
+        return self
+
+    @overload
+    def __next__(self: JsonReader[Literal['frame']]) -> DataFrame:
+        ...
+
+    @overload
+    def __next__(self: JsonReader[Literal['series']]) -> Series:
+        ...
+
+    @overload
+    def __next__(self: JsonReader[Literal['frame', 'series']]) -> DataFrame | Series:
+        ...
+
+    def __next__(self) -> DataFrame | Series:
+        if self.nrows and self.nrows_seen >= self.nrows:
+            self.close()
+            raise StopIteration
+        lines = list(islice(self.data, self.chunksize))
+        if not lines:
+            self.close()
+            raise StopIteration
+        try:
+            lines_json = self._combine_lines(lines)
+            obj = self._get_object_parser(lines_json)
+            obj.index = range(self.nrows_seen, self.nrows_seen + len(obj))
+            self.nrows_seen += len(obj)
+        except Exception as ex:
+            self.close()
+            raise ex
+        if self.dtype_backend is not lib.no_default:
+            return obj.convert_dtypes(infer_objects=False, dtype_backend=self.dtype_backend)
+        else:
+            return obj
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
+        self.close()
+
+class Parser:
+    _split_keys: tuple[str, ...]
+    _default_orient: str
+    _STAMP_UNITS = ('s', 'ms', 'us', 'ns')
+    _MIN_STAMPS = {'s': 31536000, 'ms': 31536000000, 'us': 31536000000000, 'ns': 31536000000000000}
+    json: str
+
+    def __init__(self, json: str, orient, dtype: DtypeArg | None=None, convert_axes: bool=True, convert_dates: bool | list[str]=True, keep_default_dates: bool=False, precise_float: bool=False, date_unit=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default) -> None:
+        self.json = json
+        if orient is None:
+            orient = self._default_orient
+        self.orient = orient
+        self.dtype = dtype
+        if date_unit is not None:
+            date_unit = date_unit.lower()
+            if date_unit not in self._STAMP_UNITS:
+                raise ValueError(f'date_unit must be one of {self._STAMP_UNITS}')
+            self.min_stamp = self._MIN_STAMPS[date_unit]
+        else:
+            self.min_stamp = self._MIN_STAMPS['s']
+        self.precise_float = precise_float
+        self.convert_axes = convert_axes
+        self.convert_dates = convert_dates
+        self.date_unit = date_unit
+        self.keep_default_dates = keep_default_dates
+        self.dtype_backend = dtype_backend
+
+    @final
+    def check_keys_split(self, decoded: dict) -> None:
+        bad_keys = set(decoded.keys()).difference(set(self._split_keys))
+        if bad_keys:
+            bad_keys_joined = ', '.join(bad_keys)
+            raise ValueError(f'JSON data had unexpected key(s): {bad_keys_joined}')
+
+    @final
+    def parse(self) -> DataFrame | Series:
+        obj = self._parse()
+        if self.convert_axes:
+            obj = self._convert_axes(obj)
+        obj = self._try_convert_types(obj)
+        return obj
+
+    def _parse(self) -> DataFrame | Series:
+        raise AbstractMethodError(self)
+
+    @final
+    def _convert_axes(self, obj: DataFrame | Series) -> DataFrame | Series:
+        for axis_name in obj._AXIS_ORDERS:
+            ax = obj._get_axis(axis_name)
+            ser = Series(ax, dtype=ax.dtype, copy=False)
+            (new_ser, result) = self._try_convert_data(name=axis_name, data=ser, use_dtypes=False, convert_dates=True, is_axis=True)
+            if result:
+                new_axis = Index(new_ser, dtype=new_ser.dtype, copy=False)
+                setattr(obj, axis_name, new_axis)
+        return obj
+
+    def _try_convert_types(self, obj):
+        raise AbstractMethodError(self)
+
+    @final
+    def _try_convert_data(self, name: Hashable, data: Series, use_dtypes: bool=True, convert_dates: bool | list[str]=True, is_axis: bool=False) -> tuple[Series, bool]:
+        if use_dtypes:
+            if not self.dtype:
+                if all(notna(data)):
+                    return (data, False)
+                filled = data.fillna(np.nan)
+                return (filled, True)
+            elif self.dtype is True:
+                pass
+            elif not _should_convert_dates(convert_dates, self.keep_default_dates, name):
+                dtype = self.dtype.get(name) if isinstance(self.dtype, dict) else self.dtype
+                if dtype is not None:
+                    try:
+                        return (data.astype(dtype), True)
+                    except (TypeError, ValueError):
+                        return (data, False)
+        if convert_dates:
+            new_data = self._try_convert_to_date(data)
+            if new_data is not data:
+                return (new_data, True)
+        converted = False
+        if self.dtype_backend is not lib.no_default and (not is_axis):
+            return (data, True)
+        elif is_string_dtype(data.dtype):
+            try:
+                data = data.astype('float64')
+                converted = True
+            except (TypeError, ValueError):
+                pass
+        if data.dtype.kind == 'f' and data.dtype != 'float64':
+            try:
+                data = data.astype('float64')
+                converted = True
+            except (TypeError, ValueError):
+                pass
+        if len(data) and data.dtype in ('float', 'object'):
+            try:
+                new_data = data.astype('int64')
+                if (new_data == data).all():
+                    data = new_data
+                    converted = True
+            except (TypeError, ValueError, OverflowError):
+                pass
+        if data.dtype == 'int' and data.dtype != 'int64':
+            try:
+                data = data.astype('int64')
+                converted = True
+            except (TypeError, ValueError):
+                pass
+        if name == 'index' and len(data):
+            if self.orient == 'split':
+                return (data, False)
+        return (data, converted)
+
+    @final
+    def _try_convert_to_date(self, data: Series) -> Series:
+        if not len(data):
+            return data
+        new_data = data
+        if new_data.dtype == 'string':
+            new_data = new_data.astype(object)
+        if new_data.dtype == 'object':
+            try:
+                new_data = data.astype('int64')
+            except OverflowError:
+                return data
+            except (TypeError, ValueError):
+                pass
+        if issubclass(new_data.dtype.type, np.number):
+            in_range = isna(new_data._values) | (new_data > self.min_stamp) | (new_data._values == iNaT)
+            if not in_range.all():
+                return data
+        date_units = (self.date_unit,) if self.date_unit else self._STAMP_UNITS
+        for date_unit in date_units:
+            try:
+                return to_datetime(new_data, errors='raise', unit=date_unit)
+            except (ValueError, OverflowError, TypeError):
+                continue
+        return data
+
+class SeriesParser(Parser):
+    _default_orient = 'index'
+    _split_keys = ('name', 'index', 'data')
+
+    def _parse(self) -> Series:
+        data = ujson_loads(self.json, precise_float=self.precise_float)
+        if self.orient == 'split':
+            decoded = {str(k): v for (k, v) in data.items()}
+            self.check_keys_split(decoded)
+            return Series(**decoded)
+        else:
+            return Series(data)
+
+    def _try_convert_types(self, obj: Series) -> Series:
+        (obj, _) = self._try_convert_data('data', obj, convert_dates=self.convert_dates)
+        return obj
+
+class FrameParser(Parser):
+    _default_orient = 'columns'
+    _split_keys = ('columns', 'index', 'data')
+
+    def _parse(self) -> DataFrame:
+        json = self.json
+        orient = self.orient
+        if orient == 'split':
+            decoded = {str(k): v for (k, v) in ujson_loads(json, precise_float=self.precise_float).items()}
+            self.check_keys_split(decoded)
+            orig_names = [tuple(col) if isinstance(col, list) else col for col in decoded['columns']]
+            decoded['columns'] = dedup_names(orig_names, is_potential_multi_index(orig_names, None))
+            return DataFrame(dtype=None, **decoded)
+        elif orient == 'index':
+            return DataFrame.from_dict(ujson_loads(json, precise_float=self.precise_float), dtype=None, orient='index')
+        elif orient == 'table':
+            return parse_table_schema(json, precise_float=self.precise_float)
+        else:
+            return DataFrame(ujson_loads(json, precise_float=self.precise_float), dtype=None)
+
+    def _try_convert_types(self, obj: DataFrame) -> DataFrame:
+        arrays = []
+        for (col_label, series) in obj.items():
+            (result, _) = self._try_convert_data(col_label, series, convert_dates=_should_convert_dates(self.convert_dates, keep_default_dates=self.keep_default_dates, col=col_label))
+            arrays.append(result.array)
+        return DataFrame._from_arrays(arrays, obj.columns, obj.index, verify_integrity=False)
+
+def _should_convert_dates(convert_dates: bool | list[str], keep_default_dates: bool, col: Hashable) -> bool:
+    if convert_dates is False:
+        return False
+    elif not isinstance(convert_dates, bool) and col in set(convert_dates):
+        return True
+    elif not keep_default_dates:
+        return False
+    elif not isinstance(col, str):
+        return False
+    col_lower = col.lower()
+    if col_lower.endswith(('_at', '_time')) or col_lower in {'modified', 'date', 'datetime'} or col_lower.startswith('timestamp'):
+        return True
+    return False
+
+# File: pandas-main/pandas/io/json/_normalize.py
+from __future__ import annotations
+from collections import abc, defaultdict
+import copy
+from typing import TYPE_CHECKING, Any, DefaultDict, overload
+import numpy as np
+from pandas._libs.writers import convert_json_to_lines
+import pandas as pd
+from pandas import DataFrame, Series
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from pandas._typing import IgnoreRaise, Scalar
+
+def convert_to_line_delimits(s: str) -> str:
+    if not s[0] == '[' and s[-1] == ']':
+        return s
+    s = s[1:-1]
+    return convert_json_to_lines(s)
+
+@overload
+def nested_to_record(ds: dict, prefix: str=..., sep: str=..., level: int=..., max_level: int | None=...) -> dict[str, Any]:
+    ...
+
+@overload
+def nested_to_record(ds: list[dict], prefix: str=..., sep: str=..., level: int=..., max_level: int | None=...) -> list[dict[str, Any]]:
+    ...
+
+def nested_to_record(ds: dict | list[dict], prefix: str='', sep: str='.', level: int=0, max_level: int | None=None) -> dict[str, Any] | list[dict[str, Any]]:
+    singleton = False
+    if isinstance(ds, dict):
+        ds = [ds]
+        singleton = True
+    new_ds = []
+    for d in ds:
+        new_d = copy.deepcopy(d)
+        for (k, v) in d.items():
+            if not isinstance(k, str):
+                k = str(k)
+            if level == 0:
+                newkey = k
+            else:
+                newkey = prefix + sep + k
+            if not isinstance(v, dict) or (max_level is not None and level >= max_level):
+                if level != 0:
+                    v = new_d.pop(k)
+                    new_d[newkey] = v
+                continue
+            v = new_d.pop(k)
+            new_d.update(nested_to_record(v, newkey, sep, level + 1, max_level))
+        new_ds.append(new_d)
+    if singleton:
+        return new_ds[0]
+    return new_ds
+
+def _normalise_json(data: Any, key_string: str, normalized_dict: dict[str, Any], separator: str) -> dict[str, Any]:
+    if isinstance(data, dict):
+        for (key, value) in data.items():
+            new_key = f'{key_string}{separator}{key}'
+            if not key_string:
+                new_key = new_key.removeprefix(separator)
+            _normalise_json(data=value, key_string=new_key, normalized_dict=normalized_dict, separator=separator)
+    else:
+        normalized_dict[key_string] = data
+    return normalized_dict
+
+def _normalise_json_ordered(data: dict[str, Any], separator: str) -> dict[str, Any]:
+    top_dict_ = {k: v for (k, v) in data.items() if not isinstance(v, dict)}
+    nested_dict_ = _normalise_json(data={k: v for (k, v) in data.items() if isinstance(v, dict)}, key_string='', normalized_dict={}, separator=separator)
+    return {**top_dict_, **nested_dict_}
+
+def _simple_json_normalize(ds: dict | list[dict], sep: str='.') -> dict | list[dict] | Any:
+    normalised_json_object = {}
+    if isinstance(ds, dict):
+        normalised_json_object = _normalise_json_ordered(data=ds, separator=sep)
+    elif isinstance(ds, list):
+        normalised_json_list = [_simple_json_normalize(row, sep=sep) for row in ds]
+        return normalised_json_list
+    return normalised_json_object
+
+def json_normalize(data: dict | list[dict] | Series, record_path: str | list | None=None, meta: str | list[str | list[str]] | None=None, meta_prefix: str | None=None, record_prefix: str | None=None, errors: IgnoreRaise='raise', sep: str='.', max_level: int | None=None) -> DataFrame:
+
+    def _pull_field(js: dict[str, Any], spec: list | str, extract_record: bool=False) -> Scalar | Iterable:
+        result = js
+        try:
+            if isinstance(spec, list):
+                for field in spec:
+                    if result is None:
+                        raise KeyError(field)
+                    result = result[field]
+            else:
+                result = result[spec]
+        except KeyError as e:
+            if extract_record:
+                raise KeyError(f'Key {e} not found. If specifying a record_path, all elements of data should have the path.') from e
+            if errors == 'ignore':
+                return np.nan
+            else:
+                raise KeyError(f"Key {e} not found. To replace missing values of {e} with np.nan, pass in errors='ignore'") from e
+        return result
+
+    def _pull_records(js: dict[str, Any], spec: list | str) -> list:
+        result = _pull_field(js, spec, extract_record=True)
+        if not isinstance(result, list):
+            if pd.isnull(result):
+                result = []
+            else:
+                raise TypeError(f'Path must contain list or null, but got {type(result).__name__} at {spec!r}')
+        return result
+    if isinstance(data, Series):
+        index = data.index
+    else:
+        index = None
+    if isinstance(data, list) and (not data):
+        return DataFrame()
+    elif isinstance(data, dict):
+        data = [data]
+    elif isinstance(data, abc.Iterable) and (not isinstance(data, str)):
+        data = list(data)
+    else:
+        raise NotImplementedError
+    if record_path is None and meta is None and (meta_prefix is None) and (record_prefix is None) and (max_level is None):
+        return DataFrame(_simple_json_normalize(data, sep=sep), index=index)
+    if record_path is None:
+        if any(([isinstance(x, dict) for x in y.values()] for y in data)):
+            data = nested_to_record(data, sep=sep, max_level=max_level)
+        return DataFrame(data, index=index)
+    elif not isinstance(record_path, list):
+        record_path = [record_path]
+    if meta is None:
+        meta = []
+    elif not isinstance(meta, list):
+        meta = [meta]
+    _meta = [m if isinstance(m, list) else [m] for m in meta]
+    records: list = []
+    lengths = []
+    meta_vals: DefaultDict = defaultdict(list)
+    meta_keys = [sep.join(val) for val in _meta]
+
+    def _recursive_extract(data, path, seen_meta, level: int=0) -> None:
+        if isinstance(data, dict):
+            data = [data]
+        if len(path) > 1:
+            for obj in data:
+                for (val, key) in zip(_meta, meta_keys):
+                    if level + 1 == len(val):
+                        seen_meta[key] = _pull_field(obj, val[-1])
+                _recursive_extract(obj[path[0]], path[1:], seen_meta, level=level + 1)
+        else:
+            for obj in data:
+                recs = _pull_records(obj, path[0])
+                recs = [nested_to_record(r, sep=sep, max_level=max_level) if isinstance(r, dict) else r for r in recs]
+                lengths.append(len(recs))
+                for (val, key) in zip(_meta, meta_keys):
+                    if level + 1 > len(val):
+                        meta_val = seen_meta[key]
+                    else:
+                        meta_val = _pull_field(obj, val[level:])
+                    meta_vals[key].append(meta_val)
+                records.extend(recs)
+    _recursive_extract(data, record_path, {}, level=0)
+    result = DataFrame(records)
+    if record_prefix is not None:
+        result = result.rename(columns=lambda x: f'{record_prefix}{x}')
+    for (k, v) in meta_vals.items():
+        if meta_prefix is not None:
+            k = meta_prefix + k
+        if k in result:
+            raise ValueError(f'Conflicting metadata name {k}, need distinguishing prefix ')
+        values = np.array(v, dtype=object)
+        if values.ndim > 1:
+            values = np.empty((len(v),), dtype=object)
+            for (i, val) in enumerate(v):
+                values[i] = val
+        result[k] = values.repeat(lengths)
+    if index is not None:
+        result.index = index.repeat(lengths)
+    return result
+
+# File: pandas-main/pandas/io/json/_table_schema.py
+""""""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, cast
+import warnings
+from pandas._libs import lib
+from pandas._libs.json import ujson_loads
+from pandas._libs.tslibs import timezones
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.base import _registry as registry
+from pandas.core.dtypes.common import is_bool_dtype, is_integer_dtype, is_numeric_dtype, is_string_dtype
+from pandas.core.dtypes.dtypes import CategoricalDtype, DatetimeTZDtype, ExtensionDtype, PeriodDtype
+from pandas import DataFrame
+import pandas.core.common as com
+from pandas.tseries.frequencies import to_offset
+if TYPE_CHECKING:
+    from pandas._typing import DtypeObj, JSONSerializable
+    from pandas import Series
+    from pandas.core.indexes.multi import MultiIndex
+TABLE_SCHEMA_VERSION = '1.4.0'
+
+def as_json_table_type(x: DtypeObj) -> str:
+    if is_integer_dtype(x):
+        return 'integer'
+    elif is_bool_dtype(x):
+        return 'boolean'
+    elif is_numeric_dtype(x):
+        return 'number'
+    elif lib.is_np_dtype(x, 'M') or isinstance(x, (DatetimeTZDtype, PeriodDtype)):
+        return 'datetime'
+    elif lib.is_np_dtype(x, 'm'):
+        return 'duration'
+    elif isinstance(x, ExtensionDtype):
+        return 'any'
+    elif is_string_dtype(x):
+        return 'string'
+    else:
+        return 'any'
+
+def set_default_names(data):
+    if com.all_not_none(*data.index.names):
+        nms = data.index.names
+        if len(nms) == 1 and data.index.name == 'index':
+            warnings.warn("Index name of 'index' is not round-trippable.", stacklevel=find_stack_level())
+        elif len(nms) > 1 and any((x.startswith('level_') for x in nms)):
+            warnings.warn("Index names beginning with 'level_' are not round-trippable.", stacklevel=find_stack_level())
+        return data
+    data = data.copy(deep=False)
+    if data.index.nlevels > 1:
+        data.index.names = com.fill_missing_names(data.index.names)
+    else:
+        data.index.name = data.index.name or 'index'
+    return data
+
+def convert_pandas_type_to_json_field(arr) -> dict[str, JSONSerializable]:
+    dtype = arr.dtype
+    name: JSONSerializable
+    if arr.name is None:
+        name = 'values'
+    else:
+        name = arr.name
+    field: dict[str, JSONSerializable] = {'name': name, 'type': as_json_table_type(dtype)}
+    if isinstance(dtype, CategoricalDtype):
+        cats = dtype.categories
+        ordered = dtype.ordered
+        field['constraints'] = {'enum': list(cats)}
+        field['ordered'] = ordered
+    elif isinstance(dtype, PeriodDtype):
+        field['freq'] = dtype.freq.freqstr
+    elif isinstance(dtype, DatetimeTZDtype):
+        if timezones.is_utc(dtype.tz):
+            field['tz'] = 'UTC'
+        else:
+            zone = timezones.get_timezone(dtype.tz)
+            if isinstance(zone, str):
+                field['tz'] = zone
+    elif isinstance(dtype, ExtensionDtype):
+        field['extDtype'] = dtype.name
+    return field
+
+def convert_json_field_to_pandas_type(field) -> str | CategoricalDtype:
+    typ = field['type']
+    if typ == 'string':
+        return 'object'
+    elif typ == 'integer':
+        return field.get('extDtype', 'int64')
+    elif typ == 'number':
+        return field.get('extDtype', 'float64')
+    elif typ == 'boolean':
+        return field.get('extDtype', 'bool')
+    elif typ == 'duration':
+        return 'timedelta64'
+    elif typ == 'datetime':
+        if field.get('tz'):
+            return f"datetime64[ns, {field['tz']}]"
+        elif field.get('freq'):
+            offset = to_offset(field['freq'])
+            freq = PeriodDtype(offset)._freqstr
+            return f'period[{freq}]'
+        else:
+            return 'datetime64[ns]'
+    elif typ == 'any':
+        if 'constraints' in field and 'ordered' in field:
+            return CategoricalDtype(categories=field['constraints']['enum'], ordered=field['ordered'])
+        elif 'extDtype' in field:
+            return registry.find(field['extDtype'])
+        else:
+            return 'object'
+    raise ValueError(f'Unsupported or invalid field type: {typ}')
+
+def build_table_schema(data: DataFrame | Series, index: bool=True, primary_key: bool | None=None, version: bool=True) -> dict[str, JSONSerializable]:
+    if index is True:
+        data = set_default_names(data)
+    schema: dict[str, Any] = {}
+    fields = []
+    if index:
+        if data.index.nlevels > 1:
+            data.index = cast('MultiIndex', data.index)
+            for (level, name) in zip(data.index.levels, data.index.names):
+                new_field = convert_pandas_type_to_json_field(level)
+                new_field['name'] = name
+                fields.append(new_field)
+        else:
+            fields.append(convert_pandas_type_to_json_field(data.index))
+    if data.ndim > 1:
+        for (column, s) in data.items():
+            fields.append(convert_pandas_type_to_json_field(s))
+    else:
+        fields.append(convert_pandas_type_to_json_field(data))
+    schema['fields'] = fields
+    if index and data.index.is_unique and (primary_key is None):
+        if data.index.nlevels == 1:
+            schema['primaryKey'] = [data.index.name]
+        else:
+            schema['primaryKey'] = data.index.names
+    elif primary_key is not None:
+        schema['primaryKey'] = primary_key
+    if version:
+        schema['pandas_version'] = TABLE_SCHEMA_VERSION
+    return schema
+
+def parse_table_schema(json, precise_float: bool) -> DataFrame:
+    table = ujson_loads(json, precise_float=precise_float)
+    col_order = [field['name'] for field in table['schema']['fields']]
+    df = DataFrame(table['data'], columns=col_order)[col_order]
+    dtypes = {field['name']: convert_json_field_to_pandas_type(field) for field in table['schema']['fields']}
+    if 'timedelta64' in dtypes.values():
+        raise NotImplementedError('table="orient" can not yet read ISO-formatted Timedelta data')
+    df = df.astype(dtypes)
+    if 'primaryKey' in table['schema']:
+        df = df.set_index(table['schema']['primaryKey'])
+        if len(df.index.names) == 1:
+            if df.index.name == 'index':
+                df.index.name = None
+        else:
+            df.index.names = [None if x.startswith('level_') else x for x in df.index.names]
+    return df
+
+# File: pandas-main/pandas/io/orc.py
+""""""
+from __future__ import annotations
+import io
+from typing import TYPE_CHECKING, Any, Literal
+from pandas._config import using_string_dtype
+from pandas._libs import lib
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._validators import check_dtype_backend
+import pandas as pd
+from pandas.core.indexes.api import default_index
+from pandas.io._util import arrow_string_types_mapper
+from pandas.io.common import get_handle, is_fsspec_url
+if TYPE_CHECKING:
+    import fsspec
+    import pyarrow.fs
+    from pandas._typing import DtypeBackend, FilePath, ReadBuffer, WriteBuffer
+    from pandas.core.frame import DataFrame
+
+def read_orc(path: FilePath | ReadBuffer[bytes], columns: list[str] | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, filesystem: pyarrow.fs.FileSystem | fsspec.spec.AbstractFileSystem | None=None, **kwargs: Any) -> DataFrame:
+    orc = import_optional_dependency('pyarrow.orc')
+    check_dtype_backend(dtype_backend)
+    with get_handle(path, 'rb', is_text=False) as handles:
+        source = handles.handle
+        if is_fsspec_url(path) and filesystem is None:
+            pa = import_optional_dependency('pyarrow')
+            pa_fs = import_optional_dependency('pyarrow.fs')
+            try:
+                (filesystem, source) = pa_fs.FileSystem.from_uri(path)
+            except (TypeError, pa.ArrowInvalid):
+                pass
+        pa_table = orc.read_table(source=source, columns=columns, filesystem=filesystem, **kwargs)
+    if dtype_backend is not lib.no_default:
+        if dtype_backend == 'pyarrow':
+            df = pa_table.to_pandas(types_mapper=pd.ArrowDtype)
+        else:
+            from pandas.io._util import _arrow_dtype_mapping
+            mapping = _arrow_dtype_mapping()
+            df = pa_table.to_pandas(types_mapper=mapping.get)
+        return df
+    else:
+        if using_string_dtype():
+            types_mapper = arrow_string_types_mapper()
+        else:
+            types_mapper = None
+        return pa_table.to_pandas(types_mapper=types_mapper)
+
+def to_orc(df: DataFrame, path: FilePath | WriteBuffer[bytes] | None=None, *, engine: Literal['pyarrow']='pyarrow', index: bool | None=None, engine_kwargs: dict[str, Any] | None=None) -> bytes | None:
+    if index is None:
+        index = df.index.names[0] is not None
+    if engine_kwargs is None:
+        engine_kwargs = {}
+    if not df.index.equals(default_index(len(df))):
+        raise ValueError('orc does not support serializing a non-default index for the index; you can .reset_index() to make the index into column(s)')
+    if df.index.name is not None:
+        raise ValueError('orc does not serialize index meta-data on a default index')
+    if engine != 'pyarrow':
+        raise ValueError("engine must be 'pyarrow'")
+    pyarrow = import_optional_dependency(engine, min_version='10.0.1')
+    pa = import_optional_dependency('pyarrow')
+    orc = import_optional_dependency('pyarrow.orc')
+    was_none = path is None
+    if was_none:
+        path = io.BytesIO()
+    assert path is not None
+    with get_handle(path, 'wb', is_text=False) as handles:
+        try:
+            orc.write_table(pyarrow.Table.from_pandas(df, preserve_index=index), handles.handle, **engine_kwargs)
+        except (TypeError, pa.ArrowNotImplementedError) as e:
+            raise NotImplementedError('The dtype of one or more columns is not supported yet.') from e
+    if was_none:
+        assert isinstance(path, io.BytesIO)
+        return path.getvalue()
+    return None
+
+# File: pandas-main/pandas/io/parquet.py
+""""""
+from __future__ import annotations
+import io
+import json
+import os
+from typing import TYPE_CHECKING, Any, Literal
+from warnings import catch_warnings, filterwarnings
+from pandas._config import using_string_dtype
+from pandas._libs import lib
+from pandas.compat._optional import import_optional_dependency
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import doc
+from pandas.util._validators import check_dtype_backend
+import pandas as pd
+from pandas import DataFrame, get_option
+from pandas.core.shared_docs import _shared_docs
+from pandas.io._util import arrow_string_types_mapper
+from pandas.io.common import IOHandles, get_handle, is_fsspec_url, is_url, stringify_path
+if TYPE_CHECKING:
+    from pandas._typing import DtypeBackend, FilePath, ReadBuffer, StorageOptions, WriteBuffer
+
+def get_engine(engine: str) -> BaseImpl:
+    if engine == 'auto':
+        engine = get_option('io.parquet.engine')
+    if engine == 'auto':
+        engine_classes = [PyArrowImpl, FastParquetImpl]
+        error_msgs = ''
+        for engine_class in engine_classes:
+            try:
+                return engine_class()
+            except ImportError as err:
+                error_msgs += '\n - ' + str(err)
+        raise ImportError(f"Unable to find a usable engine; tried using: 'pyarrow', 'fastparquet'.\nA suitable version of pyarrow or fastparquet is required for parquet support.\nTrying to import the above resulted in these errors:{error_msgs}")
+    if engine == 'pyarrow':
+        return PyArrowImpl()
+    elif engine == 'fastparquet':
+        return FastParquetImpl()
+    raise ValueError("engine must be one of 'pyarrow', 'fastparquet'")
+
+def _get_path_or_handle(path: FilePath | ReadBuffer[bytes] | WriteBuffer[bytes], fs: Any, storage_options: StorageOptions | None=None, mode: str='rb', is_dir: bool=False) -> tuple[FilePath | ReadBuffer[bytes] | WriteBuffer[bytes], IOHandles[bytes] | None, Any]:
+    path_or_handle = stringify_path(path)
+    if fs is not None:
+        pa_fs = import_optional_dependency('pyarrow.fs', errors='ignore')
+        fsspec = import_optional_dependency('fsspec', errors='ignore')
+        if pa_fs is not None and isinstance(fs, pa_fs.FileSystem):
+            if storage_options:
+                raise NotImplementedError('storage_options not supported with a pyarrow FileSystem.')
+        elif fsspec is not None and isinstance(fs, fsspec.spec.AbstractFileSystem):
+            pass
+        else:
+            raise ValueError(f'filesystem must be a pyarrow or fsspec FileSystem, not a {type(fs).__name__}')
+    if is_fsspec_url(path_or_handle) and fs is None:
+        if storage_options is None:
+            pa = import_optional_dependency('pyarrow')
+            pa_fs = import_optional_dependency('pyarrow.fs')
+            try:
+                (fs, path_or_handle) = pa_fs.FileSystem.from_uri(path)
+            except (TypeError, pa.ArrowInvalid):
+                pass
+        if fs is None:
+            fsspec = import_optional_dependency('fsspec')
+            (fs, path_or_handle) = fsspec.core.url_to_fs(path_or_handle, **storage_options or {})
+    elif storage_options and (not is_url(path_or_handle) or mode != 'rb'):
+        raise ValueError('storage_options passed with buffer, or non-supported URL')
+    handles = None
+    if not fs and (not is_dir) and isinstance(path_or_handle, str) and (not os.path.isdir(path_or_handle)):
+        handles = get_handle(path_or_handle, mode, is_text=False, storage_options=storage_options)
+        fs = None
+        path_or_handle = handles.handle
+    return (path_or_handle, handles, fs)
+
+class BaseImpl:
+
+    @staticmethod
+    def validate_dataframe(df: DataFrame) -> None:
+        if not isinstance(df, DataFrame):
+            raise ValueError('to_parquet only supports IO with DataFrames')
+
+    def write(self, df: DataFrame, path, compression, **kwargs) -> None:
+        raise AbstractMethodError(self)
+
+    def read(self, path, columns=None, **kwargs) -> DataFrame:
+        raise AbstractMethodError(self)
+
+class PyArrowImpl(BaseImpl):
+
+    def __init__(self) -> None:
+        import_optional_dependency('pyarrow', extra='pyarrow is required for parquet support.')
+        import pyarrow.parquet
+        import pandas.core.arrays.arrow.extension_types
+        self.api = pyarrow
+
+    def write(self, df: DataFrame, path: FilePath | WriteBuffer[bytes], compression: str | None='snappy', index: bool | None=None, storage_options: StorageOptions | None=None, partition_cols: list[str] | None=None, filesystem=None, **kwargs) -> None:
+        self.validate_dataframe(df)
+        from_pandas_kwargs: dict[str, Any] = {'schema': kwargs.pop('schema', None)}
+        if index is not None:
+            from_pandas_kwargs['preserve_index'] = index
+        table = self.api.Table.from_pandas(df, **from_pandas_kwargs)
+        if df.attrs:
+            df_metadata = {'PANDAS_ATTRS': json.dumps(df.attrs)}
+            existing_metadata = table.schema.metadata
+            merged_metadata = {**existing_metadata, **df_metadata}
+            table = table.replace_schema_metadata(merged_metadata)
+        (path_or_handle, handles, filesystem) = _get_path_or_handle(path, filesystem, storage_options=storage_options, mode='wb', is_dir=partition_cols is not None)
+        if isinstance(path_or_handle, io.BufferedWriter) and hasattr(path_or_handle, 'name') and isinstance(path_or_handle.name, (str, bytes)):
+            if isinstance(path_or_handle.name, bytes):
+                path_or_handle = path_or_handle.name.decode()
+            else:
+                path_or_handle = path_or_handle.name
+        try:
+            if partition_cols is not None:
+                self.api.parquet.write_to_dataset(table, path_or_handle, compression=compression, partition_cols=partition_cols, filesystem=filesystem, **kwargs)
+            else:
+                self.api.parquet.write_table(table, path_or_handle, compression=compression, filesystem=filesystem, **kwargs)
+        finally:
+            if handles is not None:
+                handles.close()
+
+    def read(self, path, columns=None, filters=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, storage_options: StorageOptions | None=None, filesystem=None, **kwargs) -> DataFrame:
+        kwargs['use_pandas_metadata'] = True
+        to_pandas_kwargs = {}
+        if dtype_backend == 'numpy_nullable':
+            from pandas.io._util import _arrow_dtype_mapping
+            mapping = _arrow_dtype_mapping()
+            to_pandas_kwargs['types_mapper'] = mapping.get
+        elif dtype_backend == 'pyarrow':
+            to_pandas_kwargs['types_mapper'] = pd.ArrowDtype
+        elif using_string_dtype():
+            to_pandas_kwargs['types_mapper'] = arrow_string_types_mapper()
+        (path_or_handle, handles, filesystem) = _get_path_or_handle(path, filesystem, storage_options=storage_options, mode='rb')
+        try:
+            pa_table = self.api.parquet.read_table(path_or_handle, columns=columns, filesystem=filesystem, filters=filters, **kwargs)
+            with catch_warnings():
+                filterwarnings('ignore', 'make_block is deprecated', DeprecationWarning)
+                result = pa_table.to_pandas(**to_pandas_kwargs)
+            if pa_table.schema.metadata:
+                if b'PANDAS_ATTRS' in pa_table.schema.metadata:
+                    df_metadata = pa_table.schema.metadata[b'PANDAS_ATTRS']
+                    result.attrs = json.loads(df_metadata)
+            return result
+        finally:
+            if handles is not None:
+                handles.close()
+
+class FastParquetImpl(BaseImpl):
+
+    def __init__(self) -> None:
+        fastparquet = import_optional_dependency('fastparquet', extra='fastparquet is required for parquet support.')
+        self.api = fastparquet
+
+    def write(self, df: DataFrame, path, compression: Literal['snappy', 'gzip', 'brotli'] | None='snappy', index=None, partition_cols=None, storage_options: StorageOptions | None=None, filesystem=None, **kwargs) -> None:
+        self.validate_dataframe(df)
+        if 'partition_on' in kwargs and partition_cols is not None:
+            raise ValueError('Cannot use both partition_on and partition_cols. Use partition_cols for partitioning data')
+        if 'partition_on' in kwargs:
+            partition_cols = kwargs.pop('partition_on')
+        if partition_cols is not None:
+            kwargs['file_scheme'] = 'hive'
+        if filesystem is not None:
+            raise NotImplementedError('filesystem is not implemented for the fastparquet engine.')
+        path = stringify_path(path)
+        if is_fsspec_url(path):
+            fsspec = import_optional_dependency('fsspec')
+            kwargs['open_with'] = lambda path, _: fsspec.open(path, 'wb', **storage_options or {}).open()
+        elif storage_options:
+            raise ValueError('storage_options passed with file object or non-fsspec file path')
+        with catch_warnings(record=True):
+            self.api.write(path, df, compression=compression, write_index=index, partition_on=partition_cols, **kwargs)
+
+    def read(self, path, columns=None, filters=None, storage_options: StorageOptions | None=None, filesystem=None, **kwargs) -> DataFrame:
+        parquet_kwargs: dict[str, Any] = {}
+        dtype_backend = kwargs.pop('dtype_backend', lib.no_default)
+        parquet_kwargs['pandas_nulls'] = False
+        if dtype_backend is not lib.no_default:
+            raise ValueError("The 'dtype_backend' argument is not supported for the fastparquet engine")
+        if filesystem is not None:
+            raise NotImplementedError('filesystem is not implemented for the fastparquet engine.')
+        path = stringify_path(path)
+        handles = None
+        if is_fsspec_url(path):
+            fsspec = import_optional_dependency('fsspec')
+            parquet_kwargs['fs'] = fsspec.open(path, 'rb', **storage_options or {}).fs
+        elif isinstance(path, str) and (not os.path.isdir(path)):
+            handles = get_handle(path, 'rb', is_text=False, storage_options=storage_options)
+            path = handles.handle
+        try:
+            parquet_file = self.api.ParquetFile(path, **parquet_kwargs)
+            with catch_warnings():
+                filterwarnings('ignore', 'make_block is deprecated', DeprecationWarning)
+                return parquet_file.to_pandas(columns=columns, filters=filters, **kwargs)
+        finally:
+            if handles is not None:
+                handles.close()
+
+@doc(storage_options=_shared_docs['storage_options'])
+def to_parquet(df: DataFrame, path: FilePath | WriteBuffer[bytes] | None=None, engine: str='auto', compression: str | None='snappy', index: bool | None=None, storage_options: StorageOptions | None=None, partition_cols: list[str] | None=None, filesystem: Any=None, **kwargs) -> bytes | None:
+    if isinstance(partition_cols, str):
+        partition_cols = [partition_cols]
+    impl = get_engine(engine)
+    path_or_buf: FilePath | WriteBuffer[bytes] = io.BytesIO() if path is None else path
+    impl.write(df, path_or_buf, compression=compression, index=index, partition_cols=partition_cols, storage_options=storage_options, filesystem=filesystem, **kwargs)
+    if path is None:
+        assert isinstance(path_or_buf, io.BytesIO)
+        return path_or_buf.getvalue()
+    else:
+        return None
+
+@doc(storage_options=_shared_docs['storage_options'])
+def read_parquet(path: FilePath | ReadBuffer[bytes], engine: str='auto', columns: list[str] | None=None, storage_options: StorageOptions | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, filesystem: Any=None, filters: list[tuple] | list[list[tuple]] | None=None, **kwargs) -> DataFrame:
+    impl = get_engine(engine)
+    check_dtype_backend(dtype_backend)
+    return impl.read(path, columns=columns, filters=filters, storage_options=storage_options, dtype_backend=dtype_backend, filesystem=filesystem, **kwargs)
+
+# File: pandas-main/pandas/io/parsers/arrow_parser_wrapper.py
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import warnings
+from pandas._config import using_string_dtype
+from pandas._libs import lib
+from pandas.compat._optional import import_optional_dependency
+from pandas.errors import ParserError, ParserWarning
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import pandas_dtype
+from pandas.core.dtypes.inference import is_integer
+import pandas as pd
+from pandas import DataFrame
+from pandas.io._util import _arrow_dtype_mapping, arrow_string_types_mapper
+from pandas.io.parsers.base_parser import ParserBase
+if TYPE_CHECKING:
+    from pandas._typing import ReadBuffer
+
+class ArrowParserWrapper(ParserBase):
+
+    def __init__(self, src: ReadBuffer[bytes], **kwds) -> None:
+        super().__init__(kwds)
+        self.kwds = kwds
+        self.src = src
+        self._parse_kwds()
+
+    def _parse_kwds(self) -> None:
+        encoding: str | None = self.kwds.get('encoding')
+        self.encoding = 'utf-8' if encoding is None else encoding
+        na_values = self.kwds['na_values']
+        if isinstance(na_values, dict):
+            raise ValueError("The pyarrow engine doesn't support passing a dict for na_values")
+        self.na_values = list(self.kwds['na_values'])
+
+    def _get_pyarrow_options(self) -> None:
+        mapping = {'usecols': 'include_columns', 'na_values': 'null_values', 'escapechar': 'escape_char', 'skip_blank_lines': 'ignore_empty_lines', 'decimal': 'decimal_point', 'quotechar': 'quote_char'}
+        for (pandas_name, pyarrow_name) in mapping.items():
+            if pandas_name in self.kwds and self.kwds.get(pandas_name) is not None:
+                self.kwds[pyarrow_name] = self.kwds.pop(pandas_name)
+        date_format = self.date_format
+        if isinstance(date_format, str):
+            date_format = [date_format]
+        else:
+            date_format = None
+        self.kwds['timestamp_parsers'] = date_format
+        self.parse_options = {option_name: option_value for (option_name, option_value) in self.kwds.items() if option_value is not None and option_name in ('delimiter', 'quote_char', 'escape_char', 'ignore_empty_lines')}
+        on_bad_lines = self.kwds.get('on_bad_lines')
+        if on_bad_lines is not None:
+            if callable(on_bad_lines):
+                self.parse_options['invalid_row_handler'] = on_bad_lines
+            elif on_bad_lines == ParserBase.BadLineHandleMethod.ERROR:
+                self.parse_options['invalid_row_handler'] = None
+            elif on_bad_lines == ParserBase.BadLineHandleMethod.WARN:
+
+                def handle_warning(invalid_row) -> str:
+                    warnings.warn(f'Expected {invalid_row.expected_columns} columns, but found {invalid_row.actual_columns}: {invalid_row.text}', ParserWarning, stacklevel=find_stack_level())
+                    return 'skip'
+                self.parse_options['invalid_row_handler'] = handle_warning
+            elif on_bad_lines == ParserBase.BadLineHandleMethod.SKIP:
+                self.parse_options['invalid_row_handler'] = lambda _: 'skip'
+        self.convert_options = {option_name: option_value for (option_name, option_value) in self.kwds.items() if option_value is not None and option_name in ('include_columns', 'null_values', 'true_values', 'false_values', 'decimal_point', 'timestamp_parsers')}
+        self.convert_options['strings_can_be_null'] = '' in self.kwds['null_values']
+        if self.header is None and 'include_columns' in self.convert_options:
+            self.convert_options['include_columns'] = [f'f{n}' for n in self.convert_options['include_columns']]
+        self.read_options = {'autogenerate_column_names': self.header is None, 'skip_rows': self.header if self.header is not None else self.kwds['skiprows'], 'encoding': self.encoding}
+
+    def _finalize_pandas_output(self, frame: DataFrame) -> DataFrame:
+        num_cols = len(frame.columns)
+        multi_index_named = True
+        if self.header is None:
+            if self.names is None:
+                if self.header is None:
+                    self.names = range(num_cols)
+            if len(self.names) != num_cols:
+                self.names = list(range(num_cols - len(self.names))) + self.names
+                multi_index_named = False
+            frame.columns = self.names
+        frame = self._do_date_conversions(frame.columns, frame)
+        if self.index_col is not None:
+            index_to_set = self.index_col.copy()
+            for (i, item) in enumerate(self.index_col):
+                if is_integer(item):
+                    index_to_set[i] = frame.columns[item]
+                elif item not in frame.columns:
+                    raise ValueError(f'Index {item} invalid')
+                if self.dtype is not None:
+                    (key, new_dtype) = (item, self.dtype.get(item)) if self.dtype.get(item) is not None else (frame.columns[item], self.dtype.get(frame.columns[item]))
+                    if new_dtype is not None:
+                        frame[key] = frame[key].astype(new_dtype)
+                        del self.dtype[key]
+            frame.set_index(index_to_set, drop=True, inplace=True)
+            if self.header is None and (not multi_index_named):
+                frame.index.names = [None] * len(frame.index.names)
+        if self.dtype is not None:
+            if isinstance(self.dtype, dict):
+                self.dtype = {k: pandas_dtype(v) for (k, v) in self.dtype.items() if k in frame.columns}
+            else:
+                self.dtype = pandas_dtype(self.dtype)
+            try:
+                frame = frame.astype(self.dtype)
+            except TypeError as err:
+                raise ValueError(str(err)) from err
+        return frame
+
+    def _validate_usecols(self, usecols) -> None:
+        if lib.is_list_like(usecols) and (not all((isinstance(x, str) for x in usecols))):
+            raise ValueError("The pyarrow engine does not allow 'usecols' to be integer column positions. Pass a list of string column names instead.")
+        elif callable(usecols):
+            raise ValueError("The pyarrow engine does not allow 'usecols' to be a callable.")
+
+    def read(self) -> DataFrame:
+        pa = import_optional_dependency('pyarrow')
+        pyarrow_csv = import_optional_dependency('pyarrow.csv')
+        self._get_pyarrow_options()
+        try:
+            convert_options = pyarrow_csv.ConvertOptions(**self.convert_options)
+        except TypeError as err:
+            include = self.convert_options.get('include_columns', None)
+            if include is not None:
+                self._validate_usecols(include)
+            nulls = self.convert_options.get('null_values', set())
+            if not lib.is_list_like(nulls) or not all((isinstance(x, str) for x in nulls)):
+                raise TypeError("The 'pyarrow' engine requires all na_values to be strings") from err
+            raise
+        try:
+            table = pyarrow_csv.read_csv(self.src, read_options=pyarrow_csv.ReadOptions(**self.read_options), parse_options=pyarrow_csv.ParseOptions(**self.parse_options), convert_options=convert_options)
+        except pa.ArrowInvalid as e:
+            raise ParserError(e) from e
+        dtype_backend = self.kwds['dtype_backend']
+        if dtype_backend is lib.no_default:
+            new_schema = table.schema
+            new_type = pa.float64()
+            for (i, arrow_type) in enumerate(table.schema.types):
+                if pa.types.is_null(arrow_type):
+                    new_schema = new_schema.set(i, new_schema.field(i).with_type(new_type))
+            table = table.cast(new_schema)
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', 'make_block is deprecated', DeprecationWarning)
+            if dtype_backend == 'pyarrow':
+                frame = table.to_pandas(types_mapper=pd.ArrowDtype)
+            elif dtype_backend == 'numpy_nullable':
+                dtype_mapping = _arrow_dtype_mapping()
+                dtype_mapping[pa.null()] = pd.Int64Dtype()
+                frame = table.to_pandas(types_mapper=dtype_mapping.get)
+            elif using_string_dtype():
+                frame = table.to_pandas(types_mapper=arrow_string_types_mapper())
+            else:
+                frame = table.to_pandas()
+        return self._finalize_pandas_output(frame)
+
+# File: pandas-main/pandas/io/parsers/base_parser.py
+from __future__ import annotations
+from collections import defaultdict
+from copy import copy
+import csv
+from enum import Enum
+import itertools
+from typing import TYPE_CHECKING, Any, cast, final, overload
+import warnings
+import numpy as np
+from pandas._libs import lib, parsers
+import pandas._libs.ops as libops
+from pandas._libs.parsers import STR_NA_VALUES
+from pandas.compat._optional import import_optional_dependency
+from pandas.errors import ParserError, ParserWarning
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import is_bool_dtype, is_dict_like, is_float_dtype, is_integer, is_integer_dtype, is_list_like, is_object_dtype, is_string_dtype
+from pandas.core.dtypes.missing import isna
+from pandas import DataFrame, DatetimeIndex, StringDtype
+from pandas.core import algorithms
+from pandas.core.arrays import ArrowExtensionArray, BaseMaskedArray, BooleanArray, FloatingArray, IntegerArray
+from pandas.core.indexes.api import Index, MultiIndex, default_index, ensure_index_from_sequences
+from pandas.core.series import Series
+from pandas.core.tools import datetimes as tools
+from pandas.io.common import is_potential_multi_index
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Mapping, Sequence
+    from pandas._typing import ArrayLike, DtypeArg, Hashable, HashableT, Scalar, SequenceT
+
+class ParserBase:
+
+    class BadLineHandleMethod(Enum):
+        ERROR = 0
+        WARN = 1
+        SKIP = 2
+    _implicit_index: bool
+    _first_chunk: bool
+    keep_default_na: bool
+    dayfirst: bool
+    cache_dates: bool
+    usecols_dtype: str | None
+
+    def __init__(self, kwds) -> None:
+        self._implicit_index = False
+        self.names = kwds.get('names')
+        self.orig_names: Sequence[Hashable] | None = None
+        self.index_col = kwds.get('index_col', None)
+        self.unnamed_cols: set = set()
+        self.index_names: Sequence[Hashable] | None = None
+        self.col_names: Sequence[Hashable] | None = None
+        parse_dates = kwds.pop('parse_dates', False)
+        if parse_dates is None or lib.is_bool(parse_dates):
+            parse_dates = bool(parse_dates)
+        elif not isinstance(parse_dates, list):
+            raise TypeError("Only booleans and lists are accepted for the 'parse_dates' parameter")
+        self.parse_dates: bool | list = parse_dates
+        self.date_parser = kwds.pop('date_parser', lib.no_default)
+        self.date_format = kwds.pop('date_format', None)
+        self.dayfirst = kwds.pop('dayfirst', False)
+        self.na_values = kwds.get('na_values')
+        self.na_fvalues = kwds.get('na_fvalues')
+        self.na_filter = kwds.get('na_filter', False)
+        self.keep_default_na = kwds.get('keep_default_na', True)
+        self.dtype = copy(kwds.get('dtype', None))
+        self.converters = kwds.get('converters')
+        self.dtype_backend = kwds.get('dtype_backend')
+        self.true_values = kwds.get('true_values')
+        self.false_values = kwds.get('false_values')
+        self.cache_dates = kwds.pop('cache_dates', True)
+        self.header = kwds.get('header')
+        if is_list_like(self.header, allow_sets=False):
+            if kwds.get('usecols'):
+                raise ValueError('cannot specify usecols when specifying a multi-index header')
+            if kwds.get('names'):
+                raise ValueError('cannot specify names when specifying a multi-index header')
+            if self.index_col is not None:
+                if is_integer(self.index_col):
+                    self.index_col = [self.index_col]
+                elif not (is_list_like(self.index_col, allow_sets=False) and all(map(is_integer, self.index_col))):
+                    raise ValueError('index_col must only contain integers of column positions when specifying a multi-index header')
+                else:
+                    self.index_col = list(self.index_col)
+        self._first_chunk = True
+        (self.usecols, self.usecols_dtype) = _validate_usecols_arg(kwds['usecols'])
+        self.on_bad_lines = kwds.get('on_bad_lines', self.BadLineHandleMethod.ERROR)
+
+    def close(self) -> None:
+        pass
+
+    @final
+    def _should_parse_dates(self, i: int) -> bool:
+        if isinstance(self.parse_dates, bool):
+            return self.parse_dates
+        else:
+            if self.index_names is not None:
+                name = self.index_names[i]
+            else:
+                name = None
+            j = i if self.index_col is None else self.index_col[i]
+            return j in self.parse_dates or (name is not None and name in self.parse_dates)
+
+    @final
+    def _extract_multi_indexer_columns(self, header, index_names: Sequence[Hashable] | None, passed_names: bool=False) -> tuple[Sequence[Hashable], Sequence[Hashable] | None, Sequence[Hashable] | None, bool]:
+        if len(header) < 2:
+            return (header[0], index_names, None, passed_names)
+        ic = self.index_col
+        if ic is None:
+            ic = []
+        if not isinstance(ic, (list, tuple, np.ndarray)):
+            ic = [ic]
+        sic = set(ic)
+        index_names = header.pop(-1)
+        (index_names, _, _) = self._clean_index_names(index_names, self.index_col)
+        field_count = len(header[0])
+        if not all((len(header_iter) == field_count for header_iter in header[1:])):
+            raise ParserError('Header rows must have an equal number of columns.')
+
+        def extract(r):
+            return tuple((r[i] for i in range(field_count) if i not in sic))
+        columns = list(zip(*(extract(r) for r in header)))
+        names = columns.copy()
+        for single_ic in sorted(ic):
+            names.insert(single_ic, single_ic)
+        if len(ic):
+            col_names = [r[ic[0]] if r[ic[0]] is not None and r[ic[0]] not in self.unnamed_cols else None for r in header]
+        else:
+            col_names = [None] * len(header)
+        passed_names = True
+        return (names, index_names, col_names, passed_names)
+
+    @final
+    def _maybe_make_multi_index_columns(self, columns: SequenceT, col_names: Sequence[Hashable] | None=None) -> SequenceT | MultiIndex:
+        if is_potential_multi_index(columns):
+            columns_mi = cast('Sequence[tuple[Hashable, ...]]', columns)
+            return MultiIndex.from_tuples(columns_mi, names=col_names)
+        return columns
+
+    @final
+    def _make_index(self, alldata, columns, indexnamerow: list[Scalar] | None=None) -> tuple[Index | None, Sequence[Hashable] | MultiIndex]:
+        index: Index | None
+        if isinstance(self.index_col, list) and len(self.index_col):
+            to_remove = []
+            indexes = []
+            for idx in self.index_col:
+                if isinstance(idx, str):
+                    raise ValueError(f'Index {idx} invalid')
+                to_remove.append(idx)
+                indexes.append(alldata[idx])
+            for i in sorted(to_remove, reverse=True):
+                alldata.pop(i)
+                if not self._implicit_index:
+                    columns.pop(i)
+            index = self._agg_index(indexes)
+            if indexnamerow:
+                coffset = len(indexnamerow) - len(columns)
+                index = index.set_names(indexnamerow[:coffset])
+        else:
+            index = None
+        columns = self._maybe_make_multi_index_columns(columns, self.col_names)
+        return (index, columns)
+
+    @final
+    def _clean_mapping(self, mapping):
+        if not isinstance(mapping, dict):
+            return mapping
+        clean = {}
+        assert self.orig_names is not None
+        for (col, v) in mapping.items():
+            if isinstance(col, int) and col not in self.orig_names:
+                col = self.orig_names[col]
+            clean[col] = v
+        if isinstance(mapping, defaultdict):
+            remaining_cols = set(self.orig_names) - set(clean.keys())
+            clean.update({col: mapping[col] for col in remaining_cols})
+        return clean
+
+    @final
+    def _agg_index(self, index) -> Index:
+        arrays = []
+        converters = self._clean_mapping(self.converters)
+        clean_dtypes = self._clean_mapping(self.dtype)
+        if self.index_names is not None:
+            names: Iterable = self.index_names
+        else:
+            names = itertools.cycle([None])
+        for (i, (arr, name)) in enumerate(zip(index, names)):
+            if self._should_parse_dates(i):
+                arr = date_converter(arr, col=self.index_names[i] if self.index_names is not None else None, dayfirst=self.dayfirst, cache_dates=self.cache_dates, date_format=self.date_format)
+            if self.na_filter:
+                col_na_values = self.na_values
+                col_na_fvalues = self.na_fvalues
+            else:
+                col_na_values = set()
+                col_na_fvalues = set()
+            if isinstance(self.na_values, dict):
+                assert self.index_names is not None
+                col_name = self.index_names[i]
+                if col_name is not None:
+                    (col_na_values, col_na_fvalues) = get_na_values(col_name, self.na_values, self.na_fvalues, self.keep_default_na)
+                else:
+                    (col_na_values, col_na_fvalues) = (set(), set())
+            cast_type = None
+            index_converter = False
+            if self.index_names is not None:
+                if isinstance(clean_dtypes, dict):
+                    cast_type = clean_dtypes.get(self.index_names[i], None)
+                if isinstance(converters, dict):
+                    index_converter = converters.get(self.index_names[i]) is not None
+            try_num_bool = not (cast_type and is_string_dtype(cast_type) or index_converter)
+            (arr, _) = self._infer_types(arr, col_na_values | col_na_fvalues, cast_type is None, try_num_bool)
+            if cast_type is not None:
+                idx = Index(arr, name=name, dtype=cast_type)
+            else:
+                idx = ensure_index_from_sequences([arr], [name])
+            arrays.append(idx)
+        if len(arrays) == 1:
+            return arrays[0]
+        else:
+            return MultiIndex.from_arrays(arrays)
+
+    @final
+    def _set_noconvert_dtype_columns(self, col_indices: list[int], names: Sequence[Hashable]) -> set[int]:
+        usecols: list[int] | list[str] | None
+        noconvert_columns = set()
+        if self.usecols_dtype == 'integer':
+            usecols = sorted(self.usecols)
+        elif callable(self.usecols) or self.usecols_dtype not in ('empty', None):
+            usecols = col_indices
+        else:
+            usecols = None
+
+        def _set(x) -> int:
+            if usecols is not None and is_integer(x):
+                x = usecols[x]
+            if not is_integer(x):
+                x = col_indices[names.index(x)]
+            return x
+        if isinstance(self.parse_dates, list):
+            validate_parse_dates_presence(self.parse_dates, names)
+            for val in self.parse_dates:
+                noconvert_columns.add(_set(val))
+        elif self.parse_dates:
+            if isinstance(self.index_col, list):
+                for k in self.index_col:
+                    noconvert_columns.add(_set(k))
+            elif self.index_col is not None:
+                noconvert_columns.add(_set(self.index_col))
+        return noconvert_columns
+
+    @final
+    def _infer_types(self, values, na_values, no_dtype_specified, try_num_bool: bool=True) -> tuple[ArrayLike, int]:
+        na_count = 0
+        if issubclass(values.dtype.type, (np.number, np.bool_)):
+            na_values = np.array([val for val in na_values if not isinstance(val, str)])
+            mask = algorithms.isin(values, na_values)
+            na_count = mask.astype('uint8', copy=False).sum()
+            if na_count > 0:
+                if is_integer_dtype(values):
+                    values = values.astype(np.float64)
+                np.putmask(values, mask, np.nan)
+            return (values, na_count)
+        dtype_backend = self.dtype_backend
+        non_default_dtype_backend = no_dtype_specified and dtype_backend is not lib.no_default
+        result: ArrayLike
+        if try_num_bool and is_object_dtype(values.dtype):
+            try:
+                (result, result_mask) = lib.maybe_convert_numeric(values, na_values, False, convert_to_masked_nullable=non_default_dtype_backend)
+            except (ValueError, TypeError):
+                na_count = parsers.sanitize_objects(values, na_values)
+                result = values
+            else:
+                if non_default_dtype_backend:
+                    if result_mask is None:
+                        result_mask = np.zeros(result.shape, dtype=np.bool_)
+                    if result_mask.all():
+                        result = IntegerArray(np.ones(result_mask.shape, dtype=np.int64), result_mask)
+                    elif is_integer_dtype(result):
+                        result = IntegerArray(result, result_mask)
+                    elif is_bool_dtype(result):
+                        result = BooleanArray(result, result_mask)
+                    elif is_float_dtype(result):
+                        result = FloatingArray(result, result_mask)
+                    na_count = result_mask.sum()
+                else:
+                    na_count = isna(result).sum()
+        else:
+            result = values
+            if values.dtype == np.object_:
+                na_count = parsers.sanitize_objects(values, na_values)
+        if result.dtype == np.object_ and try_num_bool:
+            (result, bool_mask) = libops.maybe_convert_bool(np.asarray(values), true_values=self.true_values, false_values=self.false_values, convert_to_masked_nullable=non_default_dtype_backend)
+            if result.dtype == np.bool_ and non_default_dtype_backend:
+                if bool_mask is None:
+                    bool_mask = np.zeros(result.shape, dtype=np.bool_)
+                result = BooleanArray(result, bool_mask)
+            elif result.dtype == np.object_ and non_default_dtype_backend:
+                if not lib.is_datetime_array(result, skipna=True):
+                    dtype = StringDtype()
+                    cls = dtype.construct_array_type()
+                    result = cls._from_sequence(values, dtype=dtype)
+        if dtype_backend == 'pyarrow':
+            pa = import_optional_dependency('pyarrow')
+            if isinstance(result, np.ndarray):
+                result = ArrowExtensionArray(pa.array(result, from_pandas=True))
+            elif isinstance(result, BaseMaskedArray):
+                if result._mask.all():
+                    result = ArrowExtensionArray(pa.array([None] * len(result)))
+                else:
+                    result = ArrowExtensionArray(pa.array(result._data, mask=result._mask))
+            else:
+                result = ArrowExtensionArray(pa.array(result.to_numpy(), from_pandas=True))
+        return (result, na_count)
+
+    @overload
+    def _do_date_conversions(self, names: Index, data: DataFrame) -> DataFrame:
+        ...
+
+    @overload
+    def _do_date_conversions(self, names: Sequence[Hashable], data: Mapping[Hashable, ArrayLike]) -> Mapping[Hashable, ArrayLike]:
+        ...
+
+    @final
+    def _do_date_conversions(self, names: Sequence[Hashable] | Index, data: Mapping[Hashable, ArrayLike] | DataFrame) -> Mapping[Hashable, ArrayLike] | DataFrame:
+        if not isinstance(self.parse_dates, list):
+            return data
+        for colspec in self.parse_dates:
+            if isinstance(colspec, int) and colspec not in data:
+                colspec = names[colspec]
+            if isinstance(self.index_col, list) and colspec in self.index_col or (isinstance(self.index_names, list) and colspec in self.index_names):
+                continue
+            result = date_converter(data[colspec], col=colspec, dayfirst=self.dayfirst, cache_dates=self.cache_dates, date_format=self.date_format)
+            data[colspec] = result
+        return data
+
+    @final
+    def _check_data_length(self, columns: Sequence[Hashable], data: Sequence[ArrayLike]) -> None:
+        if not self.index_col and len(columns) != len(data) and columns:
+            empty_str = is_object_dtype(data[-1]) and data[-1] == ''
+            empty_str_or_na = empty_str | isna(data[-1])
+            if len(columns) == len(data) - 1 and np.all(empty_str_or_na):
+                return
+            warnings.warn('Length of header or names does not match length of data. This leads to a loss of data with index_col=False.', ParserWarning, stacklevel=find_stack_level())
+
+    @final
+    def _validate_usecols_names(self, usecols: SequenceT, names: Sequence) -> SequenceT:
+        missing = [c for c in usecols if c not in names]
+        if len(missing) > 0:
+            raise ValueError(f'Usecols do not match columns, columns expected but not found: {missing}')
+        return usecols
+
+    @final
+    def _clean_index_names(self, columns, index_col) -> tuple[list | None, list, list]:
+        if not is_index_col(index_col):
+            return (None, columns, index_col)
+        columns = list(columns)
+        if not columns:
+            return ([None] * len(index_col), columns, index_col)
+        cp_cols = list(columns)
+        index_names: list[str | int | None] = []
+        index_col = list(index_col)
+        for (i, c) in enumerate(index_col):
+            if isinstance(c, str):
+                index_names.append(c)
+                for (j, name) in enumerate(cp_cols):
+                    if name == c:
+                        index_col[i] = j
+                        columns.remove(name)
+                        break
+            else:
+                name = cp_cols[c]
+                columns.remove(name)
+                index_names.append(name)
+        for (i, name) in enumerate(index_names):
+            if isinstance(name, str) and name in self.unnamed_cols:
+                index_names[i] = None
+        return (index_names, columns, index_col)
+
+    @final
+    def _get_empty_meta(self, columns: Sequence[HashableT], dtype: DtypeArg | None=None) -> tuple[Index, list[HashableT], dict[HashableT, Series]]:
+        columns = list(columns)
+        index_col = self.index_col
+        index_names = self.index_names
+        dtype_dict: defaultdict[Hashable, Any]
+        if not is_dict_like(dtype):
+            dtype_dict = defaultdict(lambda : dtype)
+        else:
+            dtype = cast(dict, dtype)
+            dtype_dict = defaultdict(lambda : None, {columns[k] if is_integer(k) else k: v for (k, v) in dtype.items()})
+        index: Index
+        if (index_col is None or index_col is False) or index_names is None:
+            index = default_index(0)
+        else:
+            data = [Index([], name=name, dtype=dtype_dict[name]) for name in index_names]
+            if len(data) == 1:
+                index = data[0]
+            else:
+                index = MultiIndex.from_arrays(data)
+            index_col.sort()
+            for (i, n) in enumerate(index_col):
+                columns.pop(n - i)
+        col_dict = {col_name: Series([], dtype=dtype_dict[col_name]) for col_name in columns}
+        return (index, columns, col_dict)
+
+def date_converter(date_col, col: Hashable, dayfirst: bool=False, cache_dates: bool=True, date_format: dict[Hashable, str] | str | None=None):
+    if date_col.dtype.kind in 'Mm':
+        return date_col
+    date_fmt = date_format.get(col) if isinstance(date_format, dict) else date_format
+    str_objs = lib.ensure_string_array(np.asarray(date_col))
+    try:
+        result = tools.to_datetime(str_objs, format=date_fmt, utc=False, dayfirst=dayfirst, cache=cache_dates)
+    except (ValueError, TypeError):
+        return str_objs
+    if isinstance(result, DatetimeIndex):
+        arr = result.to_numpy()
+        arr.flags.writeable = True
+        return arr
+    return result._values
+parser_defaults = {'delimiter': None, 'escapechar': None, 'quotechar': '"', 'quoting': csv.QUOTE_MINIMAL, 'doublequote': True, 'skipinitialspace': False, 'lineterminator': None, 'header': 'infer', 'index_col': None, 'names': None, 'skiprows': None, 'skipfooter': 0, 'nrows': None, 'na_values': None, 'keep_default_na': True, 'true_values': None, 'false_values': None, 'converters': None, 'dtype': None, 'cache_dates': True, 'thousands': None, 'comment': None, 'decimal': '.', 'parse_dates': False, 'dayfirst': False, 'date_format': None, 'usecols': None, 'chunksize': None, 'encoding': None, 'compression': None, 'skip_blank_lines': True, 'encoding_errors': 'strict', 'on_bad_lines': ParserBase.BadLineHandleMethod.ERROR, 'dtype_backend': lib.no_default}
+
+def get_na_values(col, na_values, na_fvalues, keep_default_na: bool):
+    if isinstance(na_values, dict):
+        if col in na_values:
+            return (na_values[col], na_fvalues[col])
+        else:
+            if keep_default_na:
+                return (STR_NA_VALUES, set())
+            return (set(), set())
+    else:
+        return (na_values, na_fvalues)
+
+def is_index_col(col) -> bool:
+    return col is not None and col is not False
+
+def validate_parse_dates_presence(parse_dates: bool | list, columns: Sequence[Hashable]) -> set:
+    if not isinstance(parse_dates, list):
+        return set()
+    missing = set()
+    unique_cols = set()
+    for col in parse_dates:
+        if isinstance(col, str):
+            if col not in columns:
+                missing.add(col)
+            else:
+                unique_cols.add(col)
+        elif col in columns:
+            unique_cols.add(col)
+        else:
+            unique_cols.add(columns[col])
+    if missing:
+        missing_cols = ', '.join(sorted(missing))
+        raise ValueError(f"Missing column provided to 'parse_dates': '{missing_cols}'")
+    return unique_cols
+
+def _validate_usecols_arg(usecols):
+    msg = "'usecols' must either be list-like of all strings, all unicode, all integers or a callable."
+    if usecols is not None:
+        if callable(usecols):
+            return (usecols, None)
+        if not is_list_like(usecols):
+            raise ValueError(msg)
+        usecols_dtype = lib.infer_dtype(usecols, skipna=False)
+        if usecols_dtype not in ('empty', 'integer', 'string'):
+            raise ValueError(msg)
+        usecols = set(usecols)
+        return (usecols, usecols_dtype)
+    return (usecols, None)
+
+@overload
+def evaluate_callable_usecols(usecols: Callable[[Hashable], object], names: Iterable[Hashable]) -> set[int]:
+    ...
+
+@overload
+def evaluate_callable_usecols(usecols: SequenceT, names: Iterable[Hashable]) -> SequenceT:
+    ...
+
+def evaluate_callable_usecols(usecols: Callable[[Hashable], object] | SequenceT, names: Iterable[Hashable]) -> SequenceT | set[int]:
+    if callable(usecols):
+        return {i for (i, name) in enumerate(names) if usecols(name)}
+    return usecols
+
+# File: pandas-main/pandas/io/parsers/c_parser_wrapper.py
+from __future__ import annotations
+from collections import defaultdict
+from typing import TYPE_CHECKING
+import warnings
+import numpy as np
+from pandas._libs import lib, parsers
+from pandas.compat._optional import import_optional_dependency
+from pandas.errors import DtypeWarning
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import pandas_dtype
+from pandas.core.dtypes.concat import concat_compat, union_categoricals
+from pandas.core.dtypes.dtypes import CategoricalDtype
+from pandas.core.indexes.api import ensure_index_from_sequences
+from pandas.io.common import dedup_names, is_potential_multi_index
+from pandas.io.parsers.base_parser import ParserBase, ParserError, date_converter, evaluate_callable_usecols, is_index_col, validate_parse_dates_presence
+if TYPE_CHECKING:
+    from collections.abc import Hashable, Mapping, Sequence
+    from pandas._typing import AnyArrayLike, ArrayLike, DtypeArg, DtypeObj, ReadCsvBuffer, SequenceT
+    from pandas import Index, MultiIndex
+
+class CParserWrapper(ParserBase):
+    low_memory: bool
+    _reader: parsers.TextReader
+
+    def __init__(self, src: ReadCsvBuffer[str], **kwds) -> None:
+        super().__init__(kwds)
+        self.kwds = kwds
+        kwds = kwds.copy()
+        self.low_memory = kwds.pop('low_memory', False)
+        kwds['allow_leading_cols'] = self.index_col is not False
+        kwds['usecols'] = self.usecols
+        kwds['on_bad_lines'] = self.on_bad_lines.value
+        for key in ('storage_options', 'encoding', 'memory_map', 'compression'):
+            kwds.pop(key, None)
+        kwds['dtype'] = ensure_dtype_objs(kwds.get('dtype', None))
+        if 'dtype_backend' not in kwds or kwds['dtype_backend'] is lib.no_default:
+            kwds['dtype_backend'] = 'numpy'
+        if kwds['dtype_backend'] == 'pyarrow':
+            import_optional_dependency('pyarrow')
+        self._reader = parsers.TextReader(src, **kwds)
+        self.unnamed_cols = self._reader.unnamed_cols
+        passed_names = self.names is None
+        if self._reader.header is None:
+            self.names = None
+        else:
+            (self.names, self.index_names, self.col_names, passed_names) = self._extract_multi_indexer_columns(self._reader.header, self.index_names, passed_names)
+        if self.names is None:
+            self.names = list(range(self._reader.table_width))
+        self.orig_names = self.names[:]
+        if self.usecols:
+            usecols = evaluate_callable_usecols(self.usecols, self.orig_names)
+            assert self.orig_names is not None
+            if self.usecols_dtype == 'string' and (not set(usecols).issubset(self.orig_names)):
+                self._validate_usecols_names(usecols, self.orig_names)
+            if len(self.names) > len(usecols):
+                self.names = [n for (i, n) in enumerate(self.names) if i in usecols or n in usecols]
+            if len(self.names) < len(usecols):
+                self._validate_usecols_names(usecols, self.names)
+        validate_parse_dates_presence(self.parse_dates, self.names)
+        self._set_noconvert_columns()
+        self.orig_names = self.names
+        if self._reader.leading_cols == 0 and is_index_col(self.index_col):
+            (index_names, self.names, self.index_col) = self._clean_index_names(self.names, self.index_col)
+            if self.index_names is None:
+                self.index_names = index_names
+        if self._reader.header is None and (not passed_names):
+            assert self.index_names is not None
+            self.index_names = [None] * len(self.index_names)
+        self._implicit_index = self._reader.leading_cols > 0
+
+    def close(self) -> None:
+        try:
+            self._reader.close()
+        except ValueError:
+            pass
+
+    def _set_noconvert_columns(self) -> None:
+        assert self.orig_names is not None
+        names_dict = {x: i for (i, x) in enumerate(self.orig_names)}
+        col_indices = [names_dict[x] for x in self.names]
+        noconvert_columns = self._set_noconvert_dtype_columns(col_indices, self.names)
+        for col in noconvert_columns:
+            self._reader.set_noconvert(col)
+
+    def read(self, nrows: int | None=None) -> tuple[Index | MultiIndex | None, Sequence[Hashable] | MultiIndex, Mapping[Hashable, AnyArrayLike]]:
+        index: Index | MultiIndex | None
+        column_names: Sequence[Hashable] | MultiIndex
+        try:
+            if self.low_memory:
+                chunks = self._reader.read_low_memory(nrows)
+                data = _concatenate_chunks(chunks, self.names)
+            else:
+                data = self._reader.read(nrows)
+        except StopIteration:
+            if self._first_chunk:
+                self._first_chunk = False
+                names = dedup_names(self.orig_names, is_potential_multi_index(self.orig_names, self.index_col))
+                (index, columns, col_dict) = self._get_empty_meta(names, dtype=self.dtype)
+                columns = self._maybe_make_multi_index_columns(columns, self.col_names)
+                columns = _filter_usecols(self.usecols, columns)
+                col_dict = {k: v for (k, v) in col_dict.items() if k in columns}
+                return (index, columns, col_dict)
+            else:
+                self.close()
+                raise
+        self._first_chunk = False
+        names = self.names
+        if self._reader.leading_cols:
+            arrays = []
+            if self.index_col and self._reader.leading_cols != len(self.index_col):
+                raise ParserError(f'Could not construct index. Requested to use {len(self.index_col)} number of columns, but {self._reader.leading_cols} left to parse.')
+            for i in range(self._reader.leading_cols):
+                if self.index_col is None:
+                    values = data.pop(i)
+                else:
+                    values = data.pop(self.index_col[i])
+                if self._should_parse_dates(i):
+                    values = date_converter(values, col=self.index_names[i] if self.index_names is not None else None, dayfirst=self.dayfirst, cache_dates=self.cache_dates, date_format=self.date_format)
+                arrays.append(values)
+            index = ensure_index_from_sequences(arrays)
+            names = _filter_usecols(self.usecols, names)
+            names = dedup_names(names, is_potential_multi_index(names, self.index_col))
+            data_tups = sorted(data.items())
+            data = {k: v for (k, (i, v)) in zip(names, data_tups)}
+            date_data = self._do_date_conversions(names, data)
+            column_names = self._maybe_make_multi_index_columns(names, self.col_names)
+        else:
+            data_tups = sorted(data.items())
+            assert self.orig_names is not None
+            names = list(self.orig_names)
+            names = dedup_names(names, is_potential_multi_index(names, self.index_col))
+            names = _filter_usecols(self.usecols, names)
+            alldata = [x[1] for x in data_tups]
+            if self.usecols is None:
+                self._check_data_length(names, alldata)
+            data = {k: v for (k, (i, v)) in zip(names, data_tups)}
+            date_data = self._do_date_conversions(names, data)
+            (index, column_names) = self._make_index(alldata, names)
+        return (index, column_names, date_data)
+
+def _filter_usecols(usecols, names: SequenceT) -> SequenceT | list[Hashable]:
+    usecols = evaluate_callable_usecols(usecols, names)
+    if usecols is not None and len(names) != len(usecols):
+        return [name for (i, name) in enumerate(names) if i in usecols or name in usecols]
+    return names
+
+def _concatenate_chunks(chunks: list[dict[int, ArrayLike]], column_names: list[str]) -> dict:
+    names = list(chunks[0].keys())
+    warning_columns = []
+    result: dict = {}
+    for name in names:
+        arrs = [chunk.pop(name) for chunk in chunks]
+        dtypes = {a.dtype for a in arrs}
+        non_cat_dtypes = {x for x in dtypes if not isinstance(x, CategoricalDtype)}
+        dtype = dtypes.pop()
+        if isinstance(dtype, CategoricalDtype):
+            result[name] = union_categoricals(arrs, sort_categories=False)
+        else:
+            result[name] = concat_compat(arrs)
+            if len(non_cat_dtypes) > 1 and result[name].dtype == np.dtype(object):
+                warning_columns.append(column_names[name])
+    if warning_columns:
+        warning_names = ', '.join([f'{index}: {name}' for (index, name) in enumerate(warning_columns)])
+        warning_message = ' '.join([f'Columns ({warning_names}) have mixed types. Specify dtype option on import or set low_memory=False.'])
+        warnings.warn(warning_message, DtypeWarning, stacklevel=find_stack_level())
+    return result
+
+def ensure_dtype_objs(dtype: DtypeArg | dict[Hashable, DtypeArg] | None) -> DtypeObj | dict[Hashable, DtypeObj] | None:
+    if isinstance(dtype, defaultdict):
+        default_dtype = pandas_dtype(dtype.default_factory())
+        dtype_converted: defaultdict = defaultdict(lambda : default_dtype)
+        for key in dtype.keys():
+            dtype_converted[key] = pandas_dtype(dtype[key])
+        return dtype_converted
+    elif isinstance(dtype, dict):
+        return {k: pandas_dtype(dtype[k]) for k in dtype}
+    elif dtype is not None:
+        return pandas_dtype(dtype)
+    return dtype
+
+# File: pandas-main/pandas/io/parsers/python_parser.py
+from __future__ import annotations
+from collections import abc, defaultdict
+import csv
+from io import StringIO
+import re
+from typing import IO, TYPE_CHECKING, Any, DefaultDict, Literal, cast, final
+import warnings
+import numpy as np
+from pandas._libs import lib
+from pandas.errors import EmptyDataError, ParserError, ParserWarning
+from pandas.util._decorators import cache_readonly
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.astype import astype_array
+from pandas.core.dtypes.common import is_bool_dtype, is_extension_array_dtype, is_integer, is_numeric_dtype, is_object_dtype, is_string_dtype, pandas_dtype
+from pandas.core.dtypes.dtypes import CategoricalDtype, ExtensionDtype
+from pandas.core.dtypes.inference import is_dict_like
+from pandas.core import algorithms
+from pandas.core.arrays import Categorical, ExtensionArray
+from pandas.core.arrays.boolean import BooleanDtype
+from pandas.core.indexes.api import Index
+from pandas.io.common import dedup_names, is_potential_multi_index
+from pandas.io.parsers.base_parser import ParserBase, evaluate_callable_usecols, get_na_values, parser_defaults, validate_parse_dates_presence
+if TYPE_CHECKING:
+    from collections.abc import Hashable, Iterator, Mapping, Sequence
+    from pandas._typing import ArrayLike, DtypeObj, ReadCsvBuffer, Scalar, T
+    from pandas import MultiIndex, Series
+_BOM = '\ufeff'
+
+class PythonParser(ParserBase):
+    _no_thousands_columns: set[int]
+
+    def __init__(self, f: ReadCsvBuffer[str] | list, **kwds) -> None:
+        super().__init__(kwds)
+        self.data: Iterator[list[str]] | list[list[Scalar]] = []
+        self.buf: list = []
+        self.pos = 0
+        self.line_pos = 0
+        self.skiprows = kwds['skiprows']
+        if callable(self.skiprows):
+            self.skipfunc = self.skiprows
+        else:
+            self.skipfunc = lambda x: x in self.skiprows
+        self.skipfooter = _validate_skipfooter_arg(kwds['skipfooter'])
+        self.delimiter = kwds['delimiter']
+        self.quotechar = kwds['quotechar']
+        if isinstance(self.quotechar, str):
+            self.quotechar = str(self.quotechar)
+        self.escapechar = kwds['escapechar']
+        self.doublequote = kwds['doublequote']
+        self.skipinitialspace = kwds['skipinitialspace']
+        self.lineterminator = kwds['lineterminator']
+        self.quoting = kwds['quoting']
+        self.skip_blank_lines = kwds['skip_blank_lines']
+        self.has_index_names = kwds.get('has_index_names', False)
+        self.thousands = kwds['thousands']
+        self.decimal = kwds['decimal']
+        self.comment = kwds['comment']
+        if isinstance(f, list):
+            self.data = f
+        else:
+            assert hasattr(f, 'readline')
+            self.data = self._make_reader(f)
+        self._col_indices: list[int] | None = None
+        columns: list[list[Scalar | None]]
+        (columns, self.num_original_columns, self.unnamed_cols) = self._infer_columns()
+        (self.columns, self.index_names, self.col_names, _) = self._extract_multi_indexer_columns(columns, self.index_names)
+        self.orig_names: list[Hashable] = list(self.columns)
+        (index_names, self.orig_names, self.columns) = self._get_index_name()
+        if self.index_names is None:
+            self.index_names = index_names
+        if self._col_indices is None:
+            self._col_indices = list(range(len(self.columns)))
+        self._no_thousands_columns = self._set_no_thousand_columns()
+        if len(self.decimal) != 1:
+            raise ValueError('Only length-1 decimal markers supported')
+
+    @cache_readonly
+    def num(self) -> re.Pattern:
+        decimal = re.escape(self.decimal)
+        if self.thousands is None:
+            regex = f'^[\\-\\+]?[0-9]*({decimal}[0-9]*)?([0-9]?(E|e)\\-?[0-9]+)?$'
+        else:
+            thousands = re.escape(self.thousands)
+            regex = f'^[\\-\\+]?([0-9]+{thousands}|[0-9])*({decimal}[0-9]*)?([0-9]?(E|e)\\-?[0-9]+)?$'
+        return re.compile(regex)
+
+    def _make_reader(self, f: IO[str] | ReadCsvBuffer[str]) -> Iterator[list[str]]:
+        sep = self.delimiter
+        if sep is None or len(sep) == 1:
+            if self.lineterminator:
+                raise ValueError('Custom line terminators not supported in python parser (yet)')
+
+            class MyDialect(csv.Dialect):
+                delimiter = self.delimiter
+                quotechar = self.quotechar
+                escapechar = self.escapechar
+                doublequote = self.doublequote
+                skipinitialspace = self.skipinitialspace
+                quoting = self.quoting
+                lineterminator = '\n'
+            dia = MyDialect
+            if sep is not None:
+                dia.delimiter = sep
+            else:
+                line = f.readline()
+                lines = self._check_comments([[line]])[0]
+                while self.skipfunc(self.pos) or not lines:
+                    self.pos += 1
+                    line = f.readline()
+                    lines = self._check_comments([[line]])[0]
+                lines_str = cast(list[str], lines)
+                line = lines_str[0]
+                self.pos += 1
+                self.line_pos += 1
+                sniffed = csv.Sniffer().sniff(line)
+                dia.delimiter = sniffed.delimiter
+                line_rdr = csv.reader(StringIO(line), dialect=dia)
+                self.buf.extend(list(line_rdr))
+            reader = csv.reader(f, dialect=dia, strict=True)
+        else:
+
+            def _read():
+                line = f.readline()
+                pat = re.compile(sep)
+                yield pat.split(line.strip())
+                for line in f:
+                    yield pat.split(line.strip())
+            reader = _read()
+        return reader
+
+    def read(self, rows: int | None=None) -> tuple[Index | None, Sequence[Hashable] | MultiIndex, Mapping[Hashable, ArrayLike | Series]]:
+        try:
+            content = self._get_lines(rows)
+        except StopIteration:
+            if self._first_chunk:
+                content = []
+            else:
+                self.close()
+                raise
+        self._first_chunk = False
+        index: Index | None
+        columns: Sequence[Hashable] = list(self.orig_names)
+        if not len(content):
+            names = dedup_names(self.orig_names, is_potential_multi_index(self.orig_names, self.index_col))
+            (index, columns, col_dict) = self._get_empty_meta(names, self.dtype)
+            conv_columns = self._maybe_make_multi_index_columns(columns, self.col_names)
+            return (index, conv_columns, col_dict)
+        indexnamerow = None
+        if self.has_index_names and sum((int(v == '' or v is None) for v in content[0])) == len(columns):
+            indexnamerow = content[0]
+            content = content[1:]
+        alldata = self._rows_to_cols(content)
+        (data, columns) = self._exclude_implicit_index(alldata)
+        conv_data = self._convert_data(data)
+        conv_data = self._do_date_conversions(columns, conv_data)
+        (index, result_columns) = self._make_index(alldata, columns, indexnamerow)
+        return (index, result_columns, conv_data)
+
+    def _exclude_implicit_index(self, alldata: list[np.ndarray]) -> tuple[Mapping[Hashable, np.ndarray], Sequence[Hashable]]:
+        names = dedup_names(self.orig_names, is_potential_multi_index(self.orig_names, self.index_col))
+        offset = 0
+        if self._implicit_index:
+            offset = len(self.index_col)
+        len_alldata = len(alldata)
+        self._check_data_length(names, alldata)
+        return ({name: alldata[i + offset] for (i, name) in enumerate(names) if i < len_alldata}, names)
+
+    def get_chunk(self, size: int | None=None) -> tuple[Index | None, Sequence[Hashable] | MultiIndex, Mapping[Hashable, ArrayLike | Series]]:
+        if size is None:
+            size = self.chunksize
+        return self.read(rows=size)
+
+    def _convert_data(self, data: Mapping[Hashable, np.ndarray]) -> Mapping[Hashable, ArrayLike]:
+        clean_conv = self._clean_mapping(self.converters)
+        clean_dtypes = self._clean_mapping(self.dtype)
+        clean_na_values = {}
+        clean_na_fvalues = {}
+        if isinstance(self.na_values, dict):
+            for col in self.na_values:
+                if col is not None:
+                    na_value = self.na_values[col]
+                    na_fvalue = self.na_fvalues[col]
+                    if isinstance(col, int) and col not in self.orig_names:
+                        col = self.orig_names[col]
+                    clean_na_values[col] = na_value
+                    clean_na_fvalues[col] = na_fvalue
+        else:
+            clean_na_values = self.na_values
+            clean_na_fvalues = self.na_fvalues
+        return self._convert_to_ndarrays(data, clean_na_values, clean_na_fvalues, clean_conv, clean_dtypes)
+
+    @final
+    def _convert_to_ndarrays(self, dct: Mapping, na_values, na_fvalues, converters=None, dtypes=None) -> dict[Any, np.ndarray]:
+        result = {}
+        parse_date_cols = validate_parse_dates_presence(self.parse_dates, self.columns)
+        for (c, values) in dct.items():
+            conv_f = None if converters is None else converters.get(c, None)
+            if isinstance(dtypes, dict):
+                cast_type = dtypes.get(c, None)
+            else:
+                cast_type = dtypes
+            if self.na_filter:
+                (col_na_values, col_na_fvalues) = get_na_values(c, na_values, na_fvalues, self.keep_default_na)
+            else:
+                (col_na_values, col_na_fvalues) = (set(), set())
+            if c in parse_date_cols:
+                mask = algorithms.isin(values, set(col_na_values) | col_na_fvalues)
+                np.putmask(values, mask, np.nan)
+                result[c] = values
+                continue
+            if conv_f is not None:
+                if cast_type is not None:
+                    warnings.warn(f'Both a converter and dtype were specified for column {c} - only the converter will be used.', ParserWarning, stacklevel=find_stack_level())
+                try:
+                    values = lib.map_infer(values, conv_f)
+                except ValueError:
+                    mask = algorithms.isin(values, list(na_values)).view(np.uint8)
+                    values = lib.map_infer_mask(values, conv_f, mask)
+                (cvals, na_count) = self._infer_types(values, set(col_na_values) | col_na_fvalues, cast_type is None, try_num_bool=False)
+            else:
+                is_ea = is_extension_array_dtype(cast_type)
+                is_str_or_ea_dtype = is_ea or is_string_dtype(cast_type)
+                try_num_bool = not (cast_type and is_str_or_ea_dtype)
+                (cvals, na_count) = self._infer_types(values, set(col_na_values) | col_na_fvalues, cast_type is None, try_num_bool)
+                if cast_type is not None:
+                    cast_type = pandas_dtype(cast_type)
+                if cast_type and (cvals.dtype != cast_type or is_ea):
+                    if not is_ea and na_count > 0:
+                        if is_bool_dtype(cast_type):
+                            raise ValueError(f'Bool column has NA values in column {c}')
+                    cvals = self._cast_types(cvals, cast_type, c)
+            result[c] = cvals
+        return result
+
+    @final
+    def _cast_types(self, values: ArrayLike, cast_type: DtypeObj, column) -> ArrayLike:
+        if isinstance(cast_type, CategoricalDtype):
+            known_cats = cast_type.categories is not None
+            if not is_object_dtype(values.dtype) and (not known_cats):
+                values = lib.ensure_string_array(values, skipna=False, convert_na_value=False)
+            cats = Index(values).unique().dropna()
+            values = Categorical._from_inferred_categories(cats, cats.get_indexer(values), cast_type, true_values=self.true_values)
+        elif isinstance(cast_type, ExtensionDtype):
+            array_type = cast_type.construct_array_type()
+            try:
+                if isinstance(cast_type, BooleanDtype):
+                    values_str = [str(val) for val in values]
+                    return array_type._from_sequence_of_strings(values_str, dtype=cast_type, true_values=self.true_values, false_values=self.false_values, none_values=self.na_values)
+                else:
+                    return array_type._from_sequence_of_strings(values, dtype=cast_type)
+            except NotImplementedError as err:
+                raise NotImplementedError(f'Extension Array: {array_type} must implement _from_sequence_of_strings in order to be used in parser methods') from err
+        elif isinstance(values, ExtensionArray):
+            values = values.astype(cast_type, copy=False)
+        elif issubclass(cast_type.type, str):
+            values = lib.ensure_string_array(values, skipna=True, convert_na_value=False)
+        else:
+            try:
+                values = astype_array(values, cast_type, copy=True)
+            except ValueError as err:
+                raise ValueError(f'Unable to convert column {column} to type {cast_type}') from err
+        return values
+
+    @cache_readonly
+    def _have_mi_columns(self) -> bool:
+        if self.header is None:
+            return False
+        header = self.header
+        if isinstance(header, (list, tuple, np.ndarray)):
+            return len(header) > 1
+        else:
+            return False
+
+    def _infer_columns(self) -> tuple[list[list[Scalar | None]], int, set[Scalar | None]]:
+        names = self.names
+        num_original_columns = 0
+        clear_buffer = True
+        unnamed_cols: set[Scalar | None] = set()
+        if self.header is not None:
+            header = self.header
+            have_mi_columns = self._have_mi_columns
+            if isinstance(header, (list, tuple, np.ndarray)):
+                if have_mi_columns:
+                    header = list(header) + [header[-1] + 1]
+            else:
+                header = [header]
+            columns: list[list[Scalar | None]] = []
+            for (level, hr) in enumerate(header):
+                try:
+                    line = self._buffered_line()
+                    while self.line_pos <= hr:
+                        line = self._next_line()
+                except StopIteration as err:
+                    if 0 < self.line_pos <= hr and (not have_mi_columns or hr != header[-1]):
+                        joi = list(map(str, header[:-1] if have_mi_columns else header))
+                        msg = f"[{','.join(joi)}], len of {len(joi)}, "
+                        raise ValueError(f'Passed header={msg}but only {self.line_pos} lines in file') from err
+                    if have_mi_columns and hr > 0:
+                        if clear_buffer:
+                            self.buf.clear()
+                        columns.append([None] * len(columns[-1]))
+                        return (columns, num_original_columns, unnamed_cols)
+                    if not self.names:
+                        raise EmptyDataError('No columns to parse from file') from err
+                    line = self.names[:]
+                this_columns: list[Scalar | None] = []
+                this_unnamed_cols = []
+                for (i, c) in enumerate(line):
+                    if c == '':
+                        if have_mi_columns:
+                            col_name = f'Unnamed: {i}_level_{level}'
+                        else:
+                            col_name = f'Unnamed: {i}'
+                        this_unnamed_cols.append(i)
+                        this_columns.append(col_name)
+                    else:
+                        this_columns.append(c)
+                if not have_mi_columns:
+                    counts: DefaultDict = defaultdict(int)
+                    col_loop_order = [i for i in range(len(this_columns)) if i not in this_unnamed_cols] + this_unnamed_cols
+                    for i in col_loop_order:
+                        col = this_columns[i]
+                        old_col = col
+                        cur_count = counts[col]
+                        if cur_count > 0:
+                            while cur_count > 0:
+                                counts[old_col] = cur_count + 1
+                                col = f'{old_col}.{cur_count}'
+                                if col in this_columns:
+                                    cur_count += 1
+                                else:
+                                    cur_count = counts[col]
+                            if self.dtype is not None and is_dict_like(self.dtype) and (self.dtype.get(old_col) is not None) and (self.dtype.get(col) is None):
+                                self.dtype.update({col: self.dtype.get(old_col)})
+                        this_columns[i] = col
+                        counts[col] = cur_count + 1
+                elif have_mi_columns:
+                    if hr == header[-1]:
+                        lc = len(this_columns)
+                        sic = self.index_col
+                        ic = len(sic) if sic is not None else 0
+                        unnamed_count = len(this_unnamed_cols)
+                        if lc != unnamed_count and lc - ic > unnamed_count or ic == 0:
+                            clear_buffer = False
+                            this_columns = [None] * lc
+                            self.buf = [self.buf[-1]]
+                columns.append(this_columns)
+                unnamed_cols.update({this_columns[i] for i in this_unnamed_cols})
+                if len(columns) == 1:
+                    num_original_columns = len(this_columns)
+            if clear_buffer:
+                self.buf.clear()
+            first_line: list[Scalar] | None
+            if names is not None:
+                try:
+                    first_line = self._next_line()
+                except StopIteration:
+                    first_line = None
+                len_first_data_row = 0 if first_line is None else len(first_line)
+                if len(names) > len(columns[0]) and len(names) > len_first_data_row:
+                    raise ValueError('Number of passed names did not match number of header fields in the file')
+                if len(columns) > 1:
+                    raise TypeError('Cannot pass names with multi-index columns')
+                if self.usecols is not None:
+                    self._handle_usecols(columns, names, num_original_columns)
+                else:
+                    num_original_columns = len(names)
+                if self._col_indices is not None and len(names) != len(self._col_indices):
+                    columns = [[names[i] for i in sorted(self._col_indices)]]
+                else:
+                    columns = [names]
+            else:
+                columns = self._handle_usecols(columns, columns[0], num_original_columns)
+        else:
+            ncols = len(self._header_line)
+            num_original_columns = ncols
+            if not names:
+                columns = [list(range(ncols))]
+                columns = self._handle_usecols(columns, columns[0], ncols)
+            elif self.usecols is None or len(names) >= ncols:
+                columns = self._handle_usecols([names], names, ncols)
+                num_original_columns = len(names)
+            elif not callable(self.usecols) and len(names) != len(self.usecols):
+                raise ValueError('Number of passed names did not match number of header fields in the file')
+            else:
+                columns = [names]
+                self._handle_usecols(columns, columns[0], ncols)
+        return (columns, num_original_columns, unnamed_cols)
+
+    @cache_readonly
+    def _header_line(self):
+        if self.header is not None:
+            return None
+        try:
+            line = self._buffered_line()
+        except StopIteration as err:
+            if not self.names:
+                raise EmptyDataError('No columns to parse from file') from err
+            line = self.names[:]
+        return line
+
+    def _handle_usecols(self, columns: list[list[Scalar | None]], usecols_key: list[Scalar | None], num_original_columns: int) -> list[list[Scalar | None]]:
+        col_indices: set[int] | list[int]
+        if self.usecols is not None:
+            if callable(self.usecols):
+                col_indices = evaluate_callable_usecols(self.usecols, usecols_key)
+            elif any((isinstance(u, str) for u in self.usecols)):
+                if len(columns) > 1:
+                    raise ValueError('If using multiple headers, usecols must be integers.')
+                col_indices = []
+                for col in self.usecols:
+                    if isinstance(col, str):
+                        try:
+                            col_indices.append(usecols_key.index(col))
+                        except ValueError:
+                            self._validate_usecols_names(self.usecols, usecols_key)
+                    else:
+                        col_indices.append(col)
+            else:
+                missing_usecols = [col for col in self.usecols if col >= num_original_columns]
+                if missing_usecols:
+                    raise ParserError(f'Defining usecols with out-of-bounds indices is not allowed. {missing_usecols} are out-of-bounds.')
+                col_indices = self.usecols
+            columns = [[n for (i, n) in enumerate(column) if i in col_indices] for column in columns]
+            self._col_indices = sorted(col_indices)
+        return columns
+
+    def _buffered_line(self) -> list[Scalar]:
+        if len(self.buf) > 0:
+            return self.buf[0]
+        else:
+            return self._next_line()
+
+    def _check_for_bom(self, first_row: list[Scalar]) -> list[Scalar]:
+        if not first_row:
+            return first_row
+        if not isinstance(first_row[0], str):
+            return first_row
+        if not first_row[0]:
+            return first_row
+        first_elt = first_row[0][0]
+        if first_elt != _BOM:
+            return first_row
+        first_row_bom = first_row[0]
+        new_row: str
+        if len(first_row_bom) > 1 and first_row_bom[1] == self.quotechar:
+            start = 2
+            quote = first_row_bom[1]
+            end = first_row_bom[2:].index(quote) + 2
+            new_row = first_row_bom[start:end]
+            if len(first_row_bom) > end + 1:
+                new_row += first_row_bom[end + 1:]
+        else:
+            new_row = first_row_bom[1:]
+        new_row_list: list[Scalar] = [new_row]
+        return new_row_list + first_row[1:]
+
+    def _is_line_empty(self, line: Sequence[Scalar]) -> bool:
+        return not line or all((not x for x in line))
+
+    def _next_line(self) -> list[Scalar]:
+        if isinstance(self.data, list):
+            while self.skipfunc(self.pos):
+                if self.pos >= len(self.data):
+                    break
+                self.pos += 1
+            while True:
+                try:
+                    line = self._check_comments([self.data[self.pos]])[0]
+                    self.pos += 1
+                    if not self.skip_blank_lines and (self._is_line_empty(self.data[self.pos - 1]) or line):
+                        break
+                    if self.skip_blank_lines:
+                        ret = self._remove_empty_lines([line])
+                        if ret:
+                            line = ret[0]
+                            break
+                except IndexError as err:
+                    raise StopIteration from err
+        else:
+            while self.skipfunc(self.pos):
+                self.pos += 1
+                next(self.data)
+            while True:
+                orig_line = self._next_iter_line(row_num=self.pos + 1)
+                self.pos += 1
+                if orig_line is not None:
+                    line = self._check_comments([orig_line])[0]
+                    if self.skip_blank_lines:
+                        ret = self._remove_empty_lines([line])
+                        if ret:
+                            line = ret[0]
+                            break
+                    elif self._is_line_empty(orig_line) or line:
+                        break
+        if self.pos == 1:
+            line = self._check_for_bom(line)
+        self.line_pos += 1
+        self.buf.append(line)
+        return line
+
+    def _alert_malformed(self, msg: str, row_num: int) -> None:
+        if self.on_bad_lines == self.BadLineHandleMethod.ERROR:
+            raise ParserError(msg)
+        if self.on_bad_lines == self.BadLineHandleMethod.WARN:
+            warnings.warn(f'Skipping line {row_num}: {msg}\n', ParserWarning, stacklevel=find_stack_level())
+
+    def _next_iter_line(self, row_num: int) -> list[Scalar] | None:
+        try:
+            assert not isinstance(self.data, list)
+            line = next(self.data)
+            return line
+        except csv.Error as e:
+            if self.on_bad_lines in (self.BadLineHandleMethod.ERROR, self.BadLineHandleMethod.WARN):
+                msg = str(e)
+                if 'NULL byte' in msg or 'line contains NUL' in msg:
+                    msg = "NULL byte detected. This byte cannot be processed in Python's native csv library at the moment, so please pass in engine='c' instead"
+                if self.skipfooter > 0:
+                    reason = "Error could possibly be due to parsing errors in the skipped footer rows (the skipfooter keyword is only applied after Python's csv library has parsed all rows)."
+                    msg += '. ' + reason
+                self._alert_malformed(msg, row_num)
+            return None
+
+    def _check_comments(self, lines: list[list[Scalar]]) -> list[list[Scalar]]:
+        if self.comment is None:
+            return lines
+        ret = []
+        for line in lines:
+            rl = []
+            for x in line:
+                if not isinstance(x, str) or self.comment not in x or x in self.na_values:
+                    rl.append(x)
+                else:
+                    x = x[:x.find(self.comment)]
+                    if len(x) > 0:
+                        rl.append(x)
+                    break
+            ret.append(rl)
+        return ret
+
+    def _remove_empty_lines(self, lines: list[list[T]]) -> list[list[T]]:
+        ret = [line for line in lines if len(line) > 1 or (len(line) == 1 and (not isinstance(line[0], str) or line[0].strip()))]
+        return ret
+
+    def _check_thousands(self, lines: list[list[Scalar]]) -> list[list[Scalar]]:
+        if self.thousands is None:
+            return lines
+        return self._search_replace_num_columns(lines=lines, search=self.thousands, replace='')
+
+    def _search_replace_num_columns(self, lines: list[list[Scalar]], search: str, replace: str) -> list[list[Scalar]]:
+        ret = []
+        for line in lines:
+            rl = []
+            for (i, x) in enumerate(line):
+                if not isinstance(x, str) or search not in x or i in self._no_thousands_columns or (not self.num.search(x.strip())):
+                    rl.append(x)
+                else:
+                    rl.append(x.replace(search, replace))
+            ret.append(rl)
+        return ret
+
+    def _check_decimal(self, lines: list[list[Scalar]]) -> list[list[Scalar]]:
+        if self.decimal == parser_defaults['decimal']:
+            return lines
+        return self._search_replace_num_columns(lines=lines, search=self.decimal, replace='.')
+
+    def _get_index_name(self) -> tuple[Sequence[Hashable] | None, list[Hashable], list[Hashable]]:
+        columns: Sequence[Hashable] = self.orig_names
+        orig_names = list(columns)
+        columns = list(columns)
+        line: list[Scalar] | None
+        if self._header_line is not None:
+            line = self._header_line
+        else:
+            try:
+                line = self._next_line()
+            except StopIteration:
+                line = None
+        next_line: list[Scalar] | None
+        try:
+            next_line = self._next_line()
+        except StopIteration:
+            next_line = None
+        implicit_first_cols = 0
+        if line is not None:
+            index_col = self.index_col
+            if index_col is not False:
+                implicit_first_cols = len(line) - self.num_original_columns
+            if next_line is not None and self.header is not None and (index_col is not False):
+                if len(next_line) == len(line) + self.num_original_columns:
+                    self.index_col = list(range(len(line)))
+                    self.buf = self.buf[1:]
+                    for c in reversed(line):
+                        columns.insert(0, c)
+                    orig_names = list(columns)
+                    self.num_original_columns = len(columns)
+                    return (line, orig_names, columns)
+        if implicit_first_cols > 0:
+            self._implicit_index = True
+            if self.index_col is None:
+                self.index_col = list(range(implicit_first_cols))
+            index_name = None
+        else:
+            (index_name, _, self.index_col) = self._clean_index_names(columns, self.index_col)
+        return (index_name, orig_names, columns)
+
+    def _rows_to_cols(self, content: list[list[Scalar]]) -> list[np.ndarray]:
+        col_len = self.num_original_columns
+        if self._implicit_index:
+            col_len += len(self.index_col)
+        max_len = max((len(row) for row in content))
+        if max_len > col_len and self.index_col is not False and (self.usecols is None):
+            footers = self.skipfooter if self.skipfooter else 0
+            bad_lines = []
+            iter_content = enumerate(content)
+            content_len = len(content)
+            content = []
+            for (i, _content) in iter_content:
+                actual_len = len(_content)
+                if actual_len > col_len:
+                    if callable(self.on_bad_lines):
+                        new_l = self.on_bad_lines(_content)
+                        if new_l is not None:
+                            content.append(new_l)
+                    elif self.on_bad_lines in (self.BadLineHandleMethod.ERROR, self.BadLineHandleMethod.WARN):
+                        row_num = self.pos - (content_len - i + footers)
+                        bad_lines.append((row_num, actual_len))
+                        if self.on_bad_lines == self.BadLineHandleMethod.ERROR:
+                            break
+                else:
+                    content.append(_content)
+            for (row_num, actual_len) in bad_lines:
+                msg = f'Expected {col_len} fields in line {row_num + 1}, saw {actual_len}'
+                if self.delimiter and len(self.delimiter) > 1 and (self.quoting != csv.QUOTE_NONE):
+                    reason = 'Error could possibly be due to quotes being ignored when a multi-char delimiter is used.'
+                    msg += '. ' + reason
+                self._alert_malformed(msg, row_num + 1)
+        zipped_content = list(lib.to_object_array(content, min_width=col_len).T)
+        if self.usecols:
+            assert self._col_indices is not None
+            col_indices = self._col_indices
+            if self._implicit_index:
+                zipped_content = [a for (i, a) in enumerate(zipped_content) if i < len(self.index_col) or i - len(self.index_col) in col_indices]
+            else:
+                zipped_content = [a for (i, a) in enumerate(zipped_content) if i in col_indices]
+        return zipped_content
+
+    def _get_lines(self, rows: int | None=None) -> list[list[Scalar]]:
+        lines = self.buf
+        new_rows = None
+        if rows is not None:
+            if len(self.buf) >= rows:
+                (new_rows, self.buf) = (self.buf[:rows], self.buf[rows:])
+            else:
+                rows -= len(self.buf)
+        if new_rows is None:
+            if isinstance(self.data, list):
+                if self.pos > len(self.data):
+                    raise StopIteration
+                if rows is None:
+                    new_rows = self.data[self.pos:]
+                    new_pos = len(self.data)
+                else:
+                    new_rows = self.data[self.pos:self.pos + rows]
+                    new_pos = self.pos + rows
+                new_rows = self._remove_skipped_rows(new_rows)
+                lines.extend(new_rows)
+                self.pos = new_pos
+            else:
+                new_rows = []
+                try:
+                    if rows is not None:
+                        row_index = 0
+                        row_ct = 0
+                        offset = self.pos if self.pos is not None else 0
+                        while row_ct < rows:
+                            new_row = next(self.data)
+                            if not self.skipfunc(offset + row_index):
+                                row_ct += 1
+                            row_index += 1
+                            new_rows.append(new_row)
+                        len_new_rows = len(new_rows)
+                        new_rows = self._remove_skipped_rows(new_rows)
+                        lines.extend(new_rows)
+                    else:
+                        rows = 0
+                        while True:
+                            next_row = self._next_iter_line(row_num=self.pos + rows + 1)
+                            rows += 1
+                            if next_row is not None:
+                                new_rows.append(next_row)
+                        len_new_rows = len(new_rows)
+                except StopIteration:
+                    len_new_rows = len(new_rows)
+                    new_rows = self._remove_skipped_rows(new_rows)
+                    lines.extend(new_rows)
+                    if len(lines) == 0:
+                        raise
+                self.pos += len_new_rows
+            self.buf = []
+        else:
+            lines = new_rows
+        if self.skipfooter:
+            lines = lines[:-self.skipfooter]
+        lines = self._check_comments(lines)
+        if self.skip_blank_lines:
+            lines = self._remove_empty_lines(lines)
+        lines = self._check_thousands(lines)
+        return self._check_decimal(lines)
+
+    def _remove_skipped_rows(self, new_rows: list[list[Scalar]]) -> list[list[Scalar]]:
+        if self.skiprows:
+            return [row for (i, row) in enumerate(new_rows) if not self.skipfunc(i + self.pos)]
+        return new_rows
+
+    def _set_no_thousand_columns(self) -> set[int]:
+        no_thousands_columns: set[int] = set()
+        if self.columns and self.parse_dates:
+            assert self._col_indices is not None
+            no_thousands_columns = self._set_noconvert_dtype_columns(self._col_indices, self.columns)
+        if self.columns and self.dtype:
+            assert self._col_indices is not None
+            for (i, col) in zip(self._col_indices, self.columns):
+                if not isinstance(self.dtype, dict) and (not is_numeric_dtype(self.dtype)):
+                    no_thousands_columns.add(i)
+                if isinstance(self.dtype, dict) and col in self.dtype and (not is_numeric_dtype(self.dtype[col]) or is_bool_dtype(self.dtype[col])):
+                    no_thousands_columns.add(i)
+        return no_thousands_columns
+
+class FixedWidthReader(abc.Iterator):
+
+    def __init__(self, f: IO[str] | ReadCsvBuffer[str], colspecs: list[tuple[int, int]] | Literal['infer'], delimiter: str | None, comment: str | None, skiprows: set[int] | None=None, infer_nrows: int=100) -> None:
+        self.f = f
+        self.buffer: Iterator | None = None
+        self.delimiter = '\r\n' + delimiter if delimiter else '\n\r\t '
+        self.comment = comment
+        if colspecs == 'infer':
+            self.colspecs = self.detect_colspecs(infer_nrows=infer_nrows, skiprows=skiprows)
+        else:
+            self.colspecs = colspecs
+        if not isinstance(self.colspecs, (tuple, list)):
+            raise TypeError(f'column specifications must be a list or tuple, input was a {type(colspecs).__name__}')
+        for colspec in self.colspecs:
+            if not (isinstance(colspec, (tuple, list)) and len(colspec) == 2 and isinstance(colspec[0], (int, np.integer, type(None))) and isinstance(colspec[1], (int, np.integer, type(None)))):
+                raise TypeError('Each column specification must be 2 element tuple or list of integers')
+
+    def get_rows(self, infer_nrows: int, skiprows: set[int] | None=None) -> list[str]:
+        if skiprows is None:
+            skiprows = set()
+        buffer_rows = []
+        detect_rows = []
+        for (i, row) in enumerate(self.f):
+            if i not in skiprows:
+                detect_rows.append(row)
+            buffer_rows.append(row)
+            if len(detect_rows) >= infer_nrows:
+                break
+        self.buffer = iter(buffer_rows)
+        return detect_rows
+
+    def detect_colspecs(self, infer_nrows: int=100, skiprows: set[int] | None=None) -> list[tuple[int, int]]:
+        delimiters = ''.join([f'\\{x}' for x in self.delimiter])
+        pattern = re.compile(f'([^{delimiters}]+)')
+        rows = self.get_rows(infer_nrows, skiprows)
+        if not rows:
+            raise EmptyDataError('No rows from which to infer column width')
+        max_len = max(map(len, rows))
+        mask = np.zeros(max_len + 1, dtype=int)
+        if self.comment is not None:
+            rows = [row.partition(self.comment)[0] for row in rows]
+        for row in rows:
+            for m in pattern.finditer(row):
+                mask[m.start():m.end()] = 1
+        shifted = np.roll(mask, 1)
+        shifted[0] = 0
+        edges = np.where(mask ^ shifted == 1)[0]
+        edge_pairs = list(zip(edges[::2], edges[1::2]))
+        return edge_pairs
+
+    def __next__(self) -> list[str]:
+        if self.buffer is not None:
+            try:
+                line = next(self.buffer)
+            except StopIteration:
+                self.buffer = None
+                line = next(self.f)
+        else:
+            line = next(self.f)
+        return [line[from_:to].strip(self.delimiter) for (from_, to) in self.colspecs]
+
+class FixedWidthFieldParser(PythonParser):
+
+    def __init__(self, f: ReadCsvBuffer[str], **kwds) -> None:
+        self.colspecs = kwds.pop('colspecs')
+        self.infer_nrows = kwds.pop('infer_nrows')
+        PythonParser.__init__(self, f, **kwds)
+
+    def _make_reader(self, f: IO[str] | ReadCsvBuffer[str]) -> FixedWidthReader:
+        return FixedWidthReader(f, self.colspecs, self.delimiter, self.comment, self.skiprows, self.infer_nrows)
+
+    def _remove_empty_lines(self, lines: list[list[T]]) -> list[list[T]]:
+        return [line for line in lines if any((not isinstance(e, str) or e.strip() for e in line))]
+
+def _validate_skipfooter_arg(skipfooter: int) -> int:
+    if not is_integer(skipfooter):
+        raise ValueError('skipfooter must be an integer')
+    if skipfooter < 0:
+        raise ValueError('skipfooter cannot be negative')
+    return skipfooter
+
+# File: pandas-main/pandas/io/parsers/readers.py
+""""""
+from __future__ import annotations
+from collections import abc, defaultdict
+import csv
+import sys
+from textwrap import fill
+from typing import IO, TYPE_CHECKING, Any, Generic, Literal, TypedDict, overload
+import warnings
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.parsers import STR_NA_VALUES
+from pandas.errors import AbstractMethodError, ParserWarning
+from pandas.util._decorators import Appender
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import check_dtype_backend
+from pandas.core.dtypes.common import is_file_like, is_float, is_integer, is_list_like, pandas_dtype
+from pandas import Series
+from pandas.core.frame import DataFrame
+from pandas.core.indexes.api import RangeIndex
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.common import IOHandles, get_handle, stringify_path, validate_header_arg
+from pandas.io.parsers.arrow_parser_wrapper import ArrowParserWrapper
+from pandas.io.parsers.base_parser import ParserBase, is_index_col, parser_defaults
+from pandas.io.parsers.c_parser_wrapper import CParserWrapper
+from pandas.io.parsers.python_parser import FixedWidthFieldParser, PythonParser
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Iterable, Mapping, Sequence
+    from types import TracebackType
+    from pandas._typing import CompressionOptions, CSVEngine, DtypeArg, DtypeBackend, FilePath, HashableT, IndexLabel, ReadCsvBuffer, Self, StorageOptions, Unpack, UsecolsArgType
+
+    class _read_shared(TypedDict, Generic[HashableT], total=False):
+        sep: str | None | lib.NoDefault
+        delimiter: str | None | lib.NoDefault
+        header: int | Sequence[int] | None | Literal['infer']
+        names: Sequence[Hashable] | None | lib.NoDefault
+        index_col: IndexLabel | Literal[False] | None
+        usecols: UsecolsArgType
+        dtype: DtypeArg | None
+        engine: CSVEngine | None
+        converters: Mapping[HashableT, Callable] | None
+        true_values: list | None
+        false_values: list | None
+        skipinitialspace: bool
+        skiprows: list[int] | int | Callable[[Hashable], bool] | None
+        skipfooter: int
+        nrows: int | None
+        na_values: Hashable | Iterable[Hashable] | Mapping[Hashable, Iterable[Hashable]] | None
+        keep_default_na: bool
+        na_filter: bool
+        skip_blank_lines: bool
+        parse_dates: bool | Sequence[Hashable] | None
+        date_format: str | dict[Hashable, str] | None
+        dayfirst: bool
+        cache_dates: bool
+        compression: CompressionOptions
+        thousands: str | None
+        decimal: str
+        lineterminator: str | None
+        quotechar: str
+        quoting: int
+        doublequote: bool
+        escapechar: str | None
+        comment: str | None
+        encoding: str | None
+        encoding_errors: str | None
+        dialect: str | csv.Dialect | None
+        on_bad_lines: str
+        low_memory: bool
+        memory_map: bool
+        float_precision: Literal['high', 'legacy', 'round_trip'] | None
+        storage_options: StorageOptions | None
+        dtype_backend: DtypeBackend | lib.NoDefault
+else:
+    _read_shared = dict
+_doc_read_csv_and_table = '\n{summary}\n\nAlso supports optionally iterating or breaking of the file\ninto chunks.\n\nAdditional help can be found in the online docs for\n`IO Tools <https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html>`_.\n\nParameters\n----------\nfilepath_or_buffer : str, path object or file-like object\n    Any valid string path is acceptable. The string could be a URL. Valid\n    URL schemes include http, ftp, s3, gs, and file. For file URLs, a host is\n    expected. A local file could be: file://localhost/path/to/table.csv.\n\n    If you want to pass in a path object, pandas accepts any ``os.PathLike``.\n\n    By file-like object, we refer to objects with a ``read()`` method, such as\n    a file handle (e.g. via builtin ``open`` function) or ``StringIO``.\nsep : str, default {_default_sep}\n    Character or regex pattern to treat as the delimiter. If ``sep=None``, the\n    C engine cannot automatically detect\n    the separator, but the Python parsing engine can, meaning the latter will\n    be used and automatically detect the separator from only the first valid\n    row of the file by Python\'s builtin sniffer tool, ``csv.Sniffer``.\n    In addition, separators longer than 1 character and different from\n    ``\'\\s+\'`` will be interpreted as regular expressions and will also force\n    the use of the Python parsing engine. Note that regex delimiters are prone\n    to ignoring quoted data. Regex example: ``\'\\r\\t\'``.\ndelimiter : str, optional\n    Alias for ``sep``.\nheader : int, Sequence of int, \'infer\' or None, default \'infer\'\n    Row number(s) containing column labels and marking the start of the\n    data (zero-indexed). Default behavior is to infer the column names: if no ``names``\n    are passed the behavior is identical to ``header=0`` and column\n    names are inferred from the first line of the file, if column\n    names are passed explicitly to ``names`` then the behavior is identical to\n    ``header=None``. Explicitly pass ``header=0`` to be able to\n    replace existing names. The header can be a list of integers that\n    specify row locations for a :class:`~pandas.MultiIndex` on the columns\n    e.g. ``[0, 1, 3]``. Intervening rows that are not specified will be\n    skipped (e.g. 2 in this example is skipped). Note that this\n    parameter ignores commented lines and empty lines if\n    ``skip_blank_lines=True``, so ``header=0`` denotes the first line of\n    data rather than the first line of the file.\n\n    When inferred from the file contents, headers are kept distinct from\n    each other by renaming duplicate names with a numeric suffix of the form\n    ``".{{count}}"`` starting from 1, e.g. ``"foo"`` and ``"foo.1"``.\n    Empty headers are named ``"Unnamed: {{i}}"`` or ``"Unnamed: {{i}}_level_{{level}}"``\n    in the case of MultiIndex columns.\nnames : Sequence of Hashable, optional\n    Sequence of column labels to apply. If the file contains a header row,\n    then you should explicitly pass ``header=0`` to override the column names.\n    Duplicates in this list are not allowed.\nindex_col : Hashable, Sequence of Hashable or False, optional\n  Column(s) to use as row label(s), denoted either by column labels or column\n  indices.  If a sequence of labels or indices is given, :class:`~pandas.MultiIndex`\n  will be formed for the row labels.\n\n  Note: ``index_col=False`` can be used to force pandas to *not* use the first\n  column as the index, e.g., when you have a malformed file with delimiters at\n  the end of each line.\nusecols : Sequence of Hashable or Callable, optional\n    Subset of columns to select, denoted either by column labels or column indices.\n    If list-like, all elements must either\n    be positional (i.e. integer indices into the document columns) or strings\n    that correspond to column names provided either by the user in ``names`` or\n    inferred from the document header row(s). If ``names`` are given, the document\n    header row(s) are not taken into account. For example, a valid list-like\n    ``usecols`` parameter would be ``[0, 1, 2]`` or ``[\'foo\', \'bar\', \'baz\']``.\n    Element order is ignored, so ``usecols=[0, 1]`` is the same as ``[1, 0]``.\n    To instantiate a :class:`~pandas.DataFrame` from ``data`` with element order\n    preserved use ``pd.read_csv(data, usecols=[\'foo\', \'bar\'])[[\'foo\', \'bar\']]``\n    for columns in ``[\'foo\', \'bar\']`` order or\n    ``pd.read_csv(data, usecols=[\'foo\', \'bar\'])[[\'bar\', \'foo\']]``\n    for ``[\'bar\', \'foo\']`` order.\n\n    If callable, the callable function will be evaluated against the column\n    names, returning names where the callable function evaluates to ``True``. An\n    example of a valid callable argument would be ``lambda x: x.upper() in\n    [\'AAA\', \'BBB\', \'DDD\']``. Using this parameter results in much faster\n    parsing time and lower memory usage.\ndtype : dtype or dict of {{Hashable : dtype}}, optional\n    Data type(s) to apply to either the whole dataset or individual columns.\n    E.g., ``{{\'a\': np.float64, \'b\': np.int32, \'c\': \'Int64\'}}``\n    Use ``str`` or ``object`` together with suitable ``na_values`` settings\n    to preserve and not interpret ``dtype``.\n    If ``converters`` are specified, they will be applied INSTEAD\n    of ``dtype`` conversion.\n\n    .. versionadded:: 1.5.0\n\n        Support for ``defaultdict`` was added. Specify a ``defaultdict`` as input where\n        the default determines the ``dtype`` of the columns which are not explicitly\n        listed.\nengine : {{\'c\', \'python\', \'pyarrow\'}}, optional\n    Parser engine to use. The C and pyarrow engines are faster, while the python engine\n    is currently more feature-complete. Multithreading is currently only supported by\n    the pyarrow engine.\n\n    .. versionadded:: 1.4.0\n\n        The \'pyarrow\' engine was added as an *experimental* engine, and some features\n        are unsupported, or may not work correctly, with this engine.\nconverters : dict of {{Hashable : Callable}}, optional\n    Functions for converting values in specified columns. Keys can either\n    be column labels or column indices.\ntrue_values : list, optional\n    Values to consider as ``True`` in addition to case-insensitive variants of \'True\'.\nfalse_values : list, optional\n    Values to consider as ``False`` in addition to case-insensitive variants of \'False\'.\nskipinitialspace : bool, default False\n    Skip spaces after delimiter.\nskiprows : int, list of int or Callable, optional\n    Line numbers to skip (0-indexed) or number of lines to skip (``int``)\n    at the start of the file.\n\n    If callable, the callable function will be evaluated against the row\n    indices, returning ``True`` if the row should be skipped and ``False`` otherwise.\n    An example of a valid callable argument would be ``lambda x: x in [0, 2]``.\nskipfooter : int, default 0\n    Number of lines at bottom of file to skip (Unsupported with ``engine=\'c\'``).\nnrows : int, optional\n    Number of rows of file to read. Useful for reading pieces of large files.\n    Refers to the number of data rows in the returned DataFrame, excluding:\n\n    * The header row containing column names.\n    * Rows before the header row, if ``header=1`` or larger.\n\n    Example usage:\n\n    * To read the first 999,999 (non-header) rows:\n      ``read_csv(..., nrows=999999)``\n\n    * To read rows 1,000,000 through 1,999,999:\n      ``read_csv(..., skiprows=1000000, nrows=999999)``\nna_values : Hashable, Iterable of Hashable or dict of {{Hashable : Iterable}}, optional\n    Additional strings to recognize as ``NA``/``NaN``. If ``dict`` passed, specific\n    per-column ``NA`` values.  By default the following values are interpreted as\n    ``NaN``: "{na_values_str}".\nkeep_default_na : bool, default True\n    Whether or not to include the default ``NaN`` values when parsing the data.\n    Depending on whether ``na_values`` is passed in, the behavior is as follows:\n\n    * If ``keep_default_na`` is ``True``, and ``na_values`` are specified, ``na_values``\n      is appended to the default ``NaN`` values used for parsing.\n    * If ``keep_default_na`` is ``True``, and ``na_values`` are not specified, only\n      the default ``NaN`` values are used for parsing.\n    * If ``keep_default_na`` is ``False``, and ``na_values`` are specified, only\n      the ``NaN`` values specified ``na_values`` are used for parsing.\n    * If ``keep_default_na`` is ``False``, and ``na_values`` are not specified, no\n      strings will be parsed as ``NaN``.\n\n    Note that if ``na_filter`` is passed in as ``False``, the ``keep_default_na`` and\n    ``na_values`` parameters will be ignored.\nna_filter : bool, default True\n    Detect missing value markers (empty strings and the value of ``na_values``). In\n    data without any ``NA`` values, passing ``na_filter=False`` can improve the\n    performance of reading a large file.\nskip_blank_lines : bool, default True\n    If ``True``, skip over blank lines rather than interpreting as ``NaN`` values.\nparse_dates : bool, None, list of Hashable, default None\n    The behavior is as follows:\n\n    * ``bool``. If ``True`` -> try parsing the index.\n    * ``None``. Behaves like ``True`` if ``date_format`` is specified.\n    * ``list`` of ``int`` or names. e.g. If ``[1, 2, 3]`` -> try parsing columns 1, 2, 3\n      each as a separate date column.\n\n    If a column or index cannot be represented as an array of ``datetime``,\n    say because of an unparsable value or a mixture of timezones, the column\n    or index will be returned unaltered as an ``object`` data type. For\n    non-standard ``datetime`` parsing, use :func:`~pandas.to_datetime` after\n    :func:`~pandas.read_csv`.\n\n    Note: A fast-path exists for iso8601-formatted dates.\ndate_format : str or dict of column -> format, optional\n    Format to use for parsing dates and/or times when used in conjunction with ``parse_dates``.\n    The strftime to parse time, e.g. :const:`"%d/%m/%Y"`. See\n    `strftime documentation\n    <https://docs.python.org/3/library/datetime.html\n    #strftime-and-strptime-behavior>`_ for more information on choices, though\n    note that :const:`"%f"` will parse all the way up to nanoseconds.\n    You can also pass:\n\n    - "ISO8601", to parse any `ISO8601 <https://en.wikipedia.org/wiki/ISO_8601>`_\n      time string (not necessarily in exactly the same format);\n    - "mixed", to infer the format for each element individually. This is risky,\n      and you should probably use it along with `dayfirst`.\n\n    .. versionadded:: 2.0.0\ndayfirst : bool, default False\n    DD/MM format dates, international and European format.\ncache_dates : bool, default True\n    If ``True``, use a cache of unique, converted dates to apply the ``datetime``\n    conversion. May produce significant speed-up when parsing duplicate\n    date strings, especially ones with timezone offsets.\n\niterator : bool, default False\n    Return ``TextFileReader`` object for iteration or getting chunks with\n    ``get_chunk()``.\nchunksize : int, optional\n    Number of lines to read from the file per chunk. Passing a value will cause the\n    function to return a ``TextFileReader`` object for iteration.\n    See the `IO Tools docs\n    <https://pandas.pydata.org/pandas-docs/stable/io.html#io-chunking>`_\n    for more information on ``iterator`` and ``chunksize``.\n\n{decompression_options}\n\n    .. versionchanged:: 1.4.0 Zstandard support.\n\nthousands : str (length 1), optional\n    Character acting as the thousands separator in numerical values.\ndecimal : str (length 1), default \'.\'\n    Character to recognize as decimal point (e.g., use \',\' for European data).\nlineterminator : str (length 1), optional\n    Character used to denote a line break. Only valid with C parser.\nquotechar : str (length 1), optional\n    Character used to denote the start and end of a quoted item. Quoted\n    items can include the ``delimiter`` and it will be ignored.\nquoting : {{0 or csv.QUOTE_MINIMAL, 1 or csv.QUOTE_ALL, 2 or csv.QUOTE_NONNUMERIC, 3 or csv.QUOTE_NONE}}, default csv.QUOTE_MINIMAL\n    Control field quoting behavior per ``csv.QUOTE_*`` constants. Default is\n    ``csv.QUOTE_MINIMAL`` (i.e., 0) which implies that only fields containing special\n    characters are quoted (e.g., characters defined in ``quotechar``, ``delimiter``,\n    or ``lineterminator``.\ndoublequote : bool, default True\n   When ``quotechar`` is specified and ``quoting`` is not ``QUOTE_NONE``, indicate\n   whether or not to interpret two consecutive ``quotechar`` elements INSIDE a\n   field as a single ``quotechar`` element.\nescapechar : str (length 1), optional\n    Character used to escape other characters.\ncomment : str (length 1), optional\n    Character indicating that the remainder of line should not be parsed.\n    If found at the beginning\n    of a line, the line will be ignored altogether. This parameter must be a\n    single character. Like empty lines (as long as ``skip_blank_lines=True``),\n    fully commented lines are ignored by the parameter ``header`` but not by\n    ``skiprows``. For example, if ``comment=\'#\'``, parsing\n    ``#empty\\\\na,b,c\\\\n1,2,3`` with ``header=0`` will result in ``\'a,b,c\'`` being\n    treated as the header.\nencoding : str, optional, default \'utf-8\'\n    Encoding to use for UTF when reading/writing (ex. ``\'utf-8\'``). `List of Python\n    standard encodings\n    <https://docs.python.org/3/library/codecs.html#standard-encodings>`_ .\n\nencoding_errors : str, optional, default \'strict\'\n    How encoding errors are treated. `List of possible values\n    <https://docs.python.org/3/library/codecs.html#error-handlers>`_ .\n\n    .. versionadded:: 1.3.0\n\ndialect : str or csv.Dialect, optional\n    If provided, this parameter will override values (default or not) for the\n    following parameters: ``delimiter``, ``doublequote``, ``escapechar``,\n    ``skipinitialspace``, ``quotechar``, and ``quoting``. If it is necessary to\n    override values, a ``ParserWarning`` will be issued. See ``csv.Dialect``\n    documentation for more details.\non_bad_lines : {{\'error\', \'warn\', \'skip\'}} or Callable, default \'error\'\n    Specifies what to do upon encountering a bad line (a line with too many fields).\n    Allowed values are:\n\n    - ``\'error\'``, raise an Exception when a bad line is encountered.\n    - ``\'warn\'``, raise a warning when a bad line is encountered and skip that line.\n    - ``\'skip\'``, skip bad lines without raising or warning when they are encountered.\n    - Callable, function that will process a single bad line.\n        - With ``engine=\'python\'``, function with signature\n          ``(bad_line: list[str]) -> list[str] | None``.\n          ``bad_line`` is a list of strings split by the ``sep``.\n          If the function returns ``None``, the bad line will be ignored.\n          If the function returns a new ``list`` of strings with more elements than\n          expected, a ``ParserWarning`` will be emitted while dropping extra elements.\n        - With ``engine=\'pyarrow\'``, function with signature\n          as described in pyarrow documentation: `invalid_row_handler\n          <https://arrow.apache.org/docs/python/generated/pyarrow.csv.ParseOptions.html\n          #pyarrow.csv.ParseOptions.invalid_row_handler>`_.\n\n    .. versionadded:: 1.3.0\n\n    .. versionadded:: 1.4.0\n\n        Callable\n\n    .. versionchanged:: 2.2.0\n\n        Callable for ``engine=\'pyarrow\'``\n\nlow_memory : bool, default True\n    Internally process the file in chunks, resulting in lower memory use\n    while parsing, but possibly mixed type inference.  To ensure no mixed\n    types either set ``False``, or specify the type with the ``dtype`` parameter.\n    Note that the entire file is read into a single :class:`~pandas.DataFrame`\n    regardless, use the ``chunksize`` or ``iterator`` parameter to return the data in\n    chunks. (Only valid with C parser).\nmemory_map : bool, default False\n    If a filepath is provided for ``filepath_or_buffer``, map the file object\n    directly onto memory and access the data directly from there. Using this\n    option can improve performance because there is no longer any I/O overhead.\nfloat_precision : {{\'high\', \'legacy\', \'round_trip\'}}, optional\n    Specifies which converter the C engine should use for floating-point\n    values. The options are ``None`` or ``\'high\'`` for the ordinary converter,\n    ``\'legacy\'`` for the original lower precision pandas converter, and\n    ``\'round_trip\'`` for the round-trip converter.\n\n{storage_options}\n\ndtype_backend : {{\'numpy_nullable\', \'pyarrow\'}}\n    Back-end data type applied to the resultant :class:`DataFrame`\n    (still experimental). If not specified, the default behavior\n    is to not use nullable data types. If specified, the behavior\n    is as follows:\n\n    * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`\n    * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype` :class:`DataFrame`\n\n    .. versionadded:: 2.0\n\nReturns\n-------\nDataFrame or TextFileReader\n    A comma-separated values (csv) file is returned as two-dimensional\n    data structure with labeled axes.\n\nSee Also\n--------\nDataFrame.to_csv : Write DataFrame to a comma-separated values (csv) file.\n{see_also_func_name} : {see_also_func_summary}\nread_fwf : Read a table of fixed-width formatted lines into DataFrame.\n\nExamples\n--------\n>>> pd.{func_name}(\'data.csv\')  # doctest: +SKIP\n   Name  Value\n0   foo      1\n1   bar      2\n2  #baz      3\n\nIndex and header can be specified via the `index_col` and `header` arguments.\n\n>>> pd.{func_name}(\'data.csv\', header=None)  # doctest: +SKIP\n      0      1\n0  Name  Value\n1   foo      1\n2   bar      2\n3  #baz      3\n\n>>> pd.{func_name}(\'data.csv\', index_col=\'Value\')  # doctest: +SKIP\n       Name\nValue\n1       foo\n2       bar\n3      #baz\n\nColumn types are inferred but can be explicitly specified using the dtype argument.\n\n>>> pd.{func_name}(\'data.csv\', dtype={{\'Value\': float}})  # doctest: +SKIP\n   Name  Value\n0   foo    1.0\n1   bar    2.0\n2  #baz    3.0\n\nTrue, False, and NA values, and thousands separators have defaults,\nbut can be explicitly specified, too. Supply the values you would like\nas strings or lists of strings!\n\n>>> pd.{func_name}(\'data.csv\', na_values=[\'foo\', \'bar\'])  # doctest: +SKIP\n   Name  Value\n0   NaN      1\n1   NaN      2\n2  #baz      3\n\nComment lines in the input file can be skipped using the `comment` argument.\n\n>>> pd.{func_name}(\'data.csv\', comment=\'#\')  # doctest: +SKIP\n  Name  Value\n0  foo      1\n1  bar      2\n\nBy default, columns with dates will be read as ``object`` rather than  ``datetime``.\n\n>>> df = pd.{func_name}(\'tmp.csv\')  # doctest: +SKIP\n\n>>> df  # doctest: +SKIP\n   col 1       col 2            col 3\n0     10  10/04/2018  Sun 15 Jan 2023\n1     20  15/04/2018  Fri 12 May 2023\n\n>>> df.dtypes  # doctest: +SKIP\ncol 1     int64\ncol 2    object\ncol 3    object\ndtype: object\n\nSpecific columns can be parsed as dates by using the `parse_dates` and\n`date_format` arguments.\n\n>>> df = pd.{func_name}(\n...     \'tmp.csv\',\n...     parse_dates=[1, 2],\n...     date_format={{\'col 2\': \'%d/%m/%Y\', \'col 3\': \'%a %d %b %Y\'}},\n... )  # doctest: +SKIP\n\n>>> df.dtypes  # doctest: +SKIP\ncol 1             int64\ncol 2    datetime64[ns]\ncol 3    datetime64[ns]\ndtype: object\n'
+
+class _C_Parser_Defaults(TypedDict):
+    na_filter: Literal[True]
+    low_memory: Literal[True]
+    memory_map: Literal[False]
+    float_precision: None
+_c_parser_defaults: _C_Parser_Defaults = {'na_filter': True, 'low_memory': True, 'memory_map': False, 'float_precision': None}
+
+class _Fwf_Defaults(TypedDict):
+    colspecs: Literal['infer']
+    infer_nrows: Literal[100]
+    widths: None
+_fwf_defaults: _Fwf_Defaults = {'colspecs': 'infer', 'infer_nrows': 100, 'widths': None}
+_c_unsupported = {'skipfooter'}
+_python_unsupported = {'low_memory', 'float_precision'}
+_pyarrow_unsupported = {'skipfooter', 'float_precision', 'chunksize', 'comment', 'nrows', 'thousands', 'memory_map', 'dialect', 'quoting', 'lineterminator', 'converters', 'iterator', 'dayfirst', 'skipinitialspace', 'low_memory'}
+
+@overload
+def validate_integer(name: str, val: None, min_val: int=...) -> None:
+    ...
+
+@overload
+def validate_integer(name: str, val: float, min_val: int=...) -> int:
+    ...
+
+@overload
+def validate_integer(name: str, val: int | None, min_val: int=...) -> int | None:
+    ...
+
+def validate_integer(name: str, val: int | float | None, min_val: int=0) -> int | None:
+    if val is None:
+        return val
+    msg = f"'{name:s}' must be an integer >={min_val:d}"
+    if is_float(val):
+        if int(val) != val:
+            raise ValueError(msg)
+        val = int(val)
+    elif not (is_integer(val) and val >= min_val):
+        raise ValueError(msg)
+    return int(val)
+
+def _validate_names(names: Sequence[Hashable] | None) -> None:
+    if names is not None:
+        if len(names) != len(set(names)):
+            raise ValueError('Duplicate names are not allowed.')
+        if not (is_list_like(names, allow_sets=False) or isinstance(names, abc.KeysView)):
+            raise ValueError('Names should be an ordered collection.')
+
+def _read(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], kwds) -> DataFrame | TextFileReader:
+    if kwds.get('parse_dates', None) is None:
+        if kwds.get('date_format', None) is None:
+            kwds['parse_dates'] = False
+        else:
+            kwds['parse_dates'] = True
+    iterator = kwds.get('iterator', False)
+    chunksize = kwds.get('chunksize', None)
+    errors = kwds.get('encoding_errors', 'strict')
+    if not isinstance(errors, str):
+        raise ValueError(f'encoding_errors must be a string, got {type(errors).__name__}')
+    if kwds.get('engine') == 'pyarrow':
+        if iterator:
+            raise ValueError("The 'iterator' option is not supported with the 'pyarrow' engine")
+        if chunksize is not None:
+            raise ValueError("The 'chunksize' option is not supported with the 'pyarrow' engine")
+    else:
+        chunksize = validate_integer('chunksize', chunksize, 1)
+    nrows = kwds.get('nrows', None)
+    _validate_names(kwds.get('names', None))
+    parser = TextFileReader(filepath_or_buffer, **kwds)
+    if chunksize or iterator:
+        return parser
+    with parser:
+        return parser.read(nrows)
+
+@overload
+def read_csv(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, iterator: Literal[True], chunksize: int | None=..., **kwds: Unpack[_read_shared[HashableT]]) -> TextFileReader:
+    ...
+
+@overload
+def read_csv(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, iterator: bool=..., chunksize: int, **kwds: Unpack[_read_shared[HashableT]]) -> TextFileReader:
+    ...
+
+@overload
+def read_csv(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, iterator: Literal[False]=..., chunksize: None=..., **kwds: Unpack[_read_shared[HashableT]]) -> DataFrame:
+    ...
+
+@overload
+def read_csv(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, iterator: bool=..., chunksize: int | None=..., **kwds: Unpack[_read_shared[HashableT]]) -> DataFrame | TextFileReader:
+    ...
+
+@Appender(_doc_read_csv_and_table.format(func_name='read_csv', summary='Read a comma-separated values (csv) file into DataFrame.', see_also_func_name='read_table', see_also_func_summary='Read general delimited file into DataFrame.', na_values_str=fill('", "'.join(sorted(STR_NA_VALUES)), 70, subsequent_indent='    '), _default_sep="','", storage_options=_shared_docs['storage_options'], decompression_options=_shared_docs['decompression_options'] % 'filepath_or_buffer'))
+def read_csv(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, sep: str | None | lib.NoDefault=lib.no_default, delimiter: str | None | lib.NoDefault=None, header: int | Sequence[int] | None | Literal['infer']='infer', names: Sequence[Hashable] | None | lib.NoDefault=lib.no_default, index_col: IndexLabel | Literal[False] | None=None, usecols: UsecolsArgType=None, dtype: DtypeArg | None=None, engine: CSVEngine | None=None, converters: Mapping[HashableT, Callable] | None=None, true_values: list | None=None, false_values: list | None=None, skipinitialspace: bool=False, skiprows: list[int] | int | Callable[[Hashable], bool] | None=None, skipfooter: int=0, nrows: int | None=None, na_values: Hashable | Iterable[Hashable] | Mapping[Hashable, Iterable[Hashable]] | None=None, keep_default_na: bool=True, na_filter: bool=True, skip_blank_lines: bool=True, parse_dates: bool | Sequence[Hashable] | None=None, date_format: str | dict[Hashable, str] | None=None, dayfirst: bool=False, cache_dates: bool=True, iterator: bool=False, chunksize: int | None=None, compression: CompressionOptions='infer', thousands: str | None=None, decimal: str='.', lineterminator: str | None=None, quotechar: str='"', quoting: int=csv.QUOTE_MINIMAL, doublequote: bool=True, escapechar: str | None=None, comment: str | None=None, encoding: str | None=None, encoding_errors: str | None='strict', dialect: str | csv.Dialect | None=None, on_bad_lines: str='error', low_memory: bool=_c_parser_defaults['low_memory'], memory_map: bool=False, float_precision: Literal['high', 'legacy', 'round_trip'] | None=None, storage_options: StorageOptions | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default) -> DataFrame | TextFileReader:
+    kwds = locals().copy()
+    del kwds['filepath_or_buffer']
+    del kwds['sep']
+    kwds_defaults = _refine_defaults_read(dialect, delimiter, engine, sep, on_bad_lines, names, defaults={'delimiter': ','}, dtype_backend=dtype_backend)
+    kwds.update(kwds_defaults)
+    return _read(filepath_or_buffer, kwds)
+
+@overload
+def read_table(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, iterator: Literal[True], chunksize: int | None=..., **kwds: Unpack[_read_shared[HashableT]]) -> TextFileReader:
+    ...
+
+@overload
+def read_table(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, iterator: bool=..., chunksize: int, **kwds: Unpack[_read_shared[HashableT]]) -> TextFileReader:
+    ...
+
+@overload
+def read_table(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, iterator: Literal[False]=..., chunksize: None=..., **kwds: Unpack[_read_shared[HashableT]]) -> DataFrame:
+    ...
+
+@overload
+def read_table(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, iterator: bool=..., chunksize: int | None=..., **kwds: Unpack[_read_shared[HashableT]]) -> DataFrame | TextFileReader:
+    ...
+
+@Appender(_doc_read_csv_and_table.format(func_name='read_table', summary='Read general delimited file into DataFrame.', see_also_func_name='read_csv', see_also_func_summary='Read a comma-separated values (csv) file into DataFrame.', na_values_str=fill('", "'.join(sorted(STR_NA_VALUES)), 70, subsequent_indent='    '), _default_sep="'\\\\t' (tab-stop)", storage_options=_shared_docs['storage_options'], decompression_options=_shared_docs['decompression_options'] % 'filepath_or_buffer'))
+def read_table(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, sep: str | None | lib.NoDefault=lib.no_default, delimiter: str | None | lib.NoDefault=None, header: int | Sequence[int] | None | Literal['infer']='infer', names: Sequence[Hashable] | None | lib.NoDefault=lib.no_default, index_col: IndexLabel | Literal[False] | None=None, usecols: UsecolsArgType=None, dtype: DtypeArg | None=None, engine: CSVEngine | None=None, converters: Mapping[HashableT, Callable] | None=None, true_values: list | None=None, false_values: list | None=None, skipinitialspace: bool=False, skiprows: list[int] | int | Callable[[Hashable], bool] | None=None, skipfooter: int=0, nrows: int | None=None, na_values: Hashable | Iterable[Hashable] | Mapping[Hashable, Iterable[Hashable]] | None=None, keep_default_na: bool=True, na_filter: bool=True, skip_blank_lines: bool=True, parse_dates: bool | Sequence[Hashable] | None=None, date_format: str | dict[Hashable, str] | None=None, dayfirst: bool=False, cache_dates: bool=True, iterator: bool=False, chunksize: int | None=None, compression: CompressionOptions='infer', thousands: str | None=None, decimal: str='.', lineterminator: str | None=None, quotechar: str='"', quoting: int=csv.QUOTE_MINIMAL, doublequote: bool=True, escapechar: str | None=None, comment: str | None=None, encoding: str | None=None, encoding_errors: str | None='strict', dialect: str | csv.Dialect | None=None, on_bad_lines: str='error', low_memory: bool=_c_parser_defaults['low_memory'], memory_map: bool=False, float_precision: Literal['high', 'legacy', 'round_trip'] | None=None, storage_options: StorageOptions | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default) -> DataFrame | TextFileReader:
+    kwds = locals().copy()
+    del kwds['filepath_or_buffer']
+    del kwds['sep']
+    kwds_defaults = _refine_defaults_read(dialect, delimiter, engine, sep, on_bad_lines, names, defaults={'delimiter': '\t'}, dtype_backend=dtype_backend)
+    kwds.update(kwds_defaults)
+    return _read(filepath_or_buffer, kwds)
+
+@overload
+def read_fwf(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, colspecs: Sequence[tuple[int, int]] | str | None=..., widths: Sequence[int] | None=..., infer_nrows: int=..., iterator: Literal[True], chunksize: int | None=..., **kwds: Unpack[_read_shared[HashableT]]) -> TextFileReader:
+    ...
+
+@overload
+def read_fwf(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, colspecs: Sequence[tuple[int, int]] | str | None=..., widths: Sequence[int] | None=..., infer_nrows: int=..., iterator: bool=..., chunksize: int, **kwds: Unpack[_read_shared[HashableT]]) -> TextFileReader:
+    ...
+
+@overload
+def read_fwf(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, colspecs: Sequence[tuple[int, int]] | str | None=..., widths: Sequence[int] | None=..., infer_nrows: int=..., iterator: Literal[False]=..., chunksize: None=..., **kwds: Unpack[_read_shared[HashableT]]) -> DataFrame:
+    ...
+
+def read_fwf(filepath_or_buffer: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str], *, colspecs: Sequence[tuple[int, int]] | str | None='infer', widths: Sequence[int] | None=None, infer_nrows: int=100, iterator: bool=False, chunksize: int | None=None, **kwds: Unpack[_read_shared[HashableT]]) -> DataFrame | TextFileReader:
+    if colspecs is None and widths is None:
+        raise ValueError('Must specify either colspecs or widths')
+    if colspecs not in (None, 'infer') and widths is not None:
+        raise ValueError("You must specify only one of 'widths' and 'colspecs'")
+    if widths is not None:
+        (colspecs, col) = ([], 0)
+        for w in widths:
+            colspecs.append((col, col + w))
+            col += w
+    assert colspecs is not None
+    names = kwds.get('names')
+    if names is not None and names is not lib.no_default:
+        if len(names) != len(colspecs) and colspecs != 'infer':
+            len_index = 0
+            if kwds.get('index_col') is not None:
+                index_col: Any = kwds.get('index_col')
+                if index_col is not False:
+                    if not is_list_like(index_col):
+                        len_index = 1
+                    else:
+                        assert index_col is not lib.no_default
+                        len_index = len(index_col)
+            if kwds.get('usecols') is None and len(names) + len_index != len(colspecs):
+                raise ValueError('Length of colspecs must match length of names')
+    check_dtype_backend(kwds.setdefault('dtype_backend', lib.no_default))
+    return _read(filepath_or_buffer, kwds | {'colspecs': colspecs, 'infer_nrows': infer_nrows, 'engine': 'python-fwf', 'iterator': iterator, 'chunksize': chunksize})
+
+class TextFileReader(abc.Iterator):
+
+    def __init__(self, f: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | list, engine: CSVEngine | None=None, **kwds) -> None:
+        if engine is not None:
+            engine_specified = True
+        else:
+            engine = 'python'
+            engine_specified = False
+        self.engine = engine
+        self._engine_specified = kwds.get('engine_specified', engine_specified)
+        _validate_skipfooter(kwds)
+        dialect = _extract_dialect(kwds)
+        if dialect is not None:
+            if engine == 'pyarrow':
+                raise ValueError("The 'dialect' option is not supported with the 'pyarrow' engine")
+            kwds = _merge_with_dialect_properties(dialect, kwds)
+        if kwds.get('header', 'infer') == 'infer':
+            kwds['header'] = 0 if kwds.get('names') is None else None
+        self.orig_options = kwds
+        self._currow = 0
+        options = self._get_options_with_defaults(engine)
+        options['storage_options'] = kwds.get('storage_options', None)
+        self.chunksize = options.pop('chunksize', None)
+        self.nrows = options.pop('nrows', None)
+        self._check_file_or_buffer(f, engine)
+        (self.options, self.engine) = self._clean_options(options, engine)
+        if 'has_index_names' in kwds:
+            self.options['has_index_names'] = kwds['has_index_names']
+        self.handles: IOHandles | None = None
+        self._engine = self._make_engine(f, self.engine)
+
+    def close(self) -> None:
+        if self.handles is not None:
+            self.handles.close()
+        self._engine.close()
+
+    def _get_options_with_defaults(self, engine: CSVEngine) -> dict[str, Any]:
+        kwds = self.orig_options
+        options = {}
+        default: object | None
+        for (argname, default) in parser_defaults.items():
+            value = kwds.get(argname, default)
+            if engine == 'pyarrow' and argname in _pyarrow_unsupported and (value != default) and (value != getattr(value, 'value', default)):
+                raise ValueError(f"The {argname!r} option is not supported with the 'pyarrow' engine")
+            options[argname] = value
+        for (argname, default) in _c_parser_defaults.items():
+            if argname in kwds:
+                value = kwds[argname]
+                if engine != 'c' and value != default:
+                    if 'python' in engine and argname not in _python_unsupported:
+                        pass
+                    elif 'pyarrow' in engine and argname not in _pyarrow_unsupported:
+                        pass
+                    else:
+                        raise ValueError(f'The {argname!r} option is not supported with the {engine!r} engine')
+            else:
+                value = default
+            options[argname] = value
+        if engine == 'python-fwf':
+            for (argname, default) in _fwf_defaults.items():
+                options[argname] = kwds.get(argname, default)
+        return options
+
+    def _check_file_or_buffer(self, f, engine: CSVEngine) -> None:
+        if is_file_like(f) and engine != 'c' and (not hasattr(f, '__iter__')):
+            raise ValueError("The 'python' engine cannot iterate through this file buffer.")
+        if hasattr(f, 'encoding'):
+            file_encoding = f.encoding
+            orig_reader_enc = self.orig_options.get('encoding', None)
+            any_none = file_encoding is None or orig_reader_enc is None
+            if file_encoding != orig_reader_enc and (not any_none):
+                file_path = getattr(f, 'name', None)
+                raise ValueError(f'The specified reader encoding {orig_reader_enc} is different from the encoding {file_encoding} of file {file_path}.')
+
+    def _clean_options(self, options: dict[str, Any], engine: CSVEngine) -> tuple[dict[str, Any], CSVEngine]:
+        result = options.copy()
+        fallback_reason = None
+        if engine == 'c':
+            if options['skipfooter'] > 0:
+                fallback_reason = "the 'c' engine does not support skipfooter"
+                engine = 'python'
+        sep = options['delimiter']
+        if sep is not None and len(sep) > 1:
+            if engine == 'c' and sep == '\\s+':
+                result['delim_whitespace'] = True
+                del result['delimiter']
+            elif engine not in ('python', 'python-fwf'):
+                fallback_reason = f"the '{engine}' engine does not support regex separators (separators > 1 char and different from '\\s+' are interpreted as regex)"
+                engine = 'python'
+        elif sep is not None:
+            encodeable = True
+            encoding = sys.getfilesystemencoding() or 'utf-8'
+            try:
+                if len(sep.encode(encoding)) > 1:
+                    encodeable = False
+            except UnicodeDecodeError:
+                encodeable = False
+            if not encodeable and engine not in ('python', 'python-fwf'):
+                fallback_reason = f"the separator encoded in {encoding} is > 1 char long, and the '{engine}' engine does not support such separators"
+                engine = 'python'
+        quotechar = options['quotechar']
+        if quotechar is not None and isinstance(quotechar, (str, bytes)):
+            if len(quotechar) == 1 and ord(quotechar) > 127 and (engine not in ('python', 'python-fwf')):
+                fallback_reason = f"ord(quotechar) > 127, meaning the quotechar is larger than one byte, and the '{engine}' engine does not support such quotechars"
+                engine = 'python'
+        if fallback_reason and self._engine_specified:
+            raise ValueError(fallback_reason)
+        if engine == 'c':
+            for arg in _c_unsupported:
+                del result[arg]
+        if 'python' in engine:
+            for arg in _python_unsupported:
+                if fallback_reason and result[arg] != _c_parser_defaults.get(arg):
+                    raise ValueError(f"Falling back to the 'python' engine because {fallback_reason}, but this causes {arg!r} to be ignored as it is not supported by the 'python' engine.")
+                del result[arg]
+        if fallback_reason:
+            warnings.warn(f"Falling back to the 'python' engine because {fallback_reason}; you can avoid this warning by specifying engine='python'.", ParserWarning, stacklevel=find_stack_level())
+        index_col = options['index_col']
+        names = options['names']
+        converters = options['converters']
+        na_values = options['na_values']
+        skiprows = options['skiprows']
+        validate_header_arg(options['header'])
+        if index_col is True:
+            raise ValueError("The value of index_col couldn't be 'True'")
+        if is_index_col(index_col):
+            if not isinstance(index_col, (list, tuple, np.ndarray)):
+                index_col = [index_col]
+        result['index_col'] = index_col
+        names = list(names) if names is not None else names
+        if converters is not None:
+            if not isinstance(converters, dict):
+                raise TypeError(f'Type converters must be a dict or subclass, input was a {type(converters).__name__}')
+        else:
+            converters = {}
+        keep_default_na = options['keep_default_na']
+        floatify = engine != 'pyarrow'
+        (na_values, na_fvalues) = _clean_na_values(na_values, keep_default_na, floatify=floatify)
+        if engine == 'pyarrow':
+            if not is_integer(skiprows) and skiprows is not None:
+                raise ValueError("skiprows argument must be an integer when using engine='pyarrow'")
+        else:
+            if is_integer(skiprows):
+                skiprows = range(skiprows)
+            if skiprows is None:
+                skiprows = set()
+            elif not callable(skiprows):
+                skiprows = set(skiprows)
+        result['names'] = names
+        result['converters'] = converters
+        result['na_values'] = na_values
+        result['na_fvalues'] = na_fvalues
+        result['skiprows'] = skiprows
+        return (result, engine)
+
+    def __next__(self) -> DataFrame:
+        try:
+            return self.get_chunk()
+        except StopIteration:
+            self.close()
+            raise
+
+    def _make_engine(self, f: FilePath | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | list | IO, engine: CSVEngine='c') -> ParserBase:
+        mapping: dict[str, type[ParserBase]] = {'c': CParserWrapper, 'python': PythonParser, 'pyarrow': ArrowParserWrapper, 'python-fwf': FixedWidthFieldParser}
+        if engine not in mapping:
+            raise ValueError(f'Unknown engine: {engine} (valid options are {mapping.keys()})')
+        if not isinstance(f, list):
+            is_text = True
+            mode = 'r'
+            if engine == 'pyarrow':
+                is_text = False
+                mode = 'rb'
+            elif engine == 'c' and self.options.get('encoding', 'utf-8') == 'utf-8' and isinstance(stringify_path(f), str):
+                is_text = False
+                if 'b' not in mode:
+                    mode += 'b'
+            self.handles = get_handle(f, mode, encoding=self.options.get('encoding', None), compression=self.options.get('compression', None), memory_map=self.options.get('memory_map', False), is_text=is_text, errors=self.options.get('encoding_errors', 'strict'), storage_options=self.options.get('storage_options', None))
+            assert self.handles is not None
+            f = self.handles.handle
+        elif engine != 'python':
+            msg = f'Invalid file path or buffer object type: {type(f)}'
+            raise ValueError(msg)
+        try:
+            return mapping[engine](f, **self.options)
+        except Exception:
+            if self.handles is not None:
+                self.handles.close()
+            raise
+
+    def _failover_to_python(self) -> None:
+        raise AbstractMethodError(self)
+
+    def read(self, nrows: int | None=None) -> DataFrame:
+        if self.engine == 'pyarrow':
+            try:
+                df = self._engine.read()
+            except Exception:
+                self.close()
+                raise
+        else:
+            nrows = validate_integer('nrows', nrows)
+            try:
+                (index, columns, col_dict) = self._engine.read(nrows)
+            except Exception:
+                self.close()
+                raise
+            if index is None:
+                if col_dict:
+                    new_rows = len(next(iter(col_dict.values())))
+                    index = RangeIndex(self._currow, self._currow + new_rows)
+                else:
+                    new_rows = 0
+            else:
+                new_rows = len(index)
+            if hasattr(self, 'orig_options'):
+                dtype_arg = self.orig_options.get('dtype', None)
+            else:
+                dtype_arg = None
+            if isinstance(dtype_arg, dict):
+                dtype = defaultdict(lambda : None)
+                dtype.update(dtype_arg)
+            elif dtype_arg is not None and pandas_dtype(dtype_arg) in (np.str_, np.object_):
+                dtype = defaultdict(lambda : dtype_arg)
+            else:
+                dtype = None
+            if dtype is not None:
+                new_col_dict = {}
+                for (k, v) in col_dict.items():
+                    d = dtype[k] if pandas_dtype(dtype[k]) in (np.str_, np.object_) else None
+                    new_col_dict[k] = Series(v, index=index, dtype=d, copy=False)
+            else:
+                new_col_dict = col_dict
+            df = DataFrame(new_col_dict, columns=columns, index=index, copy=False)
+            self._currow += new_rows
+        return df
+
+    def get_chunk(self, size: int | None=None) -> DataFrame:
+        if size is None:
+            size = self.chunksize
+        if self.nrows is not None:
+            if self._currow >= self.nrows:
+                raise StopIteration
+            if size is None:
+                size = self.nrows - self._currow
+            else:
+                size = min(size, self.nrows - self._currow)
+        return self.read(nrows=size)
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
+        self.close()
+
+def TextParser(*args, **kwds) -> TextFileReader:
+    kwds['engine'] = 'python'
+    return TextFileReader(*args, **kwds)
+
+def _clean_na_values(na_values, keep_default_na: bool=True, floatify: bool=True):
+    na_fvalues: set | dict
+    if na_values is None:
+        if keep_default_na:
+            na_values = STR_NA_VALUES
+        else:
+            na_values = set()
+        na_fvalues = set()
+    elif isinstance(na_values, dict):
+        old_na_values = na_values.copy()
+        na_values = {}
+        for (k, v) in old_na_values.items():
+            if not is_list_like(v):
+                v = [v]
+            if keep_default_na:
+                v = set(v) | STR_NA_VALUES
+            na_values[k] = _stringify_na_values(v, floatify)
+        na_fvalues = {k: _floatify_na_values(v) for (k, v) in na_values.items()}
+    else:
+        if not is_list_like(na_values):
+            na_values = [na_values]
+        na_values = _stringify_na_values(na_values, floatify)
+        if keep_default_na:
+            na_values = na_values | STR_NA_VALUES
+        na_fvalues = _floatify_na_values(na_values)
+    return (na_values, na_fvalues)
+
+def _floatify_na_values(na_values):
+    result = set()
+    for v in na_values:
+        try:
+            v = float(v)
+            if not np.isnan(v):
+                result.add(v)
+        except (TypeError, ValueError, OverflowError):
+            pass
+    return result
+
+def _stringify_na_values(na_values, floatify: bool) -> set[str | float]:
+    result: list[str | float] = []
+    for x in na_values:
+        result.append(str(x))
+        result.append(x)
+        try:
+            v = float(x)
+            if v == int(v):
+                v = int(v)
+                result.append(f'{v}.0')
+                result.append(str(v))
+            if floatify:
+                result.append(v)
+        except (TypeError, ValueError, OverflowError):
+            pass
+        if floatify:
+            try:
+                result.append(int(x))
+            except (TypeError, ValueError, OverflowError):
+                pass
+    return set(result)
+
+def _refine_defaults_read(dialect: str | csv.Dialect | None, delimiter: str | None | lib.NoDefault, engine: CSVEngine | None, sep: str | None | lib.NoDefault, on_bad_lines: str | Callable, names: Sequence[Hashable] | None | lib.NoDefault, defaults: dict[str, Any], dtype_backend: DtypeBackend | lib.NoDefault):
+    delim_default = defaults['delimiter']
+    kwds: dict[str, Any] = {}
+    if dialect is not None:
+        kwds['sep_override'] = delimiter is None and (sep is lib.no_default or sep == delim_default)
+    if delimiter and sep is not lib.no_default:
+        raise ValueError('Specified a sep and a delimiter; you can only specify one.')
+    kwds['names'] = None if names is lib.no_default else names
+    if delimiter is None:
+        delimiter = sep
+    if delimiter == '\n':
+        raise ValueError('Specified \\n as separator or delimiter. This forces the python engine which does not accept a line terminator. Hence it is not allowed to use the line terminator as separator.')
+    if delimiter is lib.no_default:
+        kwds['delimiter'] = delim_default
+    else:
+        kwds['delimiter'] = delimiter
+    if engine is not None:
+        kwds['engine_specified'] = True
+    else:
+        kwds['engine'] = 'c'
+        kwds['engine_specified'] = False
+    if on_bad_lines == 'error':
+        kwds['on_bad_lines'] = ParserBase.BadLineHandleMethod.ERROR
+    elif on_bad_lines == 'warn':
+        kwds['on_bad_lines'] = ParserBase.BadLineHandleMethod.WARN
+    elif on_bad_lines == 'skip':
+        kwds['on_bad_lines'] = ParserBase.BadLineHandleMethod.SKIP
+    elif callable(on_bad_lines):
+        if engine not in ['python', 'pyarrow']:
+            raise ValueError("on_bad_line can only be a callable function if engine='python' or 'pyarrow'")
+        kwds['on_bad_lines'] = on_bad_lines
+    else:
+        raise ValueError(f'Argument {on_bad_lines} is invalid for on_bad_lines')
+    check_dtype_backend(dtype_backend)
+    kwds['dtype_backend'] = dtype_backend
+    return kwds
+
+def _extract_dialect(kwds: dict[str, Any]) -> csv.Dialect | None:
+    if kwds.get('dialect') is None:
+        return None
+    dialect = kwds['dialect']
+    if dialect in csv.list_dialects():
+        dialect = csv.get_dialect(dialect)
+    _validate_dialect(dialect)
+    return dialect
+MANDATORY_DIALECT_ATTRS = ('delimiter', 'doublequote', 'escapechar', 'skipinitialspace', 'quotechar', 'quoting')
+
+def _validate_dialect(dialect: csv.Dialect) -> None:
+    for param in MANDATORY_DIALECT_ATTRS:
+        if not hasattr(dialect, param):
+            raise ValueError(f'Invalid dialect {dialect} provided')
+
+def _merge_with_dialect_properties(dialect: csv.Dialect, defaults: dict[str, Any]) -> dict[str, Any]:
+    kwds = defaults.copy()
+    for param in MANDATORY_DIALECT_ATTRS:
+        dialect_val = getattr(dialect, param)
+        parser_default = parser_defaults[param]
+        provided = kwds.get(param, parser_default)
+        conflict_msgs = []
+        if provided not in (parser_default, dialect_val):
+            msg = f"Conflicting values for '{param}': '{provided}' was provided, but the dialect specifies '{dialect_val}'. Using the dialect-specified value."
+            if not (param == 'delimiter' and kwds.pop('sep_override', False)):
+                conflict_msgs.append(msg)
+        if conflict_msgs:
+            warnings.warn('\n\n'.join(conflict_msgs), ParserWarning, stacklevel=find_stack_level())
+        kwds[param] = dialect_val
+    return kwds
+
+def _validate_skipfooter(kwds: dict[str, Any]) -> None:
+    if kwds.get('skipfooter'):
+        if kwds.get('iterator') or kwds.get('chunksize'):
+            raise ValueError("'skipfooter' not supported for iteration")
+        if kwds.get('nrows'):
+            raise ValueError("'skipfooter' not supported with 'nrows'")
+
+# File: pandas-main/pandas/io/pickle.py
+""""""
+from __future__ import annotations
+import pickle
+from typing import TYPE_CHECKING, Any
+import warnings
+from pandas.compat import pickle_compat
+from pandas.util._decorators import doc
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.common import get_handle
+if TYPE_CHECKING:
+    from pandas._typing import CompressionOptions, FilePath, ReadPickleBuffer, StorageOptions, WriteBuffer
+    from pandas import DataFrame, Series
+
+@doc(storage_options=_shared_docs['storage_options'], compression_options=_shared_docs['compression_options'] % 'filepath_or_buffer')
+def to_pickle(obj: Any, filepath_or_buffer: FilePath | WriteBuffer[bytes], compression: CompressionOptions='infer', protocol: int=pickle.HIGHEST_PROTOCOL, storage_options: StorageOptions | None=None) -> None:
+    if protocol < 0:
+        protocol = pickle.HIGHEST_PROTOCOL
+    with get_handle(filepath_or_buffer, 'wb', compression=compression, is_text=False, storage_options=storage_options) as handles:
+        pickle.dump(obj, handles.handle, protocol=protocol)
+
+@doc(storage_options=_shared_docs['storage_options'], decompression_options=_shared_docs['decompression_options'] % 'filepath_or_buffer')
+def read_pickle(filepath_or_buffer: FilePath | ReadPickleBuffer, compression: CompressionOptions='infer', storage_options: StorageOptions | None=None) -> DataFrame | Series:
+    excs_to_catch = (AttributeError, ImportError, ModuleNotFoundError, TypeError)
+    with get_handle(filepath_or_buffer, 'rb', compression=compression, is_text=False, storage_options=storage_options) as handles:
+        try:
+            with warnings.catch_warnings(record=True):
+                warnings.simplefilter('ignore', Warning)
+                return pickle.load(handles.handle)
+        except excs_to_catch:
+            handles.handle.seek(0)
+            return pickle_compat.Unpickler(handles.handle).load()
+
+# File: pandas-main/pandas/io/pytables.py
+""""""
+from __future__ import annotations
+from contextlib import suppress
+import copy
+from datetime import date, tzinfo
+import itertools
+import os
+import re
+from textwrap import dedent
+from typing import TYPE_CHECKING, Any, Final, Literal, cast, overload
+import warnings
+import numpy as np
+from pandas._config import config, get_option, using_string_dtype
+from pandas._libs import lib, writers as libwriters
+from pandas._libs.lib import is_string_array
+from pandas._libs.tslibs import timezones
+from pandas.compat._optional import import_optional_dependency
+from pandas.compat.pickle_compat import patch_pickle
+from pandas.errors import AttributeConflictWarning, ClosedFileError, IncompatibilityWarning, PerformanceWarning, PossibleDataLossError
+from pandas.util._decorators import cache_readonly
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import ensure_object, is_bool_dtype, is_complex_dtype, is_list_like, is_string_dtype, needs_i8_conversion
+from pandas.core.dtypes.dtypes import CategoricalDtype, DatetimeTZDtype, ExtensionDtype, PeriodDtype
+from pandas.core.dtypes.missing import array_equivalent
+from pandas import DataFrame, DatetimeIndex, Index, MultiIndex, PeriodIndex, RangeIndex, Series, StringDtype, TimedeltaIndex, concat, isna
+from pandas.core.arrays import Categorical, DatetimeArray, PeriodArray
+from pandas.core.arrays.datetimes import tz_to_dtype
+import pandas.core.common as com
+from pandas.core.computation.pytables import PyTablesExpr, maybe_expression
+from pandas.core.construction import extract_array
+from pandas.core.indexes.api import ensure_index
+from pandas.io.common import stringify_path
+from pandas.io.formats.printing import adjoin, pprint_thing
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Iterator, Sequence
+    from types import TracebackType
+    from tables import Col, File, Node
+    from pandas._typing import AnyArrayLike, ArrayLike, AxisInt, DtypeArg, FilePath, Self, Shape, npt
+    from pandas.core.internals.blocks import Block
+_version = '0.15.2'
+_default_encoding = 'UTF-8'
+
+def _ensure_encoding(encoding: str | None) -> str:
+    if encoding is None:
+        encoding = _default_encoding
+    return encoding
+
+def _ensure_str(name):
+    if isinstance(name, str):
+        name = str(name)
+    return name
+Term = PyTablesExpr
+
+def _ensure_term(where, scope_level: int):
+    level = scope_level + 1
+    if isinstance(where, (list, tuple)):
+        where = [Term(term, scope_level=level + 1) if maybe_expression(term) else term for term in where if term is not None]
+    elif maybe_expression(where):
+        where = Term(where, scope_level=level)
+    return where if where is None or len(where) else None
+incompatibility_doc: Final = '\nwhere criteria is being ignored as this version [%s] is too old (or\nnot-defined), read the file in and write it out to a new file to upgrade (with\nthe copy_to method)\n'
+attribute_conflict_doc: Final = '\nthe [%s] attribute of the existing index is [%s] which conflicts with the new\n[%s], resetting the attribute to None\n'
+performance_doc: Final = '\nyour performance may suffer as PyTables will pickle object types that it cannot\nmap directly to c-types [inferred_type->%s,key->%s] [items->%s]\n'
+_FORMAT_MAP = {'f': 'fixed', 'fixed': 'fixed', 't': 'table', 'table': 'table'}
+_AXES_MAP = {DataFrame: [0]}
+dropna_doc: Final = '\n: boolean\n    drop ALL nan rows when appending to a table\n'
+format_doc: Final = "\n: format\n    default format writing format, if None, then\n    put will default to 'fixed' and append will default to 'table'\n"
+with config.config_prefix('io.hdf'):
+    config.register_option('dropna_table', False, dropna_doc, validator=config.is_bool)
+    config.register_option('default_format', None, format_doc, validator=config.is_one_of_factory(['fixed', 'table', None]))
+_table_mod = None
+_table_file_open_policy_is_strict = False
+
+def _tables():
+    global _table_mod
+    global _table_file_open_policy_is_strict
+    if _table_mod is None:
+        import tables
+        _table_mod = tables
+        with suppress(AttributeError):
+            _table_file_open_policy_is_strict = tables.file._FILE_OPEN_POLICY == 'strict'
+    return _table_mod
+
+def to_hdf(path_or_buf: FilePath | HDFStore, key: str, value: DataFrame | Series, mode: str='a', complevel: int | None=None, complib: str | None=None, append: bool=False, format: str | None=None, index: bool=True, min_itemsize: int | dict[str, int] | None=None, nan_rep=None, dropna: bool | None=None, data_columns: Literal[True] | list[str] | None=None, errors: str='strict', encoding: str='UTF-8') -> None:
+    if append:
+        f = lambda store: store.append(key, value, format=format, index=index, min_itemsize=min_itemsize, nan_rep=nan_rep, dropna=dropna, data_columns=data_columns, errors=errors, encoding=encoding)
+    else:
+        f = lambda store: store.put(key, value, format=format, index=index, min_itemsize=min_itemsize, nan_rep=nan_rep, data_columns=data_columns, errors=errors, encoding=encoding, dropna=dropna)
+    if isinstance(path_or_buf, HDFStore):
+        f(path_or_buf)
+    else:
+        path_or_buf = stringify_path(path_or_buf)
+        with HDFStore(path_or_buf, mode=mode, complevel=complevel, complib=complib) as store:
+            f(store)
+
+def read_hdf(path_or_buf: FilePath | HDFStore, key=None, mode: str='r', errors: str='strict', where: str | list | None=None, start: int | None=None, stop: int | None=None, columns: list[str] | None=None, iterator: bool=False, chunksize: int | None=None, **kwargs):
+    if mode not in ['r', 'r+', 'a']:
+        raise ValueError(f'mode {mode} is not allowed while performing a read. Allowed modes are r, r+ and a.')
+    if where is not None:
+        where = _ensure_term(where, scope_level=1)
+    if isinstance(path_or_buf, HDFStore):
+        if not path_or_buf.is_open:
+            raise OSError('The HDFStore must be open for reading.')
+        store = path_or_buf
+        auto_close = False
+    else:
+        path_or_buf = stringify_path(path_or_buf)
+        if not isinstance(path_or_buf, str):
+            raise NotImplementedError('Support for generic buffers has not been implemented.')
+        try:
+            exists = os.path.exists(path_or_buf)
+        except (TypeError, ValueError):
+            exists = False
+        if not exists:
+            raise FileNotFoundError(f'File {path_or_buf} does not exist')
+        store = HDFStore(path_or_buf, mode=mode, errors=errors, **kwargs)
+        auto_close = True
+    try:
+        if key is None:
+            groups = store.groups()
+            if len(groups) == 0:
+                raise ValueError('Dataset(s) incompatible with Pandas data types, not table, or no datasets found in HDF5 file.')
+            candidate_only_group = groups[0]
+            for group_to_check in groups[1:]:
+                if not _is_metadata_of(group_to_check, candidate_only_group):
+                    raise ValueError('key must be provided when HDF5 file contains multiple datasets.')
+            key = candidate_only_group._v_pathname
+        return store.select(key, where=where, start=start, stop=stop, columns=columns, iterator=iterator, chunksize=chunksize, auto_close=auto_close)
+    except (ValueError, TypeError, LookupError):
+        if not isinstance(path_or_buf, HDFStore):
+            with suppress(AttributeError):
+                store.close()
+        raise
+
+def _is_metadata_of(group: Node, parent_group: Node) -> bool:
+    if group._v_depth <= parent_group._v_depth:
+        return False
+    current = group
+    while current._v_depth > 1:
+        parent = current._v_parent
+        if parent == parent_group and current._v_name == 'meta':
+            return True
+        current = current._v_parent
+    return False
+
+class HDFStore:
+    _handle: File | None
+    _mode: str
+
+    def __init__(self, path, mode: str='a', complevel: int | None=None, complib=None, fletcher32: bool=False, **kwargs) -> None:
+        if 'format' in kwargs:
+            raise ValueError('format is not a defined argument for HDFStore')
+        tables = import_optional_dependency('tables')
+        if complib is not None and complib not in tables.filters.all_complibs:
+            raise ValueError(f'complib only supports {tables.filters.all_complibs} compression.')
+        if complib is None and complevel is not None:
+            complib = tables.filters.default_complib
+        self._path = stringify_path(path)
+        if mode is None:
+            mode = 'a'
+        self._mode = mode
+        self._handle = None
+        self._complevel = complevel if complevel else 0
+        self._complib = complib
+        self._fletcher32 = fletcher32
+        self._filters = None
+        self.open(mode=mode, **kwargs)
+
+    def __fspath__(self) -> str:
+        return self._path
+
+    @property
+    def root(self):
+        self._check_if_open()
+        assert self._handle is not None
+        return self._handle.root
+
+    @property
+    def filename(self) -> str:
+        return self._path
+
+    def __getitem__(self, key: str):
+        return self.get(key)
+
+    def __setitem__(self, key: str, value) -> None:
+        self.put(key, value)
+
+    def __delitem__(self, key: str) -> int | None:
+        return self.remove(key)
+
+    def __getattr__(self, name: str):
+        try:
+            return self.get(name)
+        except (KeyError, ClosedFileError):
+            pass
+        raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+
+    def __contains__(self, key: str) -> bool:
+        node = self.get_node(key)
+        if node is not None:
+            name = node._v_pathname
+            if key in (name, name[1:]):
+                return True
+        return False
+
+    def __len__(self) -> int:
+        return len(self.groups())
+
+    def __repr__(self) -> str:
+        pstr = pprint_thing(self._path)
+        return f'{type(self)}\nFile path: {pstr}\n'
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
+        self.close()
+
+    def keys(self, include: str='pandas') -> list[str]:
+        if include == 'pandas':
+            return [n._v_pathname for n in self.groups()]
+        elif include == 'native':
+            assert self._handle is not None
+            return [n._v_pathname for n in self._handle.walk_nodes('/', classname='Table')]
+        raise ValueError(f"`include` should be either 'pandas' or 'native' but is '{include}'")
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.keys())
+
+    def items(self) -> Iterator[tuple[str, list]]:
+        for g in self.groups():
+            yield (g._v_pathname, g)
+
+    def open(self, mode: str='a', **kwargs) -> None:
+        tables = _tables()
+        if self._mode != mode:
+            if self._mode in ['a', 'w'] and mode in ['r', 'r+']:
+                pass
+            elif mode in ['w']:
+                if self.is_open:
+                    raise PossibleDataLossError(f'Re-opening the file [{self._path}] with mode [{self._mode}] will delete the current file!')
+            self._mode = mode
+        if self.is_open:
+            self.close()
+        if self._complevel and self._complevel > 0:
+            self._filters = _tables().Filters(self._complevel, self._complib, fletcher32=self._fletcher32)
+        if _table_file_open_policy_is_strict and self.is_open:
+            msg = 'Cannot open HDF5 file, which is already opened, even in read-only mode.'
+            raise ValueError(msg)
+        self._handle = tables.open_file(self._path, self._mode, **kwargs)
+
+    def close(self) -> None:
+        if self._handle is not None:
+            self._handle.close()
+        self._handle = None
+
+    @property
+    def is_open(self) -> bool:
+        if self._handle is None:
+            return False
+        return bool(self._handle.isopen)
+
+    def flush(self, fsync: bool=False) -> None:
+        if self._handle is not None:
+            self._handle.flush()
+            if fsync:
+                with suppress(OSError):
+                    os.fsync(self._handle.fileno())
+
+    def get(self, key: str):
+        with patch_pickle():
+            group = self.get_node(key)
+            if group is None:
+                raise KeyError(f'No object named {key} in the file')
+            return self._read_group(group)
+
+    def select(self, key: str, where=None, start=None, stop=None, columns=None, iterator: bool=False, chunksize: int | None=None, auto_close: bool=False):
+        group = self.get_node(key)
+        if group is None:
+            raise KeyError(f'No object named {key} in the file')
+        where = _ensure_term(where, scope_level=1)
+        s = self._create_storer(group)
+        s.infer_axes()
+
+        def func(_start, _stop, _where):
+            return s.read(start=_start, stop=_stop, where=_where, columns=columns)
+        it = TableIterator(self, s, func, where=where, nrows=s.nrows, start=start, stop=stop, iterator=iterator, chunksize=chunksize, auto_close=auto_close)
+        return it.get_result()
+
+    def select_as_coordinates(self, key: str, where=None, start: int | None=None, stop: int | None=None):
+        where = _ensure_term(where, scope_level=1)
+        tbl = self.get_storer(key)
+        if not isinstance(tbl, Table):
+            raise TypeError('can only read_coordinates with a table')
+        return tbl.read_coordinates(where=where, start=start, stop=stop)
+
+    def select_column(self, key: str, column: str, start: int | None=None, stop: int | None=None):
+        tbl = self.get_storer(key)
+        if not isinstance(tbl, Table):
+            raise TypeError('can only read_column with a table')
+        return tbl.read_column(column=column, start=start, stop=stop)
+
+    def select_as_multiple(self, keys, where=None, selector=None, columns=None, start=None, stop=None, iterator: bool=False, chunksize: int | None=None, auto_close: bool=False):
+        where = _ensure_term(where, scope_level=1)
+        if isinstance(keys, (list, tuple)) and len(keys) == 1:
+            keys = keys[0]
+        if isinstance(keys, str):
+            return self.select(key=keys, where=where, columns=columns, start=start, stop=stop, iterator=iterator, chunksize=chunksize, auto_close=auto_close)
+        if not isinstance(keys, (list, tuple)):
+            raise TypeError('keys must be a list/tuple')
+        if not len(keys):
+            raise ValueError('keys must have a non-zero length')
+        if selector is None:
+            selector = keys[0]
+        tbls = [self.get_storer(k) for k in keys]
+        s = self.get_storer(selector)
+        nrows = None
+        for (t, k) in itertools.chain([(s, selector)], zip(tbls, keys)):
+            if t is None:
+                raise KeyError(f'Invalid table [{k}]')
+            if not t.is_table:
+                raise TypeError(f'object [{t.pathname}] is not a table, and cannot be used in all select as multiple')
+            if nrows is None:
+                nrows = t.nrows
+            elif t.nrows != nrows:
+                raise ValueError('all tables must have exactly the same nrows!')
+        _tbls = [x for x in tbls if isinstance(x, Table)]
+        axis = {t.non_index_axes[0][0] for t in _tbls}.pop()
+
+        def func(_start, _stop, _where):
+            objs = [t.read(where=_where, columns=columns, start=_start, stop=_stop) for t in tbls]
+            return concat(objs, axis=axis, verify_integrity=False)._consolidate()
+        it = TableIterator(self, s, func, where=where, nrows=nrows, start=start, stop=stop, iterator=iterator, chunksize=chunksize, auto_close=auto_close)
+        return it.get_result(coordinates=True)
+
+    def put(self, key: str, value: DataFrame | Series, format=None, index: bool=True, append: bool=False, complib=None, complevel: int | None=None, min_itemsize: int | dict[str, int] | None=None, nan_rep=None, data_columns: Literal[True] | list[str] | None=None, encoding=None, errors: str='strict', track_times: bool=True, dropna: bool=False) -> None:
+        if format is None:
+            format = get_option('io.hdf.default_format') or 'fixed'
+        format = self._validate_format(format)
+        self._write_to_group(key, value, format=format, index=index, append=append, complib=complib, complevel=complevel, min_itemsize=min_itemsize, nan_rep=nan_rep, data_columns=data_columns, encoding=encoding, errors=errors, track_times=track_times, dropna=dropna)
+
+    def remove(self, key: str, where=None, start=None, stop=None) -> int | None:
+        where = _ensure_term(where, scope_level=1)
+        try:
+            s = self.get_storer(key)
+        except KeyError:
+            raise
+        except AssertionError:
+            raise
+        except Exception as err:
+            if where is not None:
+                raise ValueError('trying to remove a node with a non-None where clause!') from err
+            node = self.get_node(key)
+            if node is not None:
+                node._f_remove(recursive=True)
+                return None
+        if com.all_none(where, start, stop):
+            s.group._f_remove(recursive=True)
+            return None
+        if not s.is_table:
+            raise ValueError('can only remove with where on objects written as tables')
+        return s.delete(where=where, start=start, stop=stop)
+
+    def append(self, key: str, value: DataFrame | Series, format=None, axes=None, index: bool | list[str]=True, append: bool=True, complib=None, complevel: int | None=None, columns=None, min_itemsize: int | dict[str, int] | None=None, nan_rep=None, chunksize: int | None=None, expectedrows=None, dropna: bool | None=None, data_columns: Literal[True] | list[str] | None=None, encoding=None, errors: str='strict') -> None:
+        if columns is not None:
+            raise TypeError('columns is not a supported keyword in append, try data_columns')
+        if dropna is None:
+            dropna = get_option('io.hdf.dropna_table')
+        if format is None:
+            format = get_option('io.hdf.default_format') or 'table'
+        format = self._validate_format(format)
+        self._write_to_group(key, value, format=format, axes=axes, index=index, append=append, complib=complib, complevel=complevel, min_itemsize=min_itemsize, nan_rep=nan_rep, chunksize=chunksize, expectedrows=expectedrows, dropna=dropna, data_columns=data_columns, encoding=encoding, errors=errors)
+
+    def append_to_multiple(self, d: dict, value, selector, data_columns=None, axes=None, dropna: bool=False, **kwargs) -> None:
+        if axes is not None:
+            raise TypeError('axes is currently not accepted as a parameter to append_to_multiple; you can create the tables independently instead')
+        if not isinstance(d, dict):
+            raise ValueError('append_to_multiple must have a dictionary specified as the way to split the value')
+        if selector not in d:
+            raise ValueError('append_to_multiple requires a selector that is in passed dict')
+        axis = next(iter(set(range(value.ndim)) - set(_AXES_MAP[type(value)])))
+        remain_key = None
+        remain_values: list = []
+        for (k, v) in d.items():
+            if v is None:
+                if remain_key is not None:
+                    raise ValueError('append_to_multiple can only have one value in d that is None')
+                remain_key = k
+            else:
+                remain_values.extend(v)
+        if remain_key is not None:
+            ordered = value.axes[axis]
+            ordd = ordered.difference(Index(remain_values))
+            ordd = sorted(ordered.get_indexer(ordd))
+            d[remain_key] = ordered.take(ordd)
+        if data_columns is None:
+            data_columns = d[selector]
+        if dropna:
+            idxs = (value[cols].dropna(how='all').index for cols in d.values())
+            valid_index = next(idxs)
+            for index in idxs:
+                valid_index = valid_index.intersection(index)
+            value = value.loc[valid_index]
+        min_itemsize = kwargs.pop('min_itemsize', None)
+        for (k, v) in d.items():
+            dc = data_columns if k == selector else None
+            val = value.reindex(v, axis=axis)
+            filtered = {key: value for (key, value) in min_itemsize.items() if key in v} if min_itemsize is not None else None
+            self.append(k, val, data_columns=dc, min_itemsize=filtered, **kwargs)
+
+    def create_table_index(self, key: str, columns=None, optlevel: int | None=None, kind: str | None=None) -> None:
+        _tables()
+        s = self.get_storer(key)
+        if s is None:
+            return
+        if not isinstance(s, Table):
+            raise TypeError('cannot create table index on a Fixed format store')
+        s.create_index(columns=columns, optlevel=optlevel, kind=kind)
+
+    def groups(self) -> list:
+        _tables()
+        self._check_if_open()
+        assert self._handle is not None
+        assert _table_mod is not None
+        return [g for g in self._handle.walk_groups() if not isinstance(g, _table_mod.link.Link) and (getattr(g._v_attrs, 'pandas_type', None) or getattr(g, 'table', None) or (isinstance(g, _table_mod.table.Table) and g._v_name != 'table'))]
+
+    def walk(self, where: str='/') -> Iterator[tuple[str, list[str], list[str]]]:
+        _tables()
+        self._check_if_open()
+        assert self._handle is not None
+        assert _table_mod is not None
+        for g in self._handle.walk_groups(where):
+            if getattr(g._v_attrs, 'pandas_type', None) is not None:
+                continue
+            groups = []
+            leaves = []
+            for child in g._v_children.values():
+                pandas_type = getattr(child._v_attrs, 'pandas_type', None)
+                if pandas_type is None:
+                    if isinstance(child, _table_mod.group.Group):
+                        groups.append(child._v_name)
+                else:
+                    leaves.append(child._v_name)
+            yield (g._v_pathname.rstrip('/'), groups, leaves)
+
+    def get_node(self, key: str) -> Node | None:
+        self._check_if_open()
+        if not key.startswith('/'):
+            key = '/' + key
+        assert self._handle is not None
+        assert _table_mod is not None
+        try:
+            node = self._handle.get_node(self.root, key)
+        except _table_mod.exceptions.NoSuchNodeError:
+            return None
+        assert isinstance(node, _table_mod.Node), type(node)
+        return node
+
+    def get_storer(self, key: str) -> GenericFixed | Table:
+        group = self.get_node(key)
+        if group is None:
+            raise KeyError(f'No object named {key} in the file')
+        s = self._create_storer(group)
+        s.infer_axes()
+        return s
+
+    def copy(self, file, mode: str='w', propindexes: bool=True, keys=None, complib=None, complevel: int | None=None, fletcher32: bool=False, overwrite: bool=True) -> HDFStore:
+        new_store = HDFStore(file, mode=mode, complib=complib, complevel=complevel, fletcher32=fletcher32)
+        if keys is None:
+            keys = list(self.keys())
+        if not isinstance(keys, (tuple, list)):
+            keys = [keys]
+        for k in keys:
+            s = self.get_storer(k)
+            if s is not None:
+                if k in new_store:
+                    if overwrite:
+                        new_store.remove(k)
+                data = self.select(k)
+                if isinstance(s, Table):
+                    index: bool | list[str] = False
+                    if propindexes:
+                        index = [a.name for a in s.axes if a.is_indexed]
+                    new_store.append(k, data, index=index, data_columns=getattr(s, 'data_columns', None), encoding=s.encoding)
+                else:
+                    new_store.put(k, data, encoding=s.encoding)
+        return new_store
+
+    def info(self) -> str:
+        path = pprint_thing(self._path)
+        output = f'{type(self)}\nFile path: {path}\n'
+        if self.is_open:
+            lkeys = sorted(self.keys())
+            if len(lkeys):
+                keys = []
+                values = []
+                for k in lkeys:
+                    try:
+                        s = self.get_storer(k)
+                        if s is not None:
+                            keys.append(pprint_thing(s.pathname or k))
+                            values.append(pprint_thing(s or 'invalid_HDFStore node'))
+                    except AssertionError:
+                        raise
+                    except Exception as detail:
+                        keys.append(k)
+                        dstr = pprint_thing(detail)
+                        values.append(f'[invalid_HDFStore node: {dstr}]')
+                output += adjoin(12, keys, values)
+            else:
+                output += 'Empty'
+        else:
+            output += 'File is CLOSED'
+        return output
+
+    def _check_if_open(self) -> None:
+        if not self.is_open:
+            raise ClosedFileError(f'{self._path} file is not open!')
+
+    def _validate_format(self, format: str) -> str:
+        try:
+            format = _FORMAT_MAP[format.lower()]
+        except KeyError as err:
+            raise TypeError(f'invalid HDFStore format specified [{format}]') from err
+        return format
+
+    def _create_storer(self, group, format=None, value: DataFrame | Series | None=None, encoding: str='UTF-8', errors: str='strict') -> GenericFixed | Table:
+        cls: type[GenericFixed | Table]
+        if value is not None and (not isinstance(value, (Series, DataFrame))):
+            raise TypeError('value must be None, Series, or DataFrame')
+        pt = getattr(group._v_attrs, 'pandas_type', None)
+        tt = getattr(group._v_attrs, 'table_type', None)
+        if pt is None:
+            if value is None:
+                _tables()
+                assert _table_mod is not None
+                if getattr(group, 'table', None) or isinstance(group, _table_mod.table.Table):
+                    pt = 'frame_table'
+                    tt = 'generic_table'
+                else:
+                    raise TypeError('cannot create a storer if the object is not existing nor a value are passed')
+            else:
+                if isinstance(value, Series):
+                    pt = 'series'
+                else:
+                    pt = 'frame'
+                if format == 'table':
+                    pt += '_table'
+        if 'table' not in pt:
+            _STORER_MAP = {'series': SeriesFixed, 'frame': FrameFixed}
+            try:
+                cls = _STORER_MAP[pt]
+            except KeyError as err:
+                raise TypeError(f'cannot properly create the storer for: [_STORER_MAP] [group->{group},value->{type(value)},format->{format}') from err
+            return cls(self, group, encoding=encoding, errors=errors)
+        if tt is None:
+            if value is not None:
+                if pt == 'series_table':
+                    index = getattr(value, 'index', None)
+                    if index is not None:
+                        if index.nlevels == 1:
+                            tt = 'appendable_series'
+                        elif index.nlevels > 1:
+                            tt = 'appendable_multiseries'
+                elif pt == 'frame_table':
+                    index = getattr(value, 'index', None)
+                    if index is not None:
+                        if index.nlevels == 1:
+                            tt = 'appendable_frame'
+                        elif index.nlevels > 1:
+                            tt = 'appendable_multiframe'
+        _TABLE_MAP = {'generic_table': GenericTable, 'appendable_series': AppendableSeriesTable, 'appendable_multiseries': AppendableMultiSeriesTable, 'appendable_frame': AppendableFrameTable, 'appendable_multiframe': AppendableMultiFrameTable, 'worm': WORMTable}
+        try:
+            cls = _TABLE_MAP[tt]
+        except KeyError as err:
+            raise TypeError(f'cannot properly create the storer for: [_TABLE_MAP] [group->{group},value->{type(value)},format->{format}') from err
+        return cls(self, group, encoding=encoding, errors=errors)
+
+    def _write_to_group(self, key: str, value: DataFrame | Series, format, axes=None, index: bool | list[str]=True, append: bool=False, complib=None, complevel: int | None=None, fletcher32=None, min_itemsize: int | dict[str, int] | None=None, chunksize: int | None=None, expectedrows=None, dropna: bool=False, nan_rep=None, data_columns=None, encoding=None, errors: str='strict', track_times: bool=True) -> None:
+        if getattr(value, 'empty', None) and (format == 'table' or append):
+            return
+        group = self._identify_group(key, append)
+        s = self._create_storer(group, format, value, encoding=encoding, errors=errors)
+        if append:
+            if not s.is_table or (s.is_table and format == 'fixed' and s.is_exists):
+                raise ValueError('Can only append to Tables')
+            if not s.is_exists:
+                s.set_object_info()
+        else:
+            s.set_object_info()
+        if not s.is_table and complib:
+            raise ValueError('Compression not supported on Fixed format stores')
+        s.write(obj=value, axes=axes, append=append, complib=complib, complevel=complevel, fletcher32=fletcher32, min_itemsize=min_itemsize, chunksize=chunksize, expectedrows=expectedrows, dropna=dropna, nan_rep=nan_rep, data_columns=data_columns, track_times=track_times)
+        if isinstance(s, Table) and index:
+            s.create_index(columns=index)
+
+    def _read_group(self, group: Node):
+        s = self._create_storer(group)
+        s.infer_axes()
+        return s.read()
+
+    def _identify_group(self, key: str, append: bool) -> Node:
+        group = self.get_node(key)
+        assert self._handle is not None
+        if group is not None and (not append):
+            self._handle.remove_node(group, recursive=True)
+            group = None
+        if group is None:
+            group = self._create_nodes_and_group(key)
+        return group
+
+    def _create_nodes_and_group(self, key: str) -> Node:
+        assert self._handle is not None
+        paths = key.split('/')
+        path = '/'
+        for p in paths:
+            if not len(p):
+                continue
+            new_path = path
+            if not path.endswith('/'):
+                new_path += '/'
+            new_path += p
+            group = self.get_node(new_path)
+            if group is None:
+                group = self._handle.create_group(path, p)
+            path = new_path
+        return group
+
+class TableIterator:
+    chunksize: int | None
+    store: HDFStore
+    s: GenericFixed | Table
+
+    def __init__(self, store: HDFStore, s: GenericFixed | Table, func, where, nrows, start=None, stop=None, iterator: bool=False, chunksize: int | None=None, auto_close: bool=False) -> None:
+        self.store = store
+        self.s = s
+        self.func = func
+        self.where = where
+        if self.s.is_table:
+            if nrows is None:
+                nrows = 0
+            if start is None:
+                start = 0
+            if stop is None:
+                stop = nrows
+            stop = min(nrows, stop)
+        self.nrows = nrows
+        self.start = start
+        self.stop = stop
+        self.coordinates = None
+        if iterator or chunksize is not None:
+            if chunksize is None:
+                chunksize = 100000
+            self.chunksize = int(chunksize)
+        else:
+            self.chunksize = None
+        self.auto_close = auto_close
+
+    def __iter__(self) -> Iterator:
+        current = self.start
+        if self.coordinates is None:
+            raise ValueError('Cannot iterate until get_result is called.')
+        while current < self.stop:
+            stop = min(current + self.chunksize, self.stop)
+            value = self.func(None, None, self.coordinates[current:stop])
+            current = stop
+            if value is None or not len(value):
+                continue
+            yield value
+        self.close()
+
+    def close(self) -> None:
+        if self.auto_close:
+            self.store.close()
+
+    def get_result(self, coordinates: bool=False):
+        if self.chunksize is not None:
+            if not isinstance(self.s, Table):
+                raise TypeError('can only use an iterator or chunksize on a table')
+            self.coordinates = self.s.read_coordinates(where=self.where)
+            return self
+        if coordinates:
+            if not isinstance(self.s, Table):
+                raise TypeError('can only read_coordinates on a table')
+            where = self.s.read_coordinates(where=self.where, start=self.start, stop=self.stop)
+        else:
+            where = self.where
+        results = self.func(self.start, self.stop, where)
+        self.close()
+        return results
+
+class IndexCol:
+    is_an_indexable: bool = True
+    is_data_indexable: bool = True
+    _info_fields = ['freq', 'tz', 'index_name']
+
+    def __init__(self, name: str, values=None, kind=None, typ=None, cname: str | None=None, axis=None, pos=None, freq=None, tz=None, index_name=None, ordered=None, table=None, meta=None, metadata=None) -> None:
+        if not isinstance(name, str):
+            raise ValueError('`name` must be a str.')
+        self.values = values
+        self.kind = kind
+        self.typ = typ
+        self.name = name
+        self.cname = cname or name
+        self.axis = axis
+        self.pos = pos
+        self.freq = freq
+        self.tz = tz
+        self.index_name = index_name
+        self.ordered = ordered
+        self.table = table
+        self.meta = meta
+        self.metadata = metadata
+        if pos is not None:
+            self.set_pos(pos)
+        assert isinstance(self.name, str)
+        assert isinstance(self.cname, str)
+
+    @property
+    def itemsize(self) -> int:
+        return self.typ.itemsize
+
+    @property
+    def kind_attr(self) -> str:
+        return f'{self.name}_kind'
+
+    def set_pos(self, pos: int) -> None:
+        self.pos = pos
+        if pos is not None and self.typ is not None:
+            self.typ._v_pos = pos
+
+    def __repr__(self) -> str:
+        temp = tuple(map(pprint_thing, (self.name, self.cname, self.axis, self.pos, self.kind)))
+        return ','.join([f'{key}->{value}' for (key, value) in zip(['name', 'cname', 'axis', 'pos', 'kind'], temp)])
+
+    def __eq__(self, other: object) -> bool:
+        return all((getattr(self, a, None) == getattr(other, a, None) for a in ['name', 'cname', 'axis', 'pos']))
+
+    def __ne__(self, other) -> bool:
+        return not self.__eq__(other)
+
+    @property
+    def is_indexed(self) -> bool:
+        if not hasattr(self.table, 'cols'):
+            return False
+        return getattr(self.table.cols, self.cname).is_indexed
+
+    def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str) -> tuple[np.ndarray, np.ndarray] | tuple[Index, Index]:
+        assert isinstance(values, np.ndarray), type(values)
+        if values.dtype.fields is not None:
+            values = values[self.cname].copy()
+        val_kind = self.kind
+        values = _maybe_convert(values, val_kind, encoding, errors)
+        kwargs = {}
+        kwargs['name'] = self.index_name
+        if self.freq is not None:
+            kwargs['freq'] = self.freq
+        factory: type[Index | DatetimeIndex] = Index
+        if lib.is_np_dtype(values.dtype, 'M') or isinstance(values.dtype, DatetimeTZDtype):
+            factory = DatetimeIndex
+        elif values.dtype == 'i8' and 'freq' in kwargs:
+            factory = lambda x, **kwds: PeriodIndex.from_ordinals(x, freq=kwds.get('freq', None))._rename(kwds['name'])
+        try:
+            new_pd_index = factory(values, **kwargs)
+        except ValueError:
+            if 'freq' in kwargs:
+                kwargs['freq'] = None
+            new_pd_index = factory(values, **kwargs)
+        final_pd_index: Index
+        if self.tz is not None and isinstance(new_pd_index, DatetimeIndex):
+            final_pd_index = new_pd_index.tz_localize('UTC').tz_convert(self.tz)
+        else:
+            final_pd_index = new_pd_index
+        return (final_pd_index, final_pd_index)
+
+    def take_data(self):
+        return self.values
+
+    @property
+    def attrs(self):
+        return self.table._v_attrs
+
+    @property
+    def description(self):
+        return self.table.description
+
+    @property
+    def col(self):
+        return getattr(self.description, self.cname, None)
+
+    @property
+    def cvalues(self):
+        return self.values
+
+    def __iter__(self) -> Iterator:
+        return iter(self.values)
+
+    def maybe_set_size(self, min_itemsize=None) -> None:
+        if self.kind == 'string':
+            if isinstance(min_itemsize, dict):
+                min_itemsize = min_itemsize.get(self.name)
+            if min_itemsize is not None and self.typ.itemsize < min_itemsize:
+                self.typ = _tables().StringCol(itemsize=min_itemsize, pos=self.pos)
+
+    def validate_names(self) -> None:
+        pass
+
+    def validate_and_set(self, handler: AppendableTable, append: bool) -> None:
+        self.table = handler.table
+        self.validate_col()
+        self.validate_attr(append)
+        self.validate_metadata(handler)
+        self.write_metadata(handler)
+        self.set_attr()
+
+    def validate_col(self, itemsize=None):
+        if self.kind == 'string':
+            c = self.col
+            if c is not None:
+                if itemsize is None:
+                    itemsize = self.itemsize
+                if c.itemsize < itemsize:
+                    raise ValueError(f'Trying to store a string with len [{itemsize}] in [{self.cname}] column but\nthis column has a limit of [{c.itemsize}]!\nConsider using min_itemsize to preset the sizes on these columns')
+                return c.itemsize
+        return None
+
+    def validate_attr(self, append: bool) -> None:
+        if append:
+            existing_kind = getattr(self.attrs, self.kind_attr, None)
+            if existing_kind is not None and existing_kind != self.kind:
+                raise TypeError(f'incompatible kind in col [{existing_kind} - {self.kind}]')
+
+    def update_info(self, info) -> None:
+        for key in self._info_fields:
+            value = getattr(self, key, None)
+            idx = info.setdefault(self.name, {})
+            existing_value = idx.get(key)
+            if key in idx and value is not None and (existing_value != value):
+                if key in ['freq', 'index_name']:
+                    ws = attribute_conflict_doc % (key, existing_value, value)
+                    warnings.warn(ws, AttributeConflictWarning, stacklevel=find_stack_level())
+                    idx[key] = None
+                    setattr(self, key, None)
+                else:
+                    raise ValueError(f'invalid info for [{self.name}] for [{key}], existing_value [{existing_value}] conflicts with new value [{value}]')
+            elif value is not None or existing_value is not None:
+                idx[key] = value
+
+    def set_info(self, info) -> None:
+        idx = info.get(self.name)
+        if idx is not None:
+            self.__dict__.update(idx)
+
+    def set_attr(self) -> None:
+        setattr(self.attrs, self.kind_attr, self.kind)
+
+    def validate_metadata(self, handler: AppendableTable) -> None:
+        if self.meta == 'category':
+            new_metadata = self.metadata
+            cur_metadata = handler.read_metadata(self.cname)
+            if new_metadata is not None and cur_metadata is not None and (not array_equivalent(new_metadata, cur_metadata, strict_nan=True, dtype_equal=True)):
+                raise ValueError('cannot append a categorical with different categories to the existing')
+
+    def write_metadata(self, handler: AppendableTable) -> None:
+        if self.metadata is not None:
+            handler.write_metadata(self.cname, self.metadata)
+
+class GenericIndexCol(IndexCol):
+
+    @property
+    def is_indexed(self) -> bool:
+        return False
+
+    def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str) -> tuple[Index, Index]:
+        assert isinstance(values, np.ndarray), type(values)
+        index = RangeIndex(len(values))
+        return (index, index)
+
+    def set_attr(self) -> None:
+        pass
+
+class DataCol(IndexCol):
+    is_an_indexable = False
+    is_data_indexable = False
+    _info_fields = ['tz', 'ordered']
+
+    def __init__(self, name: str, values=None, kind=None, typ=None, cname: str | None=None, pos=None, tz=None, ordered=None, table=None, meta=None, metadata=None, dtype: DtypeArg | None=None, data=None) -> None:
+        super().__init__(name=name, values=values, kind=kind, typ=typ, pos=pos, cname=cname, tz=tz, ordered=ordered, table=table, meta=meta, metadata=metadata)
+        self.dtype = dtype
+        self.data = data
+
+    @property
+    def dtype_attr(self) -> str:
+        return f'{self.name}_dtype'
+
+    @property
+    def meta_attr(self) -> str:
+        return f'{self.name}_meta'
+
+    def __repr__(self) -> str:
+        temp = tuple(map(pprint_thing, (self.name, self.cname, self.dtype, self.kind, self.shape)))
+        return ','.join([f'{key}->{value}' for (key, value) in zip(['name', 'cname', 'dtype', 'kind', 'shape'], temp)])
+
+    def __eq__(self, other: object) -> bool:
+        return all((getattr(self, a, None) == getattr(other, a, None) for a in ['name', 'cname', 'dtype', 'pos']))
+
+    def set_data(self, data: ArrayLike) -> None:
+        assert data is not None
+        assert self.dtype is None
+        (data, dtype_name) = _get_data_and_dtype_name(data)
+        self.data = data
+        self.dtype = dtype_name
+        self.kind = _dtype_to_kind(dtype_name)
+
+    def take_data(self):
+        return self.data
+
+    @classmethod
+    def _get_atom(cls, values: ArrayLike) -> Col:
+        dtype = values.dtype
+        itemsize = dtype.itemsize
+        shape = values.shape
+        if values.ndim == 1:
+            shape = (1, values.size)
+        if isinstance(values, Categorical):
+            codes = values.codes
+            atom = cls.get_atom_data(shape, kind=codes.dtype.name)
+        elif lib.is_np_dtype(dtype, 'M') or isinstance(dtype, DatetimeTZDtype):
+            atom = cls.get_atom_datetime64(shape)
+        elif lib.is_np_dtype(dtype, 'm'):
+            atom = cls.get_atom_timedelta64(shape)
+        elif is_complex_dtype(dtype):
+            atom = _tables().ComplexCol(itemsize=itemsize, shape=shape[0])
+        elif is_string_dtype(dtype):
+            atom = cls.get_atom_string(shape, itemsize)
+        else:
+            atom = cls.get_atom_data(shape, kind=dtype.name)
+        return atom
+
+    @classmethod
+    def get_atom_string(cls, shape, itemsize):
+        return _tables().StringCol(itemsize=itemsize, shape=shape[0])
+
+    @classmethod
+    def get_atom_coltype(cls, kind: str) -> type[Col]:
+        if kind.startswith('uint'):
+            k4 = kind[4:]
+            col_name = f'UInt{k4}Col'
+        elif kind.startswith('period'):
+            col_name = 'Int64Col'
+        else:
+            kcap = kind.capitalize()
+            col_name = f'{kcap}Col'
+        return getattr(_tables(), col_name)
+
+    @classmethod
+    def get_atom_data(cls, shape, kind: str) -> Col:
+        return cls.get_atom_coltype(kind=kind)(shape=shape[0])
+
+    @classmethod
+    def get_atom_datetime64(cls, shape):
+        return _tables().Int64Col(shape=shape[0])
+
+    @classmethod
+    def get_atom_timedelta64(cls, shape):
+        return _tables().Int64Col(shape=shape[0])
+
+    @property
+    def shape(self):
+        return getattr(self.data, 'shape', None)
+
+    @property
+    def cvalues(self):
+        return self.data
+
+    def validate_attr(self, append) -> None:
+        if append:
+            existing_fields = getattr(self.attrs, self.kind_attr, None)
+            if existing_fields is not None and existing_fields != list(self.values):
+                raise ValueError('appended items do not match existing items in table!')
+            existing_dtype = getattr(self.attrs, self.dtype_attr, None)
+            if existing_dtype is not None and existing_dtype != self.dtype:
+                raise ValueError('appended items dtype do not match existing items dtype in table!')
+
+    def convert(self, values: np.ndarray, nan_rep, encoding: str, errors: str):
+        assert isinstance(values, np.ndarray), type(values)
+        if values.dtype.fields is not None:
+            values = values[self.cname]
+        assert self.typ is not None
+        if self.dtype is None:
+            (converted, dtype_name) = _get_data_and_dtype_name(values)
+            kind = _dtype_to_kind(dtype_name)
+        else:
+            converted = values
+            dtype_name = self.dtype
+            kind = self.kind
+        assert isinstance(converted, np.ndarray)
+        meta = self.meta
+        metadata = self.metadata
+        ordered = self.ordered
+        tz = self.tz
+        assert dtype_name is not None
+        dtype = dtype_name
+        if dtype.startswith('datetime64'):
+            converted = _set_tz(converted, tz, dtype)
+        elif dtype == 'timedelta64':
+            converted = np.asarray(converted, dtype='m8[ns]')
+        elif dtype == 'date':
+            try:
+                converted = np.asarray([date.fromordinal(v) for v in converted], dtype=object)
+            except ValueError:
+                converted = np.asarray([date.fromtimestamp(v) for v in converted], dtype=object)
+        elif meta == 'category':
+            categories = metadata
+            codes = converted.ravel()
+            if categories is None:
+                categories = Index([], dtype=np.float64)
+            else:
+                mask = isna(categories)
+                if mask.any():
+                    categories = categories[~mask]
+                    codes[codes != -1] -= mask.astype(int).cumsum()._values
+            converted = Categorical.from_codes(codes, categories=categories, ordered=ordered, validate=False)
+        else:
+            try:
+                converted = converted.astype(dtype, copy=False)
+            except TypeError:
+                converted = converted.astype('O', copy=False)
+        if kind == 'string':
+            converted = _unconvert_string_array(converted, nan_rep=nan_rep, encoding=encoding, errors=errors)
+        return (self.values, converted)
+
+    def set_attr(self) -> None:
+        setattr(self.attrs, self.kind_attr, self.values)
+        setattr(self.attrs, self.meta_attr, self.meta)
+        assert self.dtype is not None
+        setattr(self.attrs, self.dtype_attr, self.dtype)
+
+class DataIndexableCol(DataCol):
+    is_data_indexable = True
+
+    def validate_names(self) -> None:
+        if not is_string_dtype(Index(self.values).dtype):
+            raise ValueError('cannot have non-object label DataIndexableCol')
+
+    @classmethod
+    def get_atom_string(cls, shape, itemsize):
+        return _tables().StringCol(itemsize=itemsize)
+
+    @classmethod
+    def get_atom_data(cls, shape, kind: str) -> Col:
+        return cls.get_atom_coltype(kind=kind)()
+
+    @classmethod
+    def get_atom_datetime64(cls, shape):
+        return _tables().Int64Col()
+
+    @classmethod
+    def get_atom_timedelta64(cls, shape):
+        return _tables().Int64Col()
+
+class GenericDataIndexableCol(DataIndexableCol):
+
+class Fixed:
+    pandas_kind: str
+    format_type: str = 'fixed'
+    obj_type: type[DataFrame | Series]
+    ndim: int
+    parent: HDFStore
+    is_table: bool = False
+
+    def __init__(self, parent: HDFStore, group: Node, encoding: str | None='UTF-8', errors: str='strict') -> None:
+        assert isinstance(parent, HDFStore), type(parent)
+        assert _table_mod is not None
+        assert isinstance(group, _table_mod.Node), type(group)
+        self.parent = parent
+        self.group = group
+        self.encoding = _ensure_encoding(encoding)
+        self.errors = errors
+
+    @property
+    def is_old_version(self) -> bool:
+        return self.version[0] <= 0 and self.version[1] <= 10 and (self.version[2] < 1)
+
+    @property
+    def version(self) -> tuple[int, int, int]:
+        version = getattr(self.group._v_attrs, 'pandas_version', None)
+        if isinstance(version, str):
+            version_tup = tuple((int(x) for x in version.split('.')))
+            if len(version_tup) == 2:
+                version_tup = version_tup + (0,)
+            assert len(version_tup) == 3
+            return version_tup
+        else:
+            return (0, 0, 0)
+
+    @property
+    def pandas_type(self):
+        return getattr(self.group._v_attrs, 'pandas_type', None)
+
+    def __repr__(self) -> str:
+        self.infer_axes()
+        s = self.shape
+        if s is not None:
+            if isinstance(s, (list, tuple)):
+                jshape = ','.join([pprint_thing(x) for x in s])
+                s = f'[{jshape}]'
+            return f'{self.pandas_type:12.12} (shape->{s})'
+        return self.pandas_type
+
+    def set_object_info(self) -> None:
+        self.attrs.pandas_type = str(self.pandas_kind)
+        self.attrs.pandas_version = str(_version)
+
+    def copy(self) -> Fixed:
+        new_self = copy.copy(self)
+        return new_self
+
+    @property
+    def shape(self):
+        return self.nrows
+
+    @property
+    def pathname(self):
+        return self.group._v_pathname
+
+    @property
+    def _handle(self):
+        return self.parent._handle
+
+    @property
+    def _filters(self):
+        return self.parent._filters
+
+    @property
+    def _complevel(self) -> int:
+        return self.parent._complevel
+
+    @property
+    def _fletcher32(self) -> bool:
+        return self.parent._fletcher32
+
+    @property
+    def attrs(self):
+        return self.group._v_attrs
+
+    def set_attrs(self) -> None:
+
+    def get_attrs(self) -> None:
+
+    @property
+    def storable(self):
+        return self.group
+
+    @property
+    def is_exists(self) -> bool:
+        return False
+
+    @property
+    def nrows(self):
+        return getattr(self.storable, 'nrows', None)
+
+    def validate(self, other) -> Literal[True] | None:
+        if other is None:
+            return None
+        return True
+
+    def validate_version(self, where=None) -> None:
+
+    def infer_axes(self) -> bool:
+        s = self.storable
+        if s is None:
+            return False
+        self.get_attrs()
+        return True
+
+    def read(self, where=None, columns=None, start: int | None=None, stop: int | None=None) -> Series | DataFrame:
+        raise NotImplementedError('cannot read on an abstract storer: subclasses should implement')
+
+    def write(self, obj, **kwargs) -> None:
+        raise NotImplementedError('cannot write on an abstract storer: subclasses should implement')
+
+    def delete(self, where=None, start: int | None=None, stop: int | None=None) -> int | None:
+        if com.all_none(where, start, stop):
+            self._handle.remove_node(self.group, recursive=True)
+            return None
+        raise TypeError('cannot delete on an abstract storer')
+
+class GenericFixed(Fixed):
+    _index_type_map = {DatetimeIndex: 'datetime', PeriodIndex: 'period'}
+    _reverse_index_map = {v: k for (k, v) in _index_type_map.items()}
+    attributes: list[str] = []
+
+    def _class_to_alias(self, cls) -> str:
+        return self._index_type_map.get(cls, '')
+
+    def _alias_to_class(self, alias):
+        if isinstance(alias, type):
+            return alias
+        return self._reverse_index_map.get(alias, Index)
+
+    def _get_index_factory(self, attrs):
+        index_class = self._alias_to_class(getattr(attrs, 'index_class', ''))
+        factory: Callable
+        if index_class == DatetimeIndex:
+
+            def f(values, freq=None, tz=None):
+                dta = DatetimeArray._simple_new(values.values, dtype=values.dtype, freq=freq)
+                result = DatetimeIndex._simple_new(dta, name=None)
+                if tz is not None:
+                    result = result.tz_localize('UTC').tz_convert(tz)
+                return result
+            factory = f
+        elif index_class == PeriodIndex:
+
+            def f(values, freq=None, tz=None):
+                dtype = PeriodDtype(freq)
+                parr = PeriodArray._simple_new(values, dtype=dtype)
+                return PeriodIndex._simple_new(parr, name=None)
+            factory = f
+        else:
+            factory = index_class
+        kwargs = {}
+        if 'freq' in attrs:
+            kwargs['freq'] = attrs['freq']
+            if index_class is Index:
+                factory = TimedeltaIndex
+        if 'tz' in attrs:
+            kwargs['tz'] = attrs['tz']
+            assert index_class is DatetimeIndex
+        return (factory, kwargs)
+
+    def validate_read(self, columns, where) -> None:
+        if columns is not None:
+            raise TypeError('cannot pass a column specification when reading a Fixed format store. this store must be selected in its entirety')
+        if where is not None:
+            raise TypeError('cannot pass a where specification when reading from a Fixed format store. this store must be selected in its entirety')
+
+    @property
+    def is_exists(self) -> bool:
+        return True
+
+    def set_attrs(self) -> None:
+        self.attrs.encoding = self.encoding
+        self.attrs.errors = self.errors
+
+    def get_attrs(self) -> None:
+        self.encoding = _ensure_encoding(getattr(self.attrs, 'encoding', None))
+        self.errors = getattr(self.attrs, 'errors', 'strict')
+        for n in self.attributes:
+            setattr(self, n, getattr(self.attrs, n, None))
+
+    def write(self, obj, **kwargs) -> None:
+        self.set_attrs()
+
+    def read_array(self, key: str, start: int | None=None, stop: int | None=None):
+        import tables
+        node = getattr(self.group, key)
+        attrs = node._v_attrs
+        transposed = getattr(attrs, 'transposed', False)
+        if isinstance(node, tables.VLArray):
+            ret = node[0][start:stop]
+        else:
+            dtype = getattr(attrs, 'value_type', None)
+            shape = getattr(attrs, 'shape', None)
+            if shape is not None:
+                ret = np.empty(shape, dtype=dtype)
+            else:
+                ret = node[start:stop]
+            if dtype and dtype.startswith('datetime64'):
+                tz = getattr(attrs, 'tz', None)
+                ret = _set_tz(ret, tz, dtype)
+            elif dtype == 'timedelta64':
+                ret = np.asarray(ret, dtype='m8[ns]')
+        if transposed:
+            return ret.T
+        else:
+            return ret
+
+    def read_index(self, key: str, start: int | None=None, stop: int | None=None) -> Index:
+        variety = getattr(self.attrs, f'{key}_variety')
+        if variety == 'multi':
+            return self.read_multi_index(key, start=start, stop=stop)
+        elif variety == 'regular':
+            node = getattr(self.group, key)
+            index = self.read_index_node(node, start=start, stop=stop)
+            return index
+        else:
+            raise TypeError(f'unrecognized index variety: {variety}')
+
+    def write_index(self, key: str, index: Index) -> None:
+        if isinstance(index, MultiIndex):
+            setattr(self.attrs, f'{key}_variety', 'multi')
+            self.write_multi_index(key, index)
+        else:
+            setattr(self.attrs, f'{key}_variety', 'regular')
+            converted = _convert_index('index', index, self.encoding, self.errors)
+            self.write_array(key, converted.values)
+            node = getattr(self.group, key)
+            node._v_attrs.kind = converted.kind
+            node._v_attrs.name = index.name
+            if isinstance(index, (DatetimeIndex, PeriodIndex)):
+                node._v_attrs.index_class = self._class_to_alias(type(index))
+            if isinstance(index, (DatetimeIndex, PeriodIndex, TimedeltaIndex)):
+                node._v_attrs.freq = index.freq
+            if isinstance(index, DatetimeIndex) and index.tz is not None:
+                node._v_attrs.tz = _get_tz(index.tz)
+
+    def write_multi_index(self, key: str, index: MultiIndex) -> None:
+        setattr(self.attrs, f'{key}_nlevels', index.nlevels)
+        for (i, (lev, level_codes, name)) in enumerate(zip(index.levels, index.codes, index.names)):
+            if isinstance(lev.dtype, ExtensionDtype):
+                raise NotImplementedError('Saving a MultiIndex with an extension dtype is not supported.')
+            level_key = f'{key}_level{i}'
+            conv_level = _convert_index(level_key, lev, self.encoding, self.errors)
+            self.write_array(level_key, conv_level.values)
+            node = getattr(self.group, level_key)
+            node._v_attrs.kind = conv_level.kind
+            node._v_attrs.name = name
+            setattr(node._v_attrs, f'{key}_name{name}', name)
+            label_key = f'{key}_label{i}'
+            self.write_array(label_key, level_codes)
+
+    def read_multi_index(self, key: str, start: int | None=None, stop: int | None=None) -> MultiIndex:
+        nlevels = getattr(self.attrs, f'{key}_nlevels')
+        levels = []
+        codes = []
+        names: list[Hashable] = []
+        for i in range(nlevels):
+            level_key = f'{key}_level{i}'
+            node = getattr(self.group, level_key)
+            lev = self.read_index_node(node, start=start, stop=stop)
+            levels.append(lev)
+            names.append(lev.name)
+            label_key = f'{key}_label{i}'
+            level_codes = self.read_array(label_key, start=start, stop=stop)
+            codes.append(level_codes)
+        return MultiIndex(levels=levels, codes=codes, names=names, verify_integrity=True)
+
+    def read_index_node(self, node: Node, start: int | None=None, stop: int | None=None) -> Index:
+        data = node[start:stop]
+        if 'shape' in node._v_attrs and np.prod(node._v_attrs.shape) == 0:
+            data = np.empty(node._v_attrs.shape, dtype=node._v_attrs.value_type)
+        kind = node._v_attrs.kind
+        name = None
+        if 'name' in node._v_attrs:
+            name = _ensure_str(node._v_attrs.name)
+        attrs = node._v_attrs
+        (factory, kwargs) = self._get_index_factory(attrs)
+        if kind in ('date', 'object'):
+            index = factory(_unconvert_index(data, kind, encoding=self.encoding, errors=self.errors), dtype=object, **kwargs)
+        else:
+            index = factory(_unconvert_index(data, kind, encoding=self.encoding, errors=self.errors), **kwargs)
+        index.name = name
+        return index
+
+    def write_array_empty(self, key: str, value: ArrayLike) -> None:
+        arr = np.empty((1,) * value.ndim)
+        self._handle.create_array(self.group, key, arr)
+        node = getattr(self.group, key)
+        node._v_attrs.value_type = str(value.dtype)
+        node._v_attrs.shape = value.shape
+
+    def write_array(self, key: str, obj: AnyArrayLike, items: Index | None=None) -> None:
+        value = extract_array(obj, extract_numpy=True)
+        if key in self.group:
+            self._handle.remove_node(self.group, key)
+        empty_array = value.size == 0
+        transposed = False
+        if isinstance(value.dtype, CategoricalDtype):
+            raise NotImplementedError('Cannot store a category dtype in a HDF5 dataset that uses format="fixed". Use format="table".')
+        if not empty_array:
+            if hasattr(value, 'T'):
+                value = value.T
+                transposed = True
+        atom = None
+        if self._filters is not None:
+            with suppress(ValueError):
+                atom = _tables().Atom.from_dtype(value.dtype)
+        if atom is not None:
+            if not empty_array:
+                ca = self._handle.create_carray(self.group, key, atom, value.shape, filters=self._filters)
+                ca[:] = value
+            else:
+                self.write_array_empty(key, value)
+        elif value.dtype.type == np.object_:
+            inferred_type = lib.infer_dtype(value, skipna=False)
+            if empty_array:
+                pass
+            elif inferred_type == 'string':
+                pass
+            elif get_option('performance_warnings'):
+                ws = performance_doc % (inferred_type, key, items)
+                warnings.warn(ws, PerformanceWarning, stacklevel=find_stack_level())
+            vlarr = self._handle.create_vlarray(self.group, key, _tables().ObjectAtom())
+            vlarr.append(value)
+        elif lib.is_np_dtype(value.dtype, 'M'):
+            self._handle.create_array(self.group, key, value.view('i8'))
+            getattr(self.group, key)._v_attrs.value_type = str(value.dtype)
+        elif isinstance(value.dtype, DatetimeTZDtype):
+            self._handle.create_array(self.group, key, value.asi8)
+            node = getattr(self.group, key)
+            node._v_attrs.tz = _get_tz(value.tz)
+            node._v_attrs.value_type = f'datetime64[{value.dtype.unit}]'
+        elif lib.is_np_dtype(value.dtype, 'm'):
+            self._handle.create_array(self.group, key, value.view('i8'))
+            getattr(self.group, key)._v_attrs.value_type = 'timedelta64'
+        elif empty_array:
+            self.write_array_empty(key, value)
+        else:
+            self._handle.create_array(self.group, key, value)
+        getattr(self.group, key)._v_attrs.transposed = transposed
+
+class SeriesFixed(GenericFixed):
+    pandas_kind = 'series'
+    attributes = ['name']
+    name: Hashable
+
+    @property
+    def shape(self) -> tuple[int] | None:
+        try:
+            return (len(self.group.values),)
+        except (TypeError, AttributeError):
+            return None
+
+    def read(self, where=None, columns=None, start: int | None=None, stop: int | None=None) -> Series:
+        self.validate_read(columns, where)
+        index = self.read_index('index', start=start, stop=stop)
+        values = self.read_array('values', start=start, stop=stop)
+        result = Series(values, index=index, name=self.name, copy=False)
+        if using_string_dtype() and is_string_array(values, skipna=True):
+            result = result.astype(StringDtype(na_value=np.nan))
+        return result
+
+    def write(self, obj, **kwargs) -> None:
+        super().write(obj, **kwargs)
+        self.write_index('index', obj.index)
+        self.write_array('values', obj)
+        self.attrs.name = obj.name
+
+class BlockManagerFixed(GenericFixed):
+    attributes = ['ndim', 'nblocks']
+    nblocks: int
+
+    @property
+    def shape(self) -> Shape | None:
+        try:
+            ndim = self.ndim
+            items = 0
+            for i in range(self.nblocks):
+                node = getattr(self.group, f'block{i}_items')
+                shape = getattr(node, 'shape', None)
+                if shape is not None:
+                    items += shape[0]
+            node = self.group.block0_values
+            shape = getattr(node, 'shape', None)
+            if shape is not None:
+                shape = list(shape[0:ndim - 1])
+            else:
+                shape = []
+            shape.append(items)
+            return shape
+        except AttributeError:
+            return None
+
+    def read(self, where=None, columns=None, start: int | None=None, stop: int | None=None) -> DataFrame:
+        self.validate_read(columns, where)
+        select_axis = self.obj_type()._get_block_manager_axis(0)
+        axes = []
+        for i in range(self.ndim):
+            (_start, _stop) = (start, stop) if i == select_axis else (None, None)
+            ax = self.read_index(f'axis{i}', start=_start, stop=_stop)
+            axes.append(ax)
+        items = axes[0]
+        dfs = []
+        for i in range(self.nblocks):
+            blk_items = self.read_index(f'block{i}_items')
+            values = self.read_array(f'block{i}_values', start=_start, stop=_stop)
+            columns = items[items.get_indexer(blk_items)]
+            df = DataFrame(values.T, columns=columns, index=axes[1], copy=False)
+            if using_string_dtype() and is_string_array(values, skipna=True):
+                df = df.astype(StringDtype(na_value=np.nan))
+            dfs.append(df)
+        if len(dfs) > 0:
+            out = concat(dfs, axis=1).copy()
+            return out.reindex(columns=items)
+        return DataFrame(columns=axes[0], index=axes[1])
+
+    def write(self, obj, **kwargs) -> None:
+        super().write(obj, **kwargs)
+        data = obj._mgr
+        if not data.is_consolidated():
+            data = data.consolidate()
+        self.attrs.ndim = data.ndim
+        for (i, ax) in enumerate(data.axes):
+            if i == 0 and (not ax.is_unique):
+                raise ValueError('Columns index has to be unique for fixed format')
+            self.write_index(f'axis{i}', ax)
+        self.attrs.nblocks = len(data.blocks)
+        for (i, blk) in enumerate(data.blocks):
+            blk_items = data.items.take(blk.mgr_locs)
+            self.write_array(f'block{i}_values', blk.values, items=blk_items)
+            self.write_index(f'block{i}_items', blk_items)
+
+class FrameFixed(BlockManagerFixed):
+    pandas_kind = 'frame'
+    obj_type = DataFrame
+
+class Table(Fixed):
+    pandas_kind = 'wide_table'
+    format_type: str = 'table'
+    table_type: str
+    levels: int | list[Hashable] = 1
+    is_table = True
+    metadata: list
+
+    def __init__(self, parent: HDFStore, group: Node, encoding: str | None=None, errors: str='strict', index_axes: list[IndexCol] | None=None, non_index_axes: list[tuple[AxisInt, Any]] | None=None, values_axes: list[DataCol] | None=None, data_columns: list | None=None, info: dict | None=None, nan_rep=None) -> None:
+        super().__init__(parent, group, encoding=encoding, errors=errors)
+        self.index_axes = index_axes or []
+        self.non_index_axes = non_index_axes or []
+        self.values_axes = values_axes or []
+        self.data_columns = data_columns or []
+        self.info = info or {}
+        self.nan_rep = nan_rep
+
+    @property
+    def table_type_short(self) -> str:
+        return self.table_type.split('_')[0]
+
+    def __repr__(self) -> str:
+        self.infer_axes()
+        jdc = ','.join(self.data_columns) if len(self.data_columns) else ''
+        dc = f',dc->[{jdc}]'
+        ver = ''
+        if self.is_old_version:
+            jver = '.'.join([str(x) for x in self.version])
+            ver = f'[{jver}]'
+        jindex_axes = ','.join([a.name for a in self.index_axes])
+        return f'{self.pandas_type:12.12}{ver} (typ->{self.table_type_short},nrows->{self.nrows},ncols->{self.ncols},indexers->[{jindex_axes}]{dc})'
+
+    def __getitem__(self, c: str):
+        for a in self.axes:
+            if c == a.name:
+                return a
+        return None
+
+    def validate(self, other) -> None:
+        if other is None:
+            return
+        if other.table_type != self.table_type:
+            raise TypeError(f'incompatible table_type with existing [{other.table_type} - {self.table_type}]')
+        for c in ['index_axes', 'non_index_axes', 'values_axes']:
+            sv = getattr(self, c, None)
+            ov = getattr(other, c, None)
+            if sv != ov:
+                for (i, sax) in enumerate(sv):
+                    oax = ov[i]
+                    if sax != oax:
+                        raise ValueError(f'invalid combination of [{c}] on appending data [{sax}] vs current table [{oax}]')
+                raise Exception(f'invalid combination of [{c}] on appending data [{sv}] vs current table [{ov}]')
+
+    @property
+    def is_multi_index(self) -> bool:
+        return isinstance(self.levels, list)
+
+    def validate_multiindex(self, obj: DataFrame | Series) -> tuple[DataFrame, list[Hashable]]:
+        levels = com.fill_missing_names(obj.index.names)
+        try:
+            reset_obj = obj.reset_index()
+        except ValueError as err:
+            raise ValueError('duplicate names/columns in the multi-index when storing as a table') from err
+        assert isinstance(reset_obj, DataFrame)
+        return (reset_obj, levels)
+
+    @property
+    def nrows_expected(self) -> int:
+        return np.prod([i.cvalues.shape[0] for i in self.index_axes])
+
+    @property
+    def is_exists(self) -> bool:
+        return 'table' in self.group
+
+    @property
+    def storable(self):
+        return getattr(self.group, 'table', None)
+
+    @property
+    def table(self):
+        return self.storable
+
+    @property
+    def dtype(self):
+        return self.table.dtype
+
+    @property
+    def description(self):
+        return self.table.description
+
+    @property
+    def axes(self) -> itertools.chain[IndexCol]:
+        return itertools.chain(self.index_axes, self.values_axes)
+
+    @property
+    def ncols(self) -> int:
+        return sum((len(a.values) for a in self.values_axes))
+
+    @property
+    def is_transposed(self) -> bool:
+        return False
+
+    @property
+    def data_orientation(self) -> tuple[int, ...]:
+        return tuple(itertools.chain([int(a[0]) for a in self.non_index_axes], [int(a.axis) for a in self.index_axes]))
+
+    def queryables(self) -> dict[str, Any]:
+        axis_names = {0: 'index', 1: 'columns'}
+        d1 = [(a.cname, a) for a in self.index_axes]
+        d2 = [(axis_names[axis], None) for (axis, values) in self.non_index_axes]
+        d3 = [(v.cname, v) for v in self.values_axes if v.name in set(self.data_columns)]
+        return dict(d1 + d2 + d3)
+
+    def index_cols(self) -> list[tuple[Any, Any]]:
+        return [(i.axis, i.cname) for i in self.index_axes]
+
+    def values_cols(self) -> list[str]:
+        return [i.cname for i in self.values_axes]
+
+    def _get_metadata_path(self, key: str) -> str:
+        group = self.group._v_pathname
+        return f'{group}/meta/{key}/meta'
+
+    def write_metadata(self, key: str, values: np.ndarray) -> None:
+        self.parent.put(self._get_metadata_path(key), Series(values, copy=False), format='table', encoding=self.encoding, errors=self.errors, nan_rep=self.nan_rep)
+
+    def read_metadata(self, key: str):
+        if getattr(getattr(self.group, 'meta', None), key, None) is not None:
+            return self.parent.select(self._get_metadata_path(key))
+        return None
+
+    def set_attrs(self) -> None:
+        self.attrs.table_type = str(self.table_type)
+        self.attrs.index_cols = self.index_cols()
+        self.attrs.values_cols = self.values_cols()
+        self.attrs.non_index_axes = self.non_index_axes
+        self.attrs.data_columns = self.data_columns
+        self.attrs.nan_rep = self.nan_rep
+        self.attrs.encoding = self.encoding
+        self.attrs.errors = self.errors
+        self.attrs.levels = self.levels
+        self.attrs.info = self.info
+
+    def get_attrs(self) -> None:
+        self.non_index_axes = getattr(self.attrs, 'non_index_axes', None) or []
+        self.data_columns = getattr(self.attrs, 'data_columns', None) or []
+        self.info = getattr(self.attrs, 'info', None) or {}
+        self.nan_rep = getattr(self.attrs, 'nan_rep', None)
+        self.encoding = _ensure_encoding(getattr(self.attrs, 'encoding', None))
+        self.errors = getattr(self.attrs, 'errors', 'strict')
+        self.levels: list[Hashable] = getattr(self.attrs, 'levels', None) or []
+        self.index_axes = [a for a in self.indexables if a.is_an_indexable]
+        self.values_axes = [a for a in self.indexables if not a.is_an_indexable]
+
+    def validate_version(self, where=None) -> None:
+        if where is not None:
+            if self.is_old_version:
+                ws = incompatibility_doc % '.'.join([str(x) for x in self.version])
+                warnings.warn(ws, IncompatibilityWarning, stacklevel=find_stack_level())
+
+    def validate_min_itemsize(self, min_itemsize) -> None:
+        if min_itemsize is None:
+            return
+        if not isinstance(min_itemsize, dict):
+            return
+        q = self.queryables()
+        for k in min_itemsize:
+            if k == 'values':
+                continue
+            if k not in q:
+                raise ValueError(f'min_itemsize has the key [{k}] which is not an axis or data_column')
+
+    @cache_readonly
+    def indexables(self):
+        _indexables = []
+        desc = self.description
+        table_attrs = self.table.attrs
+        for (i, (axis, name)) in enumerate(self.attrs.index_cols):
+            atom = getattr(desc, name)
+            md = self.read_metadata(name)
+            meta = 'category' if md is not None else None
+            kind_attr = f'{name}_kind'
+            kind = getattr(table_attrs, kind_attr, None)
+            index_col = IndexCol(name=name, axis=axis, pos=i, kind=kind, typ=atom, table=self.table, meta=meta, metadata=md)
+            _indexables.append(index_col)
+        dc = set(self.data_columns)
+        base_pos = len(_indexables)
+
+        def f(i, c: str) -> DataCol:
+            assert isinstance(c, str)
+            klass = DataCol
+            if c in dc:
+                klass = DataIndexableCol
+            atom = getattr(desc, c)
+            adj_name = _maybe_adjust_name(c, self.version)
+            values = getattr(table_attrs, f'{adj_name}_kind', None)
+            dtype = getattr(table_attrs, f'{adj_name}_dtype', None)
+            kind = _dtype_to_kind(dtype)
+            md = self.read_metadata(c)
+            meta = getattr(table_attrs, f'{adj_name}_meta', None)
+            obj = klass(name=adj_name, cname=c, values=values, kind=kind, pos=base_pos + i, typ=atom, table=self.table, meta=meta, metadata=md, dtype=dtype)
+            return obj
+        _indexables.extend([f(i, c) for (i, c) in enumerate(self.attrs.values_cols)])
+        return _indexables
+
+    def create_index(self, columns=None, optlevel=None, kind: str | None=None) -> None:
+        if not self.infer_axes():
+            return
+        if columns is False:
+            return
+        if columns is None or columns is True:
+            columns = [a.cname for a in self.axes if a.is_data_indexable]
+        if not isinstance(columns, (tuple, list)):
+            columns = [columns]
+        kw = {}
+        if optlevel is not None:
+            kw['optlevel'] = optlevel
+        if kind is not None:
+            kw['kind'] = kind
+        table = self.table
+        for c in columns:
+            v = getattr(table.cols, c, None)
+            if v is not None:
+                if v.is_indexed:
+                    index = v.index
+                    cur_optlevel = index.optlevel
+                    cur_kind = index.kind
+                    if kind is not None and cur_kind != kind:
+                        v.remove_index()
+                    else:
+                        kw['kind'] = cur_kind
+                    if optlevel is not None and cur_optlevel != optlevel:
+                        v.remove_index()
+                    else:
+                        kw['optlevel'] = cur_optlevel
+                if not v.is_indexed:
+                    if v.type.startswith('complex'):
+                        raise TypeError('Columns containing complex values can be stored but cannot be indexed when using table format. Either use fixed format, set index=False, or do not include the columns containing complex values to data_columns when initializing the table.')
+                    v.create_index(**kw)
+            elif c in self.non_index_axes[0][1]:
+                raise AttributeError(f'column {c} is not a data_column.\nIn order to read column {c} you must reload the dataframe \ninto HDFStore and include {c} with the data_columns argument.')
+
+    def _read_axes(self, where, start: int | None=None, stop: int | None=None) -> list[tuple[np.ndarray, np.ndarray] | tuple[Index, Index]]:
+        selection = Selection(self, where=where, start=start, stop=stop)
+        values = selection.select()
+        results = []
+        for a in self.axes:
+            a.set_info(self.info)
+            res = a.convert(values, nan_rep=self.nan_rep, encoding=self.encoding, errors=self.errors)
+            results.append(res)
+        return results
+
+    @classmethod
+    def get_object(cls, obj, transposed: bool):
+        return obj
+
+    def validate_data_columns(self, data_columns, min_itemsize, non_index_axes) -> list:
+        if not len(non_index_axes):
+            return []
+        (axis, axis_labels) = non_index_axes[0]
+        info = self.info.get(axis, {})
+        if info.get('type') == 'MultiIndex' and data_columns:
+            raise ValueError(f'cannot use a multi-index on axis [{axis}] with data_columns {data_columns}')
+        if data_columns is True:
+            data_columns = list(axis_labels)
+        elif data_columns is None:
+            data_columns = []
+        if isinstance(min_itemsize, dict):
+            existing_data_columns = set(data_columns)
+            data_columns = list(data_columns)
+            data_columns.extend([k for k in min_itemsize.keys() if k != 'values' and k not in existing_data_columns])
+        return [c for c in data_columns if c in axis_labels]
+
+    def _create_axes(self, axes, obj: DataFrame, validate: bool=True, nan_rep=None, data_columns=None, min_itemsize=None):
+        if not isinstance(obj, DataFrame):
+            group = self.group._v_name
+            raise TypeError(f'cannot properly create the storer for: [group->{group},value->{type(obj)}]')
+        if axes is None:
+            axes = [0]
+        axes = [obj._get_axis_number(a) for a in axes]
+        if self.infer_axes():
+            table_exists = True
+            axes = [a.axis for a in self.index_axes]
+            data_columns = list(self.data_columns)
+            nan_rep = self.nan_rep
+        else:
+            table_exists = False
+        new_info = self.info
+        assert self.ndim == 2
+        if len(axes) != self.ndim - 1:
+            raise ValueError('currently only support ndim-1 indexers in an AppendableTable')
+        new_non_index_axes: list = []
+        if nan_rep is None:
+            nan_rep = 'nan'
+        idx = next((x for x in [0, 1] if x not in axes))
+        a = obj.axes[idx]
+        append_axis = list(a)
+        if table_exists:
+            indexer = len(new_non_index_axes)
+            exist_axis = self.non_index_axes[indexer][1]
+            if not array_equivalent(np.array(append_axis), np.array(exist_axis), strict_nan=True, dtype_equal=True):
+                if array_equivalent(np.array(sorted(append_axis)), np.array(sorted(exist_axis)), strict_nan=True, dtype_equal=True):
+                    append_axis = exist_axis
+        info = new_info.setdefault(idx, {})
+        info['names'] = list(a.names)
+        info['type'] = type(a).__name__
+        new_non_index_axes.append((idx, append_axis))
+        idx = axes[0]
+        a = obj.axes[idx]
+        axis_name = obj._get_axis_name(idx)
+        new_index = _convert_index(axis_name, a, self.encoding, self.errors)
+        new_index.axis = idx
+        new_index.set_pos(0)
+        new_index.update_info(new_info)
+        new_index.maybe_set_size(min_itemsize)
+        new_index_axes = [new_index]
+        j = len(new_index_axes)
+        assert j == 1
+        assert len(new_non_index_axes) == 1
+        for a in new_non_index_axes:
+            obj = _reindex_axis(obj, a[0], a[1])
+        transposed = new_index.axis == 1
+        data_columns = self.validate_data_columns(data_columns, min_itemsize, new_non_index_axes)
+        frame = self.get_object(obj, transposed)._consolidate()
+        (blocks, blk_items) = self._get_blocks_and_items(frame, table_exists, new_non_index_axes, self.values_axes, data_columns)
+        vaxes = []
+        for (i, (blk, b_items)) in enumerate(zip(blocks, blk_items)):
+            klass = DataCol
+            name = None
+            if data_columns and len(b_items) == 1 and (b_items[0] in data_columns):
+                klass = DataIndexableCol
+                name = b_items[0]
+                if not (name is None or isinstance(name, str)):
+                    raise ValueError('cannot have non-object label DataIndexableCol')
+            existing_col: DataCol | None
+            if table_exists and validate:
+                try:
+                    existing_col = self.values_axes[i]
+                except (IndexError, KeyError) as err:
+                    raise ValueError(f'Incompatible appended table [{blocks}]with existing table [{self.values_axes}]') from err
+            else:
+                existing_col = None
+            new_name = name or f'values_block_{i}'
+            data_converted = _maybe_convert_for_string_atom(new_name, blk.values, existing_col=existing_col, min_itemsize=min_itemsize, nan_rep=nan_rep, encoding=self.encoding, errors=self.errors, columns=b_items)
+            adj_name = _maybe_adjust_name(new_name, self.version)
+            typ = klass._get_atom(data_converted)
+            kind = _dtype_to_kind(data_converted.dtype.name)
+            tz = None
+            if getattr(data_converted, 'tz', None) is not None:
+                tz = _get_tz(data_converted.tz)
+            meta = metadata = ordered = None
+            if isinstance(data_converted.dtype, CategoricalDtype):
+                ordered = data_converted.ordered
+                meta = 'category'
+                metadata = np.asarray(data_converted.categories).ravel()
+            (data, dtype_name) = _get_data_and_dtype_name(data_converted)
+            col = klass(name=adj_name, cname=new_name, values=list(b_items), typ=typ, pos=j, kind=kind, tz=tz, ordered=ordered, meta=meta, metadata=metadata, dtype=dtype_name, data=data)
+            col.update_info(new_info)
+            vaxes.append(col)
+            j += 1
+        dcs = [col.name for col in vaxes if col.is_data_indexable]
+        new_table = type(self)(parent=self.parent, group=self.group, encoding=self.encoding, errors=self.errors, index_axes=new_index_axes, non_index_axes=new_non_index_axes, values_axes=vaxes, data_columns=dcs, info=new_info, nan_rep=nan_rep)
+        if hasattr(self, 'levels'):
+            new_table.levels = self.levels
+        new_table.validate_min_itemsize(min_itemsize)
+        if validate and table_exists:
+            new_table.validate(self)
+        return new_table
+
+    @staticmethod
+    def _get_blocks_and_items(frame: DataFrame, table_exists: bool, new_non_index_axes, values_axes, data_columns):
+
+        def get_blk_items(mgr):
+            return [mgr.items.take(blk.mgr_locs) for blk in mgr.blocks]
+        mgr = frame._mgr
+        blocks: list[Block] = list(mgr.blocks)
+        blk_items: list[Index] = get_blk_items(mgr)
+        if len(data_columns):
+            (axis, axis_labels) = new_non_index_axes[0]
+            new_labels = Index(axis_labels).difference(Index(data_columns))
+            mgr = frame.reindex(new_labels, axis=axis)._mgr
+            blocks = list(mgr.blocks)
+            blk_items = get_blk_items(mgr)
+            for c in data_columns:
+                mgr = frame.reindex([c], axis=axis)._mgr
+                blocks.extend(mgr.blocks)
+                blk_items.extend(get_blk_items(mgr))
+        if table_exists:
+            by_items = {tuple(b_items.tolist()): (b, b_items) for (b, b_items) in zip(blocks, blk_items)}
+            new_blocks: list[Block] = []
+            new_blk_items = []
+            for ea in values_axes:
+                items = tuple(ea.values)
+                try:
+                    (b, b_items) = by_items.pop(items)
+                    new_blocks.append(b)
+                    new_blk_items.append(b_items)
+                except (IndexError, KeyError) as err:
+                    jitems = ','.join([pprint_thing(item) for item in items])
+                    raise ValueError(f'cannot match existing table structure for [{jitems}] on appending data') from err
+            blocks = new_blocks
+            blk_items = new_blk_items
+        return (blocks, blk_items)
+
+    def process_axes(self, obj, selection: Selection, columns=None) -> DataFrame:
+        if columns is not None:
+            columns = list(columns)
+        if columns is not None and self.is_multi_index:
+            assert isinstance(self.levels, list)
+            for n in self.levels:
+                if n not in columns:
+                    columns.insert(0, n)
+        for (axis, labels) in self.non_index_axes:
+            obj = _reindex_axis(obj, axis, labels, columns)
+
+            def process_filter(field, filt, op):
+                for axis_name in obj._AXIS_ORDERS:
+                    axis_number = obj._get_axis_number(axis_name)
+                    axis_values = obj._get_axis(axis_name)
+                    assert axis_number is not None
+                    if field == axis_name:
+                        if self.is_multi_index:
+                            filt = filt.union(Index(self.levels))
+                        takers = op(axis_values, filt)
+                        return obj.loc(axis=axis_number)[takers]
+                    elif field in axis_values:
+                        values = ensure_index(getattr(obj, field).values)
+                        filt = ensure_index(filt)
+                        if isinstance(obj, DataFrame):
+                            axis_number = 1 - axis_number
+                        takers = op(values, filt)
+                        return obj.loc(axis=axis_number)[takers]
+                raise ValueError(f'cannot find the field [{field}] for filtering!')
+        if selection.filter is not None:
+            for (field, op, filt) in selection.filter.format():
+                obj = process_filter(field, filt, op)
+        return obj
+
+    def create_description(self, complib, complevel: int | None, fletcher32: bool, expectedrows: int | None) -> dict[str, Any]:
+        if expectedrows is None:
+            expectedrows = max(self.nrows_expected, 10000)
+        d = {'name': 'table', 'expectedrows': expectedrows}
+        d['description'] = {a.cname: a.typ for a in self.axes}
+        if complib:
+            if complevel is None:
+                complevel = self._complevel or 9
+            filters = _tables().Filters(complevel=complevel, complib=complib, fletcher32=fletcher32 or self._fletcher32)
+            d['filters'] = filters
+        elif self._filters is not None:
+            d['filters'] = self._filters
+        return d
+
+    def read_coordinates(self, where=None, start: int | None=None, stop: int | None=None):
+        self.validate_version(where)
+        if not self.infer_axes():
+            return False
+        selection = Selection(self, where=where, start=start, stop=stop)
+        coords = selection.select_coords()
+        if selection.filter is not None:
+            for (field, op, filt) in selection.filter.format():
+                data = self.read_column(field, start=coords.min(), stop=coords.max() + 1)
+                coords = coords[op(data.iloc[coords - coords.min()], filt).values]
+        return Index(coords)
+
+    def read_column(self, column: str, where=None, start: int | None=None, stop: int | None=None):
+        self.validate_version()
+        if not self.infer_axes():
+            return False
+        if where is not None:
+            raise TypeError('read_column does not currently accept a where clause')
+        for a in self.axes:
+            if column == a.name:
+                if not a.is_data_indexable:
+                    raise ValueError(f'column [{column}] can not be extracted individually; it is not data indexable')
+                c = getattr(self.table.cols, column)
+                a.set_info(self.info)
+                col_values = a.convert(c[start:stop], nan_rep=self.nan_rep, encoding=self.encoding, errors=self.errors)
+                cvs = col_values[1]
+                return Series(cvs, name=column, copy=False)
+        raise KeyError(f'column [{column}] not found in the table')
+
+class WORMTable(Table):
+    table_type = 'worm'
+
+    def read(self, where=None, columns=None, start: int | None=None, stop: int | None=None):
+        raise NotImplementedError('WORMTable needs to implement read')
+
+    def write(self, obj, **kwargs) -> None:
+        raise NotImplementedError('WORMTable needs to implement write')
+
+class AppendableTable(Table):
+    table_type = 'appendable'
+
+    def write(self, obj, axes=None, append: bool=False, complib=None, complevel=None, fletcher32=None, min_itemsize=None, chunksize: int | None=None, expectedrows=None, dropna: bool=False, nan_rep=None, data_columns=None, track_times: bool=True) -> None:
+        if not append and self.is_exists:
+            self._handle.remove_node(self.group, 'table')
+        table = self._create_axes(axes=axes, obj=obj, validate=append, min_itemsize=min_itemsize, nan_rep=nan_rep, data_columns=data_columns)
+        for a in table.axes:
+            a.validate_names()
+        if not table.is_exists:
+            options = table.create_description(complib=complib, complevel=complevel, fletcher32=fletcher32, expectedrows=expectedrows)
+            table.set_attrs()
+            options['track_times'] = track_times
+            table._handle.create_table(table.group, **options)
+        table.attrs.info = table.info
+        for a in table.axes:
+            a.validate_and_set(table, append)
+        table.write_data(chunksize, dropna=dropna)
+
+    def write_data(self, chunksize: int | None, dropna: bool=False) -> None:
+        names = self.dtype.names
+        nrows = self.nrows_expected
+        masks = []
+        if dropna:
+            for a in self.values_axes:
+                mask = isna(a.data).all(axis=0)
+                if isinstance(mask, np.ndarray):
+                    masks.append(mask.astype('u1', copy=False))
+        if len(masks):
+            mask = masks[0]
+            for m in masks[1:]:
+                mask = mask & m
+            mask = mask.ravel()
+        else:
+            mask = None
+        indexes = [a.cvalues for a in self.index_axes]
+        nindexes = len(indexes)
+        assert nindexes == 1, nindexes
+        values = [a.take_data() for a in self.values_axes]
+        values = [v.transpose(np.roll(np.arange(v.ndim), v.ndim - 1)) for v in values]
+        bvalues = []
+        for (i, v) in enumerate(values):
+            new_shape = (nrows,) + self.dtype[names[nindexes + i]].shape
+            bvalues.append(v.reshape(new_shape))
+        if chunksize is None:
+            chunksize = 100000
+        rows = np.empty(min(chunksize, nrows), dtype=self.dtype)
+        chunks = nrows // chunksize + 1
+        for i in range(chunks):
+            start_i = i * chunksize
+            end_i = min((i + 1) * chunksize, nrows)
+            if start_i >= end_i:
+                break
+            self.write_data_chunk(rows, indexes=[a[start_i:end_i] for a in indexes], mask=mask[start_i:end_i] if mask is not None else None, values=[v[start_i:end_i] for v in bvalues])
+
+    def write_data_chunk(self, rows: np.ndarray, indexes: list[np.ndarray], mask: npt.NDArray[np.bool_] | None, values: list[np.ndarray]) -> None:
+        for v in values:
+            if not np.prod(v.shape):
+                return
+        nrows = indexes[0].shape[0]
+        if nrows != len(rows):
+            rows = np.empty(nrows, dtype=self.dtype)
+        names = self.dtype.names
+        nindexes = len(indexes)
+        for (i, idx) in enumerate(indexes):
+            rows[names[i]] = idx
+        for (i, v) in enumerate(values):
+            rows[names[i + nindexes]] = v
+        if mask is not None:
+            m = ~mask.ravel().astype(bool, copy=False)
+            if not m.all():
+                rows = rows[m]
+        if len(rows):
+            self.table.append(rows)
+            self.table.flush()
+
+    def delete(self, where=None, start: int | None=None, stop: int | None=None) -> int | None:
+        if where is None or not len(where):
+            if start is None and stop is None:
+                nrows = self.nrows
+                self._handle.remove_node(self.group, recursive=True)
+            else:
+                if stop is None:
+                    stop = self.nrows
+                nrows = self.table.remove_rows(start=start, stop=stop)
+                self.table.flush()
+            return nrows
+        if not self.infer_axes():
+            return None
+        table = self.table
+        selection = Selection(self, where, start=start, stop=stop)
+        values = selection.select_coords()
+        sorted_series = Series(values, copy=False).sort_values()
+        ln = len(sorted_series)
+        if ln:
+            diff = sorted_series.diff()
+            groups = list(diff[diff > 1].index)
+            if not len(groups):
+                groups = [0]
+            if groups[-1] != ln:
+                groups.append(ln)
+            if groups[0] != 0:
+                groups.insert(0, 0)
+            pg = groups.pop()
+            for g in reversed(groups):
+                rows = sorted_series.take(range(g, pg))
+                table.remove_rows(start=rows[rows.index[0]], stop=rows[rows.index[-1]] + 1)
+                pg = g
+            self.table.flush()
+        return ln
+
+class AppendableFrameTable(AppendableTable):
+    pandas_kind = 'frame_table'
+    table_type = 'appendable_frame'
+    ndim = 2
+    obj_type: type[DataFrame | Series] = DataFrame
+
+    @property
+    def is_transposed(self) -> bool:
+        return self.index_axes[0].axis == 1
+
+    @classmethod
+    def get_object(cls, obj, transposed: bool):
+        if transposed:
+            obj = obj.T
+        return obj
+
+    def read(self, where=None, columns=None, start: int | None=None, stop: int | None=None):
+        self.validate_version(where)
+        if not self.infer_axes():
+            return None
+        result = self._read_axes(where=where, start=start, stop=stop)
+        info = self.info.get(self.non_index_axes[0][0], {}) if len(self.non_index_axes) else {}
+        inds = [i for (i, ax) in enumerate(self.axes) if ax is self.index_axes[0]]
+        assert len(inds) == 1
+        ind = inds[0]
+        index = result[ind][0]
+        frames = []
+        for (i, a) in enumerate(self.axes):
+            if a not in self.values_axes:
+                continue
+            (index_vals, cvalues) = result[i]
+            if info.get('type') != 'MultiIndex':
+                cols = Index(index_vals)
+            else:
+                cols = MultiIndex.from_tuples(index_vals)
+            names = info.get('names')
+            if names is not None:
+                cols.set_names(names, inplace=True)
+            if self.is_transposed:
+                values = cvalues
+                index_ = cols
+                cols_ = Index(index, name=getattr(index, 'name', None))
+            else:
+                values = cvalues.T
+                index_ = Index(index, name=getattr(index, 'name', None))
+                cols_ = cols
+            if values.ndim == 1 and isinstance(values, np.ndarray):
+                values = values.reshape((1, values.shape[0]))
+            if isinstance(values, (np.ndarray, DatetimeArray)):
+                df = DataFrame(values.T, columns=cols_, index=index_, copy=False)
+            elif isinstance(values, Index):
+                df = DataFrame(values, columns=cols_, index=index_)
+            else:
+                df = DataFrame._from_arrays([values], columns=cols_, index=index_)
+            if not (using_string_dtype() and values.dtype.kind == 'O'):
+                assert (df.dtypes == values.dtype).all(), (df.dtypes, values.dtype)
+            if using_string_dtype() and is_string_array(values, skipna=True):
+                df = df.astype(StringDtype(na_value=np.nan))
+            frames.append(df)
+        if len(frames) == 1:
+            df = frames[0]
+        else:
+            df = concat(frames, axis=1)
+        selection = Selection(self, where=where, start=start, stop=stop)
+        df = self.process_axes(df, selection=selection, columns=columns)
+        return df
+
+class AppendableSeriesTable(AppendableFrameTable):
+    pandas_kind = 'series_table'
+    table_type = 'appendable_series'
+    ndim = 2
+    obj_type = Series
+
+    @property
+    def is_transposed(self) -> bool:
+        return False
+
+    @classmethod
+    def get_object(cls, obj, transposed: bool):
+        return obj
+
+    def write(self, obj, data_columns=None, **kwargs) -> None:
+        if not isinstance(obj, DataFrame):
+            name = obj.name or 'values'
+            obj = obj.to_frame(name)
+        super().write(obj=obj, data_columns=obj.columns.tolist(), **kwargs)
+
+    def read(self, where=None, columns=None, start: int | None=None, stop: int | None=None) -> Series:
+        is_multi_index = self.is_multi_index
+        if columns is not None and is_multi_index:
+            assert isinstance(self.levels, list)
+            for n in self.levels:
+                if n not in columns:
+                    columns.insert(0, n)
+        s = super().read(where=where, columns=columns, start=start, stop=stop)
+        if is_multi_index:
+            s.set_index(self.levels, inplace=True)
+        s = s.iloc[:, 0]
+        if s.name == 'values':
+            s.name = None
+        return s
+
+class AppendableMultiSeriesTable(AppendableSeriesTable):
+    pandas_kind = 'series_table'
+    table_type = 'appendable_multiseries'
+
+    def write(self, obj, **kwargs) -> None:
+        name = obj.name or 'values'
+        (newobj, self.levels) = self.validate_multiindex(obj)
+        assert isinstance(self.levels, list)
+        cols = list(self.levels)
+        cols.append(name)
+        newobj.columns = Index(cols)
+        super().write(obj=newobj, **kwargs)
+
+class GenericTable(AppendableFrameTable):
+    pandas_kind = 'frame_table'
+    table_type = 'generic_table'
+    ndim = 2
+    obj_type = DataFrame
+    levels: list[Hashable]
+
+    @property
+    def pandas_type(self) -> str:
+        return self.pandas_kind
+
+    @property
+    def storable(self):
+        return getattr(self.group, 'table', None) or self.group
+
+    def get_attrs(self) -> None:
+        self.non_index_axes = []
+        self.nan_rep = None
+        self.levels = []
+        self.index_axes = [a for a in self.indexables if a.is_an_indexable]
+        self.values_axes = [a for a in self.indexables if not a.is_an_indexable]
+        self.data_columns = [a.name for a in self.values_axes]
+
+    @cache_readonly
+    def indexables(self):
+        d = self.description
+        md = self.read_metadata('index')
+        meta = 'category' if md is not None else None
+        index_col = GenericIndexCol(name='index', axis=0, table=self.table, meta=meta, metadata=md)
+        _indexables: list[GenericIndexCol | GenericDataIndexableCol] = [index_col]
+        for (i, n) in enumerate(d._v_names):
+            assert isinstance(n, str)
+            atom = getattr(d, n)
+            md = self.read_metadata(n)
+            meta = 'category' if md is not None else None
+            dc = GenericDataIndexableCol(name=n, pos=i, values=[n], typ=atom, table=self.table, meta=meta, metadata=md)
+            _indexables.append(dc)
+        return _indexables
+
+    def write(self, **kwargs) -> None:
+        raise NotImplementedError('cannot write on an generic table')
+
+class AppendableMultiFrameTable(AppendableFrameTable):
+    table_type = 'appendable_multiframe'
+    obj_type = DataFrame
+    ndim = 2
+    _re_levels = re.compile('^level_\\d+$')
+
+    @property
+    def table_type_short(self) -> str:
+        return 'appendable_multi'
+
+    def write(self, obj, data_columns=None, **kwargs) -> None:
+        if data_columns is None:
+            data_columns = []
+        elif data_columns is True:
+            data_columns = obj.columns.tolist()
+        (obj, self.levels) = self.validate_multiindex(obj)
+        assert isinstance(self.levels, list)
+        for n in self.levels:
+            if n not in data_columns:
+                data_columns.insert(0, n)
+        super().write(obj=obj, data_columns=data_columns, **kwargs)
+
+    def read(self, where=None, columns=None, start: int | None=None, stop: int | None=None) -> DataFrame:
+        df = super().read(where=where, columns=columns, start=start, stop=stop)
+        df = df.set_index(self.levels)
+        df.index = df.index.set_names([None if self._re_levels.search(name) else name for name in df.index.names])
+        return df
+
+def _reindex_axis(obj: DataFrame, axis: AxisInt, labels: Index, other=None) -> DataFrame:
+    ax = obj._get_axis(axis)
+    labels = ensure_index(labels)
+    if other is not None:
+        other = ensure_index(other)
+    if (other is None or labels.equals(other)) and labels.equals(ax):
+        return obj
+    labels = ensure_index(labels.unique())
+    if other is not None:
+        labels = ensure_index(other.unique()).intersection(labels, sort=False)
+    if not labels.equals(ax):
+        slicer: list[slice | Index] = [slice(None, None)] * obj.ndim
+        slicer[axis] = labels
+        obj = obj.loc[tuple(slicer)]
+    return obj
+
+def _get_tz(tz: tzinfo) -> str | tzinfo:
+    zone = timezones.get_timezone(tz)
+    return zone
+
+def _set_tz(values: npt.NDArray[np.int64], tz: str | tzinfo | None, datetime64_dtype: str) -> DatetimeArray:
+    assert values.dtype == 'i8', values.dtype
+    (unit, _) = np.datetime_data(datetime64_dtype)
+    dtype = tz_to_dtype(tz=tz, unit=unit)
+    dta = DatetimeArray._from_sequence(values, dtype=dtype)
+    return dta
+
+def _convert_index(name: str, index: Index, encoding: str, errors: str) -> IndexCol:
+    assert isinstance(name, str)
+    index_name = index.name
+    (converted, dtype_name) = _get_data_and_dtype_name(index)
+    kind = _dtype_to_kind(dtype_name)
+    atom = DataIndexableCol._get_atom(converted)
+    if lib.is_np_dtype(index.dtype, 'iu') or needs_i8_conversion(index.dtype) or is_bool_dtype(index.dtype):
+        return IndexCol(name, values=converted, kind=kind, typ=atom, freq=getattr(index, 'freq', None), tz=getattr(index, 'tz', None), index_name=index_name)
+    if isinstance(index, MultiIndex):
+        raise TypeError('MultiIndex not supported here!')
+    inferred_type = lib.infer_dtype(index, skipna=False)
+    values = np.asarray(index)
+    if inferred_type == 'date':
+        converted = np.asarray([v.toordinal() for v in values], dtype=np.int32)
+        return IndexCol(name, converted, 'date', _tables().Time32Col(), index_name=index_name)
+    elif inferred_type == 'string':
+        converted = _convert_string_array(values, encoding, errors)
+        itemsize = converted.dtype.itemsize
+        return IndexCol(name, converted, 'string', _tables().StringCol(itemsize), index_name=index_name)
+    elif inferred_type in ['integer', 'floating']:
+        return IndexCol(name, values=converted, kind=kind, typ=atom, index_name=index_name)
+    else:
+        assert isinstance(converted, np.ndarray) and converted.dtype == object
+        assert kind == 'object', kind
+        atom = _tables().ObjectAtom()
+        return IndexCol(name, converted, kind, atom, index_name=index_name)
+
+def _unconvert_index(data, kind: str, encoding: str, errors: str) -> np.ndarray | Index:
+    index: Index | np.ndarray
+    if kind.startswith('datetime64'):
+        if kind == 'datetime64':
+            index = DatetimeIndex(data)
+        else:
+            index = DatetimeIndex(data.view(kind))
+    elif kind == 'timedelta64':
+        index = TimedeltaIndex(data)
+    elif kind == 'date':
+        try:
+            index = np.asarray([date.fromordinal(v) for v in data], dtype=object)
+        except ValueError:
+            index = np.asarray([date.fromtimestamp(v) for v in data], dtype=object)
+    elif kind in ('integer', 'float', 'bool'):
+        index = np.asarray(data)
+    elif kind in 'string':
+        index = _unconvert_string_array(data, nan_rep=None, encoding=encoding, errors=errors)
+    elif kind == 'object':
+        index = np.asarray(data[0])
+    else:
+        raise ValueError(f'unrecognized index type {kind}')
+    return index
+
+def _maybe_convert_for_string_atom(name: str, bvalues: ArrayLike, existing_col, min_itemsize, nan_rep, encoding, errors, columns: list[str]):
+    if bvalues.dtype != object:
+        return bvalues
+    bvalues = cast(np.ndarray, bvalues)
+    dtype_name = bvalues.dtype.name
+    inferred_type = lib.infer_dtype(bvalues, skipna=False)
+    if inferred_type == 'date':
+        raise TypeError('[date] is not implemented as a table column')
+    if inferred_type == 'datetime':
+        raise TypeError('too many timezones in this block, create separate data columns')
+    if not (inferred_type == 'string' or dtype_name == 'object'):
+        return bvalues
+    mask = isna(bvalues)
+    data = bvalues.copy()
+    data[mask] = nan_rep
+    inferred_type = lib.infer_dtype(data, skipna=False)
+    if inferred_type != 'string':
+        for i in range(data.shape[0]):
+            col = data[i]
+            inferred_type = lib.infer_dtype(col, skipna=False)
+            if inferred_type != 'string':
+                error_column_label = columns[i] if len(columns) > i else f'No.{i}'
+                raise TypeError(f'Cannot serialize the column [{error_column_label}]\nbecause its data contents are not [string] but [{inferred_type}] object dtype')
+    data_converted = _convert_string_array(data, encoding, errors).reshape(data.shape)
+    itemsize = data_converted.itemsize
+    if isinstance(min_itemsize, dict):
+        min_itemsize = int(min_itemsize.get(name) or min_itemsize.get('values') or 0)
+    itemsize = max(min_itemsize or 0, itemsize)
+    if existing_col is not None:
+        eci = existing_col.validate_col(itemsize)
+        if eci is not None and eci > itemsize:
+            itemsize = eci
+    data_converted = data_converted.astype(f'|S{itemsize}', copy=False)
+    return data_converted
+
+def _convert_string_array(data: np.ndarray, encoding: str, errors: str) -> np.ndarray:
+    if len(data):
+        data = Series(data.ravel(), copy=False).str.encode(encoding, errors)._values.reshape(data.shape)
+    ensured = ensure_object(data.ravel())
+    itemsize = max(1, libwriters.max_len_string_array(ensured))
+    data = np.asarray(data, dtype=f'S{itemsize}')
+    return data
+
+def _unconvert_string_array(data: np.ndarray, nan_rep, encoding: str, errors: str) -> np.ndarray:
+    shape = data.shape
+    data = np.asarray(data.ravel(), dtype=object)
+    if len(data):
+        itemsize = libwriters.max_len_string_array(ensure_object(data))
+        dtype = f'U{itemsize}'
+        if isinstance(data[0], bytes):
+            data = Series(data, copy=False).str.decode(encoding, errors=errors)._values
+        else:
+            data = data.astype(dtype, copy=False).astype(object, copy=False)
+    if nan_rep is None:
+        nan_rep = 'nan'
+    libwriters.string_array_replace_from_nan_rep(data, nan_rep)
+    return data.reshape(shape)
+
+def _maybe_convert(values: np.ndarray, val_kind: str, encoding: str, errors: str):
+    assert isinstance(val_kind, str), type(val_kind)
+    if _need_convert(val_kind):
+        conv = _get_converter(val_kind, encoding, errors)
+        values = conv(values)
+    return values
+
+def _get_converter(kind: str, encoding: str, errors: str):
+    if kind == 'datetime64':
+        return lambda x: np.asarray(x, dtype='M8[ns]')
+    elif 'datetime64' in kind:
+        return lambda x: np.asarray(x, dtype=kind)
+    elif kind == 'string':
+        return lambda x: _unconvert_string_array(x, nan_rep=None, encoding=encoding, errors=errors)
+    else:
+        raise ValueError(f'invalid kind {kind}')
+
+def _need_convert(kind: str) -> bool:
+    if kind in ('datetime64', 'string') or 'datetime64' in kind:
+        return True
+    return False
+
+def _maybe_adjust_name(name: str, version: Sequence[int]) -> str:
+    if isinstance(version, str) or len(version) < 3:
+        raise ValueError('Version is incorrect, expected sequence of 3 integers.')
+    if version[0] == 0 and version[1] <= 10 and (version[2] == 0):
+        m = re.search('values_block_(\\d+)', name)
+        if m:
+            grp = m.groups()[0]
+            name = f'values_{grp}'
+    return name
+
+def _dtype_to_kind(dtype_str: str) -> str:
+    if dtype_str.startswith(('string', 'bytes')):
+        kind = 'string'
+    elif dtype_str.startswith('float'):
+        kind = 'float'
+    elif dtype_str.startswith('complex'):
+        kind = 'complex'
+    elif dtype_str.startswith(('int', 'uint')):
+        kind = 'integer'
+    elif dtype_str.startswith('datetime64'):
+        kind = dtype_str
+    elif dtype_str.startswith('timedelta'):
+        kind = 'timedelta64'
+    elif dtype_str.startswith('bool'):
+        kind = 'bool'
+    elif dtype_str.startswith('category'):
+        kind = 'category'
+    elif dtype_str.startswith('period'):
+        kind = 'integer'
+    elif dtype_str == 'object':
+        kind = 'object'
+    else:
+        raise ValueError(f'cannot interpret dtype of [{dtype_str}]')
+    return kind
+
+def _get_data_and_dtype_name(data: ArrayLike):
+    if isinstance(data, Categorical):
+        data = data.codes
+    if isinstance(data.dtype, DatetimeTZDtype):
+        dtype_name = f'datetime64[{data.dtype.unit}]'
+    else:
+        dtype_name = data.dtype.name
+    if data.dtype.kind in 'mM':
+        data = np.asarray(data.view('i8'))
+    elif isinstance(data, PeriodIndex):
+        data = data.asi8
+    data = np.asarray(data)
+    return (data, dtype_name)
+
+class Selection:
+
+    def __init__(self, table: Table, where=None, start: int | None=None, stop: int | None=None) -> None:
+        self.table = table
+        self.where = where
+        self.start = start
+        self.stop = stop
+        self.condition = None
+        self.filter = None
+        self.terms = None
+        self.coordinates = None
+        if is_list_like(where):
+            with suppress(ValueError):
+                inferred = lib.infer_dtype(where, skipna=False)
+                if inferred in ('integer', 'boolean'):
+                    where = np.asarray(where)
+                    if where.dtype == np.bool_:
+                        (start, stop) = (self.start, self.stop)
+                        if start is None:
+                            start = 0
+                        if stop is None:
+                            stop = self.table.nrows
+                        self.coordinates = np.arange(start, stop)[where]
+                    elif issubclass(where.dtype.type, np.integer):
+                        if self.start is not None and (where < self.start).any() or (self.stop is not None and (where >= self.stop).any()):
+                            raise ValueError('where must have index locations >= start and < stop')
+                        self.coordinates = where
+        if self.coordinates is None:
+            self.terms = self.generate(where)
+            if self.terms is not None:
+                (self.condition, self.filter) = self.terms.evaluate()
+
+    @overload
+    def generate(self, where: dict | list | tuple | str) -> PyTablesExpr:
+        ...
+
+    @overload
+    def generate(self, where: None) -> None:
+        ...
+
+    def generate(self, where: dict | list | tuple | str | None) -> PyTablesExpr | None:
+        if where is None:
+            return None
+        q = self.table.queryables()
+        try:
+            return PyTablesExpr(where, queryables=q, encoding=self.table.encoding)
+        except NameError as err:
+            qkeys = ','.join(q.keys())
+            msg = dedent(f"                The passed where expression: {where}\n                            contains an invalid variable reference\n                            all of the variable references must be a reference to\n                            an axis (e.g. 'index' or 'columns'), or a data_column\n                            The currently defined references are: {qkeys}\n                ")
+            raise ValueError(msg) from err
+
+    def select(self):
+        if self.condition is not None:
+            return self.table.table.read_where(self.condition.format(), start=self.start, stop=self.stop)
+        elif self.coordinates is not None:
+            return self.table.table.read_coordinates(self.coordinates)
+        return self.table.table.read(start=self.start, stop=self.stop)
+
+    def select_coords(self):
+        (start, stop) = (self.start, self.stop)
+        nrows = self.table.nrows
+        if start is None:
+            start = 0
+        elif start < 0:
+            start += nrows
+        if stop is None:
+            stop = nrows
+        elif stop < 0:
+            stop += nrows
+        if self.condition is not None:
+            return self.table.table.get_where_list(self.condition.format(), start=start, stop=stop, sort=True)
+        elif self.coordinates is not None:
+            return self.coordinates
+        return np.arange(start, stop)
+
+# File: pandas-main/pandas/io/sas/sas7bdat.py
+""""""
+from __future__ import annotations
+from datetime import datetime
+import sys
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs.byteswap import read_double_with_byteswap, read_float_with_byteswap, read_uint16_with_byteswap, read_uint32_with_byteswap, read_uint64_with_byteswap
+from pandas._libs.sas import Parser, get_subheader_index
+from pandas._libs.tslibs.conversion import cast_from_unit_vectorized
+from pandas.errors import EmptyDataError
+import pandas as pd
+from pandas import DataFrame, Timestamp
+from pandas.io.common import get_handle
+import pandas.io.sas.sas_constants as const
+from pandas.io.sas.sasreader import SASReader
+if TYPE_CHECKING:
+    from pandas._typing import CompressionOptions, FilePath, ReadBuffer
+_unix_origin = Timestamp('1970-01-01')
+_sas_origin = Timestamp('1960-01-01')
+
+def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
+    td = (_sas_origin - _unix_origin).as_unit('s')
+    if unit == 's':
+        millis = cast_from_unit_vectorized(sas_datetimes._values, unit='s', out_unit='ms')
+        dt64ms = millis.view('M8[ms]') + td
+        return pd.Series(dt64ms, index=sas_datetimes.index, copy=False)
+    else:
+        vals = np.array(sas_datetimes, dtype='M8[D]') + td
+        return pd.Series(vals, dtype='M8[s]', index=sas_datetimes.index, copy=False)
+
+class _Column:
+    col_id: int
+    name: str | bytes
+    label: str | bytes
+    format: str | bytes
+    ctype: bytes
+    length: int
+
+    def __init__(self, col_id: int, name: str | bytes, label: str | bytes, format: str | bytes, ctype: bytes, length: int) -> None:
+        self.col_id = col_id
+        self.name = name
+        self.label = label
+        self.format = format
+        self.ctype = ctype
+        self.length = length
+
+class SAS7BDATReader(SASReader):
+    _int_length: int
+    _cached_page: bytes | None
+
+    def __init__(self, path_or_buf: FilePath | ReadBuffer[bytes], index=None, convert_dates: bool=True, blank_missing: bool=True, chunksize: int | None=None, encoding: str | None=None, convert_text: bool=True, convert_header_text: bool=True, compression: CompressionOptions='infer') -> None:
+        self.index = index
+        self.convert_dates = convert_dates
+        self.blank_missing = blank_missing
+        self.chunksize = chunksize
+        self.encoding = encoding
+        self.convert_text = convert_text
+        self.convert_header_text = convert_header_text
+        self.default_encoding = 'latin-1'
+        self.compression = b''
+        self.column_names_raw: list[bytes] = []
+        self.column_names: list[str | bytes] = []
+        self.column_formats: list[str | bytes] = []
+        self.columns: list[_Column] = []
+        self._current_page_data_subheader_pointers: list[tuple[int, int]] = []
+        self._cached_page = None
+        self._column_data_lengths: list[int] = []
+        self._column_data_offsets: list[int] = []
+        self._column_types: list[bytes] = []
+        self._current_row_in_file_index = 0
+        self._current_row_on_page_index = 0
+        self._current_row_in_file_index = 0
+        self.handles = get_handle(path_or_buf, 'rb', is_text=False, compression=compression)
+        self._path_or_buf = self.handles.handle
+        self._subheader_processors = [self._process_rowsize_subheader, self._process_columnsize_subheader, self._process_subheader_counts, self._process_columntext_subheader, self._process_columnname_subheader, self._process_columnattributes_subheader, self._process_format_subheader, self._process_columnlist_subheader, None]
+        try:
+            self._get_properties()
+            self._parse_metadata()
+        except Exception:
+            self.close()
+            raise
+
+    def column_data_lengths(self) -> np.ndarray:
+        return np.asarray(self._column_data_lengths, dtype=np.int64)
+
+    def column_data_offsets(self) -> np.ndarray:
+        return np.asarray(self._column_data_offsets, dtype=np.int64)
+
+    def column_types(self) -> np.ndarray:
+        return np.asarray(self._column_types, dtype=np.dtype('S1'))
+
+    def close(self) -> None:
+        self.handles.close()
+
+    def _get_properties(self) -> None:
+        self._path_or_buf.seek(0)
+        self._cached_page = self._path_or_buf.read(288)
+        if self._cached_page[0:len(const.magic)] != const.magic:
+            raise ValueError('magic number mismatch (not a SAS file?)')
+        buf = self._read_bytes(const.align_1_offset, const.align_1_length)
+        if buf == const.u64_byte_checker_value:
+            self.U64 = True
+            self._int_length = 8
+            self._page_bit_offset = const.page_bit_offset_x64
+            self._subheader_pointer_length = const.subheader_pointer_length_x64
+        else:
+            self.U64 = False
+            self._page_bit_offset = const.page_bit_offset_x86
+            self._subheader_pointer_length = const.subheader_pointer_length_x86
+            self._int_length = 4
+        buf = self._read_bytes(const.align_2_offset, const.align_2_length)
+        if buf == const.align_1_checker_value:
+            align1 = const.align_2_value
+        else:
+            align1 = 0
+        buf = self._read_bytes(const.endianness_offset, const.endianness_length)
+        if buf == b'\x01':
+            self.byte_order = '<'
+            self.need_byteswap = sys.byteorder == 'big'
+        else:
+            self.byte_order = '>'
+            self.need_byteswap = sys.byteorder == 'little'
+        buf = self._read_bytes(const.encoding_offset, const.encoding_length)[0]
+        if buf in const.encoding_names:
+            self.inferred_encoding = const.encoding_names[buf]
+            if self.encoding == 'infer':
+                self.encoding = self.inferred_encoding
+        else:
+            self.inferred_encoding = f'unknown (code={buf})'
+        epoch = datetime(1960, 1, 1)
+        x = self._read_float(const.date_created_offset + align1, const.date_created_length)
+        self.date_created = epoch + pd.to_timedelta(x, unit='s')
+        x = self._read_float(const.date_modified_offset + align1, const.date_modified_length)
+        self.date_modified = epoch + pd.to_timedelta(x, unit='s')
+        self.header_length = self._read_uint(const.header_size_offset + align1, const.header_size_length)
+        buf = self._path_or_buf.read(self.header_length - 288)
+        self._cached_page += buf
+        if len(self._cached_page) != self.header_length:
+            raise ValueError('The SAS7BDAT file appears to be truncated.')
+        self._page_length = self._read_uint(const.page_size_offset + align1, const.page_size_length)
+
+    def __next__(self) -> DataFrame:
+        da = self.read(nrows=self.chunksize or 1)
+        if da.empty:
+            self.close()
+            raise StopIteration
+        return da
+
+    def _read_float(self, offset: int, width: int) -> float:
+        assert self._cached_page is not None
+        if width == 4:
+            return read_float_with_byteswap(self._cached_page, offset, self.need_byteswap)
+        elif width == 8:
+            return read_double_with_byteswap(self._cached_page, offset, self.need_byteswap)
+        else:
+            self.close()
+            raise ValueError('invalid float width')
+
+    def _read_uint(self, offset: int, width: int) -> int:
+        assert self._cached_page is not None
+        if width == 1:
+            return self._read_bytes(offset, 1)[0]
+        elif width == 2:
+            return read_uint16_with_byteswap(self._cached_page, offset, self.need_byteswap)
+        elif width == 4:
+            return read_uint32_with_byteswap(self._cached_page, offset, self.need_byteswap)
+        elif width == 8:
+            return read_uint64_with_byteswap(self._cached_page, offset, self.need_byteswap)
+        else:
+            self.close()
+            raise ValueError('invalid int width')
+
+    def _read_bytes(self, offset: int, length: int):
+        assert self._cached_page is not None
+        if offset + length > len(self._cached_page):
+            self.close()
+            raise ValueError('The cached page is too small.')
+        return self._cached_page[offset:offset + length]
+
+    def _parse_metadata(self) -> None:
+        done = False
+        while not done:
+            self._cached_page = self._path_or_buf.read(self._page_length)
+            if len(self._cached_page) <= 0:
+                break
+            if len(self._cached_page) != self._page_length:
+                raise ValueError('Failed to read a meta data page from the SAS file.')
+            done = self._process_page_meta()
+
+    def _process_page_meta(self) -> bool:
+        self._read_page_header()
+        pt = const.page_meta_types + [const.page_amd_type, const.page_mix_type]
+        if self._current_page_type in pt:
+            self._process_page_metadata()
+        is_data_page = self._current_page_type == const.page_data_type
+        is_mix_page = self._current_page_type == const.page_mix_type
+        return bool(is_data_page or is_mix_page or self._current_page_data_subheader_pointers != [])
+
+    def _read_page_header(self) -> None:
+        bit_offset = self._page_bit_offset
+        tx = const.page_type_offset + bit_offset
+        self._current_page_type = self._read_uint(tx, const.page_type_length) & const.page_type_mask2
+        tx = const.block_count_offset + bit_offset
+        self._current_page_block_count = self._read_uint(tx, const.block_count_length)
+        tx = const.subheader_count_offset + bit_offset
+        self._current_page_subheaders_count = self._read_uint(tx, const.subheader_count_length)
+
+    def _process_page_metadata(self) -> None:
+        bit_offset = self._page_bit_offset
+        for i in range(self._current_page_subheaders_count):
+            offset = const.subheader_pointers_offset + bit_offset
+            total_offset = offset + self._subheader_pointer_length * i
+            subheader_offset = self._read_uint(total_offset, self._int_length)
+            total_offset += self._int_length
+            subheader_length = self._read_uint(total_offset, self._int_length)
+            total_offset += self._int_length
+            subheader_compression = self._read_uint(total_offset, 1)
+            total_offset += 1
+            subheader_type = self._read_uint(total_offset, 1)
+            if subheader_length == 0 or subheader_compression == const.truncated_subheader_id:
+                continue
+            subheader_signature = self._read_bytes(subheader_offset, self._int_length)
+            subheader_index = get_subheader_index(subheader_signature)
+            subheader_processor = self._subheader_processors[subheader_index]
+            if subheader_processor is None:
+                f1 = subheader_compression in (const.compressed_subheader_id, 0)
+                f2 = subheader_type == const.compressed_subheader_type
+                if self.compression and f1 and f2:
+                    self._current_page_data_subheader_pointers.append((subheader_offset, subheader_length))
+                else:
+                    self.close()
+                    raise ValueError(f'Unknown subheader signature {subheader_signature}')
+            else:
+                subheader_processor(subheader_offset, subheader_length)
+
+    def _process_rowsize_subheader(self, offset: int, length: int) -> None:
+        int_len = self._int_length
+        lcs_offset = offset
+        lcp_offset = offset
+        if self.U64:
+            lcs_offset += 682
+            lcp_offset += 706
+        else:
+            lcs_offset += 354
+            lcp_offset += 378
+        self.row_length = self._read_uint(offset + const.row_length_offset_multiplier * int_len, int_len)
+        self.row_count = self._read_uint(offset + const.row_count_offset_multiplier * int_len, int_len)
+        self.col_count_p1 = self._read_uint(offset + const.col_count_p1_multiplier * int_len, int_len)
+        self.col_count_p2 = self._read_uint(offset + const.col_count_p2_multiplier * int_len, int_len)
+        mx = const.row_count_on_mix_page_offset_multiplier * int_len
+        self._mix_page_row_count = self._read_uint(offset + mx, int_len)
+        self._lcs = self._read_uint(lcs_offset, 2)
+        self._lcp = self._read_uint(lcp_offset, 2)
+
+    def _process_columnsize_subheader(self, offset: int, length: int) -> None:
+        int_len = self._int_length
+        offset += int_len
+        self.column_count = self._read_uint(offset, int_len)
+        if self.col_count_p1 + self.col_count_p2 != self.column_count:
+            print(f'Warning: column count mismatch ({self.col_count_p1} + {self.col_count_p2} != {self.column_count})\n')
+
+    def _process_subheader_counts(self, offset: int, length: int) -> None:
+        pass
+
+    def _process_columntext_subheader(self, offset: int, length: int) -> None:
+        offset += self._int_length
+        text_block_size = self._read_uint(offset, const.text_block_size_length)
+        buf = self._read_bytes(offset, text_block_size)
+        cname_raw = buf[0:text_block_size].rstrip(b'\x00 ')
+        self.column_names_raw.append(cname_raw)
+        if len(self.column_names_raw) == 1:
+            compression_literal = b''
+            for cl in const.compression_literals:
+                if cl in cname_raw:
+                    compression_literal = cl
+            self.compression = compression_literal
+            offset -= self._int_length
+            offset1 = offset + 16
+            if self.U64:
+                offset1 += 4
+            buf = self._read_bytes(offset1, self._lcp)
+            compression_literal = buf.rstrip(b'\x00')
+            if compression_literal == b'':
+                self._lcs = 0
+                offset1 = offset + 32
+                if self.U64:
+                    offset1 += 4
+                buf = self._read_bytes(offset1, self._lcp)
+                self.creator_proc = buf[0:self._lcp]
+            elif compression_literal == const.rle_compression:
+                offset1 = offset + 40
+                if self.U64:
+                    offset1 += 4
+                buf = self._read_bytes(offset1, self._lcp)
+                self.creator_proc = buf[0:self._lcp]
+            elif self._lcs > 0:
+                self._lcp = 0
+                offset1 = offset + 16
+                if self.U64:
+                    offset1 += 4
+                buf = self._read_bytes(offset1, self._lcs)
+                self.creator_proc = buf[0:self._lcp]
+            if hasattr(self, 'creator_proc'):
+                self.creator_proc = self._convert_header_text(self.creator_proc)
+
+    def _process_columnname_subheader(self, offset: int, length: int) -> None:
+        int_len = self._int_length
+        offset += int_len
+        column_name_pointers_count = (length - 2 * int_len - 12) // 8
+        for i in range(column_name_pointers_count):
+            text_subheader = offset + const.column_name_pointer_length * (i + 1) + const.column_name_text_subheader_offset
+            col_name_offset = offset + const.column_name_pointer_length * (i + 1) + const.column_name_offset_offset
+            col_name_length = offset + const.column_name_pointer_length * (i + 1) + const.column_name_length_offset
+            idx = self._read_uint(text_subheader, const.column_name_text_subheader_length)
+            col_offset = self._read_uint(col_name_offset, const.column_name_offset_length)
+            col_len = self._read_uint(col_name_length, const.column_name_length_length)
+            name_raw = self.column_names_raw[idx]
+            cname = name_raw[col_offset:col_offset + col_len]
+            self.column_names.append(self._convert_header_text(cname))
+
+    def _process_columnattributes_subheader(self, offset: int, length: int) -> None:
+        int_len = self._int_length
+        column_attributes_vectors_count = (length - 2 * int_len - 12) // (int_len + 8)
+        for i in range(column_attributes_vectors_count):
+            col_data_offset = offset + int_len + const.column_data_offset_offset + i * (int_len + 8)
+            col_data_len = offset + 2 * int_len + const.column_data_length_offset + i * (int_len + 8)
+            col_types = offset + 2 * int_len + const.column_type_offset + i * (int_len + 8)
+            x = self._read_uint(col_data_offset, int_len)
+            self._column_data_offsets.append(x)
+            x = self._read_uint(col_data_len, const.column_data_length_length)
+            self._column_data_lengths.append(x)
+            x = self._read_uint(col_types, const.column_type_length)
+            self._column_types.append(b'd' if x == 1 else b's')
+
+    def _process_columnlist_subheader(self, offset: int, length: int) -> None:
+        pass
+
+    def _process_format_subheader(self, offset: int, length: int) -> None:
+        int_len = self._int_length
+        text_subheader_format = offset + const.column_format_text_subheader_index_offset + 3 * int_len
+        col_format_offset = offset + const.column_format_offset_offset + 3 * int_len
+        col_format_len = offset + const.column_format_length_offset + 3 * int_len
+        text_subheader_label = offset + const.column_label_text_subheader_index_offset + 3 * int_len
+        col_label_offset = offset + const.column_label_offset_offset + 3 * int_len
+        col_label_len = offset + const.column_label_length_offset + 3 * int_len
+        x = self._read_uint(text_subheader_format, const.column_format_text_subheader_index_length)
+        format_idx = min(x, len(self.column_names_raw) - 1)
+        format_start = self._read_uint(col_format_offset, const.column_format_offset_length)
+        format_len = self._read_uint(col_format_len, const.column_format_length_length)
+        label_idx = self._read_uint(text_subheader_label, const.column_label_text_subheader_index_length)
+        label_idx = min(label_idx, len(self.column_names_raw) - 1)
+        label_start = self._read_uint(col_label_offset, const.column_label_offset_length)
+        label_len = self._read_uint(col_label_len, const.column_label_length_length)
+        label_names = self.column_names_raw[label_idx]
+        column_label = self._convert_header_text(label_names[label_start:label_start + label_len])
+        format_names = self.column_names_raw[format_idx]
+        column_format = self._convert_header_text(format_names[format_start:format_start + format_len])
+        current_column_number = len(self.columns)
+        col = _Column(current_column_number, self.column_names[current_column_number], column_label, column_format, self._column_types[current_column_number], self._column_data_lengths[current_column_number])
+        self.column_formats.append(column_format)
+        self.columns.append(col)
+
+    def read(self, nrows: int | None=None) -> DataFrame:
+        if nrows is None and self.chunksize is not None:
+            nrows = self.chunksize
+        elif nrows is None:
+            nrows = self.row_count
+        if len(self._column_types) == 0:
+            self.close()
+            raise EmptyDataError('No columns to parse from file')
+        if nrows > 0 and self._current_row_in_file_index >= self.row_count:
+            return DataFrame()
+        nrows = min(nrows, self.row_count - self._current_row_in_file_index)
+        nd = self._column_types.count(b'd')
+        ns = self._column_types.count(b's')
+        self._string_chunk = np.empty((ns, nrows), dtype=object)
+        self._byte_chunk = np.zeros((nd, 8 * nrows), dtype=np.uint8)
+        self._current_row_in_chunk_index = 0
+        p = Parser(self)
+        p.read(nrows)
+        rslt = self._chunk_to_dataframe()
+        if self.index is not None:
+            rslt = rslt.set_index(self.index)
+        return rslt
+
+    def _read_next_page(self):
+        self._current_page_data_subheader_pointers = []
+        self._cached_page = self._path_or_buf.read(self._page_length)
+        if len(self._cached_page) <= 0:
+            return True
+        elif len(self._cached_page) != self._page_length:
+            self.close()
+            msg = f'failed to read complete page from file (read {len(self._cached_page):d} of {self._page_length:d} bytes)'
+            raise ValueError(msg)
+        self._read_page_header()
+        if self._current_page_type in const.page_meta_types:
+            self._process_page_metadata()
+        if self._current_page_type not in const.page_meta_types + [const.page_data_type, const.page_mix_type]:
+            return self._read_next_page()
+        return False
+
+    def _chunk_to_dataframe(self) -> DataFrame:
+        n = self._current_row_in_chunk_index
+        m = self._current_row_in_file_index
+        ix = range(m - n, m)
+        rslt = {}
+        (js, jb) = (0, 0)
+        for j in range(self.column_count):
+            name = self.column_names[j]
+            if self._column_types[j] == b'd':
+                col_arr = self._byte_chunk[jb, :].view(dtype=self.byte_order + 'd')
+                rslt[name] = pd.Series(col_arr, dtype=np.float64, index=ix, copy=False)
+                if self.convert_dates:
+                    if self.column_formats[j] in const.sas_date_formats:
+                        rslt[name] = _convert_datetimes(rslt[name], 'd')
+                    elif self.column_formats[j] in const.sas_datetime_formats:
+                        rslt[name] = _convert_datetimes(rslt[name], 's')
+                jb += 1
+            elif self._column_types[j] == b's':
+                rslt[name] = pd.Series(self._string_chunk[js, :], index=ix, copy=False)
+                if self.convert_text and self.encoding is not None:
+                    rslt[name] = self._decode_string(rslt[name].str)
+                js += 1
+            else:
+                self.close()
+                raise ValueError(f'unknown column type {self._column_types[j]!r}')
+        df = DataFrame(rslt, columns=self.column_names, index=ix, copy=False)
+        return df
+
+    def _decode_string(self, b):
+        return b.decode(self.encoding or self.default_encoding)
+
+    def _convert_header_text(self, b: bytes) -> str | bytes:
+        if self.convert_header_text:
+            return self._decode_string(b)
+        else:
+            return b
+
+# File: pandas-main/pandas/io/sas/sas_constants.py
+from __future__ import annotations
+from typing import Final
+magic: Final = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\xea\x81`\xb3\x14\x11\xcf\xbd\x92\x08\x00\t\xc71\x8c\x18\x1f\x10\x11'
+align_1_checker_value: Final = b'3'
+align_1_offset: Final = 32
+align_1_length: Final = 1
+align_1_value: Final = 4
+u64_byte_checker_value: Final = b'3'
+align_2_offset: Final = 35
+align_2_length: Final = 1
+align_2_value: Final = 4
+endianness_offset: Final = 37
+endianness_length: Final = 1
+platform_offset: Final = 39
+platform_length: Final = 1
+encoding_offset: Final = 70
+encoding_length: Final = 1
+dataset_offset: Final = 92
+dataset_length: Final = 64
+file_type_offset: Final = 156
+file_type_length: Final = 8
+date_created_offset: Final = 164
+date_created_length: Final = 8
+date_modified_offset: Final = 172
+date_modified_length: Final = 8
+header_size_offset: Final = 196
+header_size_length: Final = 4
+page_size_offset: Final = 200
+page_size_length: Final = 4
+page_count_offset: Final = 204
+page_count_length: Final = 4
+sas_release_offset: Final = 216
+sas_release_length: Final = 8
+sas_server_type_offset: Final = 224
+sas_server_type_length: Final = 16
+os_version_number_offset: Final = 240
+os_version_number_length: Final = 16
+os_maker_offset: Final = 256
+os_maker_length: Final = 16
+os_name_offset: Final = 272
+os_name_length: Final = 16
+page_bit_offset_x86: Final = 16
+page_bit_offset_x64: Final = 32
+subheader_pointer_length_x86: Final = 12
+subheader_pointer_length_x64: Final = 24
+page_type_offset: Final = 0
+page_type_length: Final = 2
+block_count_offset: Final = 2
+block_count_length: Final = 2
+subheader_count_offset: Final = 4
+subheader_count_length: Final = 2
+page_type_mask: Final = 3840
+page_type_mask2: Final = 61440 | page_type_mask
+page_meta_type: Final = 0
+page_data_type: Final = 256
+page_mix_type: Final = 512
+page_amd_type: Final = 1024
+page_meta2_type: Final = 16384
+page_comp_type: Final = 36864
+page_meta_types: Final = [page_meta_type, page_meta2_type]
+subheader_pointers_offset: Final = 8
+truncated_subheader_id: Final = 1
+compressed_subheader_id: Final = 4
+compressed_subheader_type: Final = 1
+text_block_size_length: Final = 2
+row_length_offset_multiplier: Final = 5
+row_count_offset_multiplier: Final = 6
+col_count_p1_multiplier: Final = 9
+col_count_p2_multiplier: Final = 10
+row_count_on_mix_page_offset_multiplier: Final = 15
+column_name_pointer_length: Final = 8
+column_name_text_subheader_offset: Final = 0
+column_name_text_subheader_length: Final = 2
+column_name_offset_offset: Final = 2
+column_name_offset_length: Final = 2
+column_name_length_offset: Final = 4
+column_name_length_length: Final = 2
+column_data_offset_offset: Final = 8
+column_data_length_offset: Final = 8
+column_data_length_length: Final = 4
+column_type_offset: Final = 14
+column_type_length: Final = 1
+column_format_text_subheader_index_offset: Final = 22
+column_format_text_subheader_index_length: Final = 2
+column_format_offset_offset: Final = 24
+column_format_offset_length: Final = 2
+column_format_length_offset: Final = 26
+column_format_length_length: Final = 2
+column_label_text_subheader_index_offset: Final = 28
+column_label_text_subheader_index_length: Final = 2
+column_label_offset_offset: Final = 30
+column_label_offset_length: Final = 2
+column_label_length_offset: Final = 32
+column_label_length_length: Final = 2
+rle_compression: Final = b'SASYZCRL'
+rdc_compression: Final = b'SASYZCR2'
+compression_literals: Final = [rle_compression, rdc_compression]
+encoding_names: Final = {20: 'utf-8', 29: 'latin1', 30: 'latin2', 31: 'latin3', 32: 'latin4', 33: 'cyrillic', 34: 'arabic', 35: 'greek', 36: 'hebrew', 37: 'latin5', 38: 'latin6', 39: 'cp874', 40: 'latin9', 41: 'cp437', 42: 'cp850', 43: 'cp852', 44: 'cp857', 45: 'cp858', 46: 'cp862', 47: 'cp864', 48: 'cp865', 49: 'cp866', 50: 'cp869', 51: 'cp874', 55: 'cp720', 56: 'cp737', 57: 'cp775', 58: 'cp860', 59: 'cp863', 60: 'cp1250', 61: 'cp1251', 62: 'cp1252', 63: 'cp1253', 64: 'cp1254', 65: 'cp1255', 66: 'cp1256', 67: 'cp1257', 68: 'cp1258', 118: 'cp950', 123: 'big5', 125: 'gb2312', 126: 'cp936', 134: 'euc_jp', 136: 'cp932', 138: 'shift_jis', 140: 'euc-kr', 141: 'cp949', 227: 'latin8'}
+
+class SASIndex:
+    row_size_index: Final = 0
+    column_size_index: Final = 1
+    subheader_counts_index: Final = 2
+    column_text_index: Final = 3
+    column_name_index: Final = 4
+    column_attributes_index: Final = 5
+    format_and_label_index: Final = 6
+    column_list_index: Final = 7
+    data_subheader_index: Final = 8
+subheader_signature_to_index: Final = {b'\xf7\xf7\xf7\xf7': SASIndex.row_size_index, b'\x00\x00\x00\x00\xf7\xf7\xf7\xf7': SASIndex.row_size_index, b'\xf7\xf7\xf7\xf7\x00\x00\x00\x00': SASIndex.row_size_index, b'\xf7\xf7\xf7\xf7\xff\xff\xfb\xfe': SASIndex.row_size_index, b'\xf6\xf6\xf6\xf6': SASIndex.column_size_index, b'\x00\x00\x00\x00\xf6\xf6\xf6\xf6': SASIndex.column_size_index, b'\xf6\xf6\xf6\xf6\x00\x00\x00\x00': SASIndex.column_size_index, b'\xf6\xf6\xf6\xf6\xff\xff\xfb\xfe': SASIndex.column_size_index, b'\x00\xfc\xff\xff': SASIndex.subheader_counts_index, b'\xff\xff\xfc\x00': SASIndex.subheader_counts_index, b'\x00\xfc\xff\xff\xff\xff\xff\xff': SASIndex.subheader_counts_index, b'\xff\xff\xff\xff\xff\xff\xfc\x00': SASIndex.subheader_counts_index, b'\xfd\xff\xff\xff': SASIndex.column_text_index, b'\xff\xff\xff\xfd': SASIndex.column_text_index, b'\xfd\xff\xff\xff\xff\xff\xff\xff': SASIndex.column_text_index, b'\xff\xff\xff\xff\xff\xff\xff\xfd': SASIndex.column_text_index, b'\xff\xff\xff\xff': SASIndex.column_name_index, b'\xff\xff\xff\xff\xff\xff\xff\xff': SASIndex.column_name_index, b'\xfc\xff\xff\xff': SASIndex.column_attributes_index, b'\xff\xff\xff\xfc': SASIndex.column_attributes_index, b'\xfc\xff\xff\xff\xff\xff\xff\xff': SASIndex.column_attributes_index, b'\xff\xff\xff\xff\xff\xff\xff\xfc': SASIndex.column_attributes_index, b'\xfe\xfb\xff\xff': SASIndex.format_and_label_index, b'\xff\xff\xfb\xfe': SASIndex.format_and_label_index, b'\xfe\xfb\xff\xff\xff\xff\xff\xff': SASIndex.format_and_label_index, b'\xff\xff\xff\xff\xff\xff\xfb\xfe': SASIndex.format_and_label_index, b'\xfe\xff\xff\xff': SASIndex.column_list_index, b'\xff\xff\xff\xfe': SASIndex.column_list_index, b'\xfe\xff\xff\xff\xff\xff\xff\xff': SASIndex.column_list_index, b'\xff\xff\xff\xff\xff\xff\xff\xfe': SASIndex.column_list_index}
+sas_date_formats: Final = ('DATE', 'DAY', 'DDMMYY', 'DOWNAME', 'JULDAY', 'JULIAN', 'MMDDYY', 'MMYY', 'MMYYC', 'MMYYD', 'MMYYP', 'MMYYS', 'MMYYN', 'MONNAME', 'MONTH', 'MONYY', 'QTR', 'QTRR', 'NENGO', 'WEEKDATE', 'WEEKDATX', 'WEEKDAY', 'WEEKV', 'WORDDATE', 'WORDDATX', 'YEAR', 'YYMM', 'YYMMC', 'YYMMD', 'YYMMP', 'YYMMS', 'YYMMN', 'YYMON', 'YYMMDD', 'YYQ', 'YYQC', 'YYQD', 'YYQP', 'YYQS', 'YYQN', 'YYQR', 'YYQRC', 'YYQRD', 'YYQRP', 'YYQRS', 'YYQRN', 'YYMMDDP', 'YYMMDDC', 'E8601DA', 'YYMMDDN', 'MMDDYYC', 'MMDDYYS', 'MMDDYYD', 'YYMMDDS', 'B8601DA', 'DDMMYYN', 'YYMMDDD', 'DDMMYYB', 'DDMMYYP', 'MMDDYYP', 'YYMMDDB', 'MMDDYYN', 'DDMMYYC', 'DDMMYYD', 'DDMMYYS', 'MINGUO')
+sas_datetime_formats: Final = ('DATETIME', 'DTWKDATX', 'B8601DN', 'B8601DT', 'B8601DX', 'B8601DZ', 'B8601LX', 'E8601DN', 'E8601DT', 'E8601DX', 'E8601DZ', 'E8601LX', 'DATEAMPM', 'DTDATE', 'DTMONYY', 'DTMONYY', 'DTWKDATX', 'DTYEAR', 'TOD', 'MDYAMPM')
+
+# File: pandas-main/pandas/io/sas/sas_xport.py
+""""""
+from __future__ import annotations
+from datetime import datetime
+import struct
+from typing import TYPE_CHECKING
+import warnings
+import numpy as np
+from pandas.util._decorators import Appender
+from pandas.util._exceptions import find_stack_level
+import pandas as pd
+from pandas.io.common import get_handle
+from pandas.io.sas.sasreader import SASReader
+if TYPE_CHECKING:
+    from pandas._typing import CompressionOptions, DatetimeNaTType, FilePath, ReadBuffer
+_correct_line1 = 'HEADER RECORD*******LIBRARY HEADER RECORD!!!!!!!000000000000000000000000000000  '
+_correct_header1 = 'HEADER RECORD*******MEMBER  HEADER RECORD!!!!!!!000000000000000001600000000'
+_correct_header2 = 'HEADER RECORD*******DSCRPTR HEADER RECORD!!!!!!!000000000000000000000000000000  '
+_correct_obs_header = 'HEADER RECORD*******OBS     HEADER RECORD!!!!!!!000000000000000000000000000000  '
+_fieldkeys = ['ntype', 'nhfun', 'field_length', 'nvar0', 'name', 'label', 'nform', 'nfl', 'num_decimals', 'nfj', 'nfill', 'niform', 'nifl', 'nifd', 'npos', '_']
+_base_params_doc = 'Parameters\n----------\nfilepath_or_buffer : str or file-like object\n    Path to SAS file or object implementing binary read method.'
+_params2_doc = 'index : identifier of index column\n    Identifier of column that should be used as index of the DataFrame.\nencoding : str\n    Encoding for text data.\nchunksize : int\n    Read file `chunksize` lines at a time, returns iterator.'
+_format_params_doc = 'format : str\n    File format, only `xport` is currently supported.'
+_iterator_doc = 'iterator : bool, default False\n    Return XportReader object for reading file incrementally.'
+_read_sas_doc = f"Read a SAS file into a DataFrame.\n\n{_base_params_doc}\n{_format_params_doc}\n{_params2_doc}\n{_iterator_doc}\n\nReturns\n-------\nDataFrame or XportReader\n\nExamples\n--------\nRead a SAS Xport file:\n\n>>> df = pd.read_sas('filename.XPT')\n\nRead a Xport file in 10,000 line chunks:\n\n>>> itr = pd.read_sas('filename.XPT', chunksize=10000)\n>>> for chunk in itr:\n>>>     do_something(chunk)\n\n"
+_xport_reader_doc = f'Class for reading SAS Xport files.\n\n{_base_params_doc}\n{_params2_doc}\n\nAttributes\n----------\nmember_info : list\n    Contains information about the file\nfields : list\n    Contains information about the variables in the file\n'
+_read_method_doc = 'Read observations from SAS Xport file, returning as data frame.\n\nParameters\n----------\nnrows : int\n    Number of rows to read from data file; if None, read whole\n    file.\n\nReturns\n-------\nA DataFrame.\n'
+
+def _parse_date(datestr: str) -> DatetimeNaTType:
+    try:
+        return datetime.strptime(datestr, '%d%b%y:%H:%M:%S')
+    except ValueError:
+        return pd.NaT
+
+def _split_line(s: str, parts):
+    out = {}
+    start = 0
+    for (name, length) in parts:
+        out[name] = s[start:start + length].strip()
+        start += length
+    del out['_']
+    return out
+
+def _handle_truncated_float_vec(vec, nbytes):
+    if nbytes != 8:
+        vec1 = np.zeros(len(vec), np.dtype('S8'))
+        dtype = np.dtype(f'S{nbytes},S{8 - nbytes}')
+        vec2 = vec1.view(dtype=dtype)
+        vec2['f0'] = vec
+        return vec2
+    return vec
+
+def _parse_float_vec(vec):
+    dtype = np.dtype('>u4,>u4')
+    vec1 = vec.view(dtype=dtype)
+    xport1 = vec1['f0']
+    xport2 = vec1['f1']
+    ieee1 = xport1 & 16777215
+    shift = np.zeros(len(vec), dtype=np.uint8)
+    shift[np.where(xport1 & 2097152)] = 1
+    shift[np.where(xport1 & 4194304)] = 2
+    shift[np.where(xport1 & 8388608)] = 3
+    ieee1 >>= shift
+    ieee2 = xport2 >> shift | (xport1 & 7) << 29 + (3 - shift)
+    ieee1 &= 4293918719
+    ieee1 |= ((xport1 >> 24 & 127) - 65 << 2) + shift + 1023 << 20 | xport1 & 2147483648
+    ieee = np.empty((len(ieee1),), dtype='>u4,>u4')
+    ieee['f0'] = ieee1
+    ieee['f1'] = ieee2
+    ieee = ieee.view(dtype='>f8')
+    ieee = ieee.astype('f8')
+    return ieee
+
+class XportReader(SASReader):
+    __doc__ = _xport_reader_doc
+
+    def __init__(self, filepath_or_buffer: FilePath | ReadBuffer[bytes], index=None, encoding: str | None='ISO-8859-1', chunksize: int | None=None, compression: CompressionOptions='infer') -> None:
+        self._encoding = encoding
+        self._lines_read = 0
+        self._index = index
+        self._chunksize = chunksize
+        self.handles = get_handle(filepath_or_buffer, 'rb', encoding=encoding, is_text=False, compression=compression)
+        self.filepath_or_buffer = self.handles.handle
+        try:
+            self._read_header()
+        except Exception:
+            self.close()
+            raise
+
+    def close(self) -> None:
+        self.handles.close()
+
+    def _get_row(self):
+        return self.filepath_or_buffer.read(80).decode()
+
+    def _read_header(self) -> None:
+        self.filepath_or_buffer.seek(0)
+        line1 = self._get_row()
+        if line1 != _correct_line1:
+            if '**COMPRESSED**' in line1:
+                raise ValueError('Header record indicates a CPORT file, which is not readable.')
+            raise ValueError('Header record is not an XPORT file.')
+        line2 = self._get_row()
+        fif = [['prefix', 24], ['version', 8], ['OS', 8], ['_', 24], ['created', 16]]
+        file_info = _split_line(line2, fif)
+        if file_info['prefix'] != 'SAS     SAS     SASLIB':
+            raise ValueError('Header record has invalid prefix.')
+        file_info['created'] = _parse_date(file_info['created'])
+        self.file_info = file_info
+        line3 = self._get_row()
+        file_info['modified'] = _parse_date(line3[:16])
+        header1 = self._get_row()
+        header2 = self._get_row()
+        headflag1 = header1.startswith(_correct_header1)
+        headflag2 = header2 == _correct_header2
+        if not (headflag1 and headflag2):
+            raise ValueError('Member header not found')
+        fieldnamelength = int(header1[-5:-2])
+        mem = [['prefix', 8], ['set_name', 8], ['sasdata', 8], ['version', 8], ['OS', 8], ['_', 24], ['created', 16]]
+        member_info = _split_line(self._get_row(), mem)
+        mem = [['modified', 16], ['_', 16], ['label', 40], ['type', 8]]
+        member_info.update(_split_line(self._get_row(), mem))
+        member_info['modified'] = _parse_date(member_info['modified'])
+        member_info['created'] = _parse_date(member_info['created'])
+        self.member_info = member_info
+        types = {1: 'numeric', 2: 'char'}
+        fieldcount = int(self._get_row()[54:58])
+        datalength = fieldnamelength * fieldcount
+        if datalength % 80:
+            datalength += 80 - datalength % 80
+        fielddata = self.filepath_or_buffer.read(datalength)
+        fields = []
+        obs_length = 0
+        while len(fielddata) >= fieldnamelength:
+            (fieldbytes, fielddata) = (fielddata[:fieldnamelength], fielddata[fieldnamelength:])
+            fieldbytes = fieldbytes.ljust(140)
+            fieldstruct = struct.unpack('>hhhh8s40s8shhh2s8shhl52s', fieldbytes)
+            field = dict(zip(_fieldkeys, fieldstruct))
+            del field['_']
+            field['ntype'] = types[field['ntype']]
+            fl = field['field_length']
+            if field['ntype'] == 'numeric' and (fl < 2 or fl > 8):
+                msg = f'Floating field width {fl} is not between 2 and 8.'
+                raise TypeError(msg)
+            for (k, v) in field.items():
+                try:
+                    field[k] = v.strip()
+                except AttributeError:
+                    pass
+            obs_length += field['field_length']
+            fields += [field]
+        header = self._get_row()
+        if not header == _correct_obs_header:
+            raise ValueError('Observation header not found.')
+        self.fields = fields
+        self.record_length = obs_length
+        self.record_start = self.filepath_or_buffer.tell()
+        self.nobs = self._record_count()
+        self.columns = [x['name'].decode() for x in self.fields]
+        dtypel = [('s' + str(i), 'S' + str(field['field_length'])) for (i, field) in enumerate(self.fields)]
+        dtype = np.dtype(dtypel)
+        self._dtype = dtype
+
+    def __next__(self) -> pd.DataFrame:
+        return self.read(nrows=self._chunksize or 1)
+
+    def _record_count(self) -> int:
+        self.filepath_or_buffer.seek(0, 2)
+        total_records_length = self.filepath_or_buffer.tell() - self.record_start
+        if total_records_length % 80 != 0:
+            warnings.warn('xport file may be corrupted.', stacklevel=find_stack_level())
+        if self.record_length > 80:
+            self.filepath_or_buffer.seek(self.record_start)
+            return total_records_length // self.record_length
+        self.filepath_or_buffer.seek(-80, 2)
+        last_card_bytes = self.filepath_or_buffer.read(80)
+        last_card = np.frombuffer(last_card_bytes, dtype=np.uint64)
+        ix = np.flatnonzero(last_card == 2314885530818453536)
+        if len(ix) == 0:
+            tail_pad = 0
+        else:
+            tail_pad = 8 * len(ix)
+        self.filepath_or_buffer.seek(self.record_start)
+        return (total_records_length - tail_pad) // self.record_length
+
+    def get_chunk(self, size: int | None=None) -> pd.DataFrame:
+        if size is None:
+            size = self._chunksize
+        return self.read(nrows=size)
+
+    def _missing_double(self, vec):
+        v = vec.view(dtype='u1,u1,u2,u4')
+        miss = (v['f1'] == 0) & (v['f2'] == 0) & (v['f3'] == 0)
+        miss1 = (v['f0'] >= 65) & (v['f0'] <= 90) | (v['f0'] == 95) | (v['f0'] == 46)
+        miss &= miss1
+        return miss
+
+    @Appender(_read_method_doc)
+    def read(self, nrows: int | None=None) -> pd.DataFrame:
+        if nrows is None:
+            nrows = self.nobs
+        read_lines = min(nrows, self.nobs - self._lines_read)
+        read_len = read_lines * self.record_length
+        if read_len <= 0:
+            self.close()
+            raise StopIteration
+        raw = self.filepath_or_buffer.read(read_len)
+        data = np.frombuffer(raw, dtype=self._dtype, count=read_lines)
+        df_data = {}
+        for (j, x) in enumerate(self.columns):
+            vec = data['s' + str(j)]
+            ntype = self.fields[j]['ntype']
+            if ntype == 'numeric':
+                vec = _handle_truncated_float_vec(vec, self.fields[j]['field_length'])
+                miss = self._missing_double(vec)
+                v = _parse_float_vec(vec)
+                v[miss] = np.nan
+            elif self.fields[j]['ntype'] == 'char':
+                v = [y.rstrip() for y in vec]
+                if self._encoding is not None:
+                    v = [y.decode(self._encoding) for y in v]
+            df_data.update({x: v})
+        df = pd.DataFrame(df_data)
+        if self._index is None:
+            df.index = pd.Index(range(self._lines_read, self._lines_read + read_lines))
+        else:
+            df = df.set_index(self._index)
+        self._lines_read += read_lines
+        return df
+
+# File: pandas-main/pandas/io/sas/sasreader.py
+""""""
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, overload
+from pandas.util._decorators import doc
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.common import stringify_path
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+    from types import TracebackType
+    from pandas._typing import CompressionOptions, FilePath, ReadBuffer, Self
+    from pandas import DataFrame
+
+class SASReader(Iterator['DataFrame'], ABC):
+
+    @abstractmethod
+    def read(self, nrows: int | None=None) -> DataFrame:
+        ...
+
+    @abstractmethod
+    def close(self) -> None:
+        ...
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
+        self.close()
+
+@overload
+def read_sas(filepath_or_buffer: FilePath | ReadBuffer[bytes], *, format: str | None=..., index: Hashable | None=..., encoding: str | None=..., chunksize: int=..., iterator: bool=..., compression: CompressionOptions=...) -> SASReader:
+    ...
+
+@overload
+def read_sas(filepath_or_buffer: FilePath | ReadBuffer[bytes], *, format: str | None=..., index: Hashable | None=..., encoding: str | None=..., chunksize: None=..., iterator: bool=..., compression: CompressionOptions=...) -> DataFrame | SASReader:
+    ...
+
+@doc(decompression_options=_shared_docs['decompression_options'] % 'filepath_or_buffer')
+def read_sas(filepath_or_buffer: FilePath | ReadBuffer[bytes], *, format: str | None=None, index: Hashable | None=None, encoding: str | None=None, chunksize: int | None=None, iterator: bool=False, compression: CompressionOptions='infer') -> DataFrame | SASReader:
+    if format is None:
+        buffer_error_msg = 'If this is a buffer object rather than a string name, you must specify a format string'
+        filepath_or_buffer = stringify_path(filepath_or_buffer)
+        if not isinstance(filepath_or_buffer, str):
+            raise ValueError(buffer_error_msg)
+        fname = filepath_or_buffer.lower()
+        if '.xpt' in fname:
+            format = 'xport'
+        elif '.sas7bdat' in fname:
+            format = 'sas7bdat'
+        else:
+            raise ValueError(f'unable to infer format of SAS file from filename: {fname!r}')
+    reader: SASReader
+    if format.lower() == 'xport':
+        from pandas.io.sas.sas_xport import XportReader
+        reader = XportReader(filepath_or_buffer, index=index, encoding=encoding, chunksize=chunksize, compression=compression)
+    elif format.lower() == 'sas7bdat':
+        from pandas.io.sas.sas7bdat import SAS7BDATReader
+        reader = SAS7BDATReader(filepath_or_buffer, index=index, encoding=encoding, chunksize=chunksize, compression=compression)
+    else:
+        raise ValueError('unknown SAS format')
+    if iterator or chunksize:
+        return reader
+    with reader:
+        return reader.read()
+
+# File: pandas-main/pandas/io/spss.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from pandas._libs import lib
+from pandas.compat._optional import import_optional_dependency
+from pandas.util._validators import check_dtype_backend
+from pandas.core.dtypes.inference import is_list_like
+from pandas.io.common import stringify_path
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pathlib import Path
+    from pandas._typing import DtypeBackend
+    from pandas import DataFrame
+
+def read_spss(path: str | Path, usecols: Sequence[str] | None=None, convert_categoricals: bool=True, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, **kwargs: Any) -> DataFrame:
+    pyreadstat = import_optional_dependency('pyreadstat')
+    check_dtype_backend(dtype_backend)
+    if usecols is not None:
+        if not is_list_like(usecols):
+            raise TypeError('usecols must be list-like.')
+        usecols = list(usecols)
+    (df, metadata) = pyreadstat.read_sav(stringify_path(path), usecols=usecols, apply_value_formats=convert_categoricals, **kwargs)
+    df.attrs = metadata.__dict__
+    if dtype_backend is not lib.no_default:
+        df = df.convert_dtypes(dtype_backend=dtype_backend)
+    return df
+
+# File: pandas-main/pandas/io/sql.py
+""""""
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from contextlib import ExitStack, contextmanager
+from datetime import date, datetime, time
+from functools import partial
+import re
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
+import warnings
+import numpy as np
+from pandas._config import using_string_dtype
+from pandas._libs import lib
+from pandas.compat._optional import import_optional_dependency
+from pandas.errors import AbstractMethodError, DatabaseError
+from pandas.util._exceptions import find_stack_level
+from pandas.util._validators import check_dtype_backend
+from pandas.core.dtypes.common import is_dict_like, is_list_like
+from pandas.core.dtypes.dtypes import ArrowDtype, DatetimeTZDtype
+from pandas.core.dtypes.missing import isna
+from pandas import get_option
+from pandas.core.api import DataFrame, Series
+from pandas.core.arrays import ArrowExtensionArray
+from pandas.core.base import PandasObject
+import pandas.core.common as com
+from pandas.core.common import maybe_make_list
+from pandas.core.internals.construction import convert_object_array
+from pandas.core.tools.datetimes import to_datetime
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator, Iterator, Mapping
+    from sqlalchemy import Table
+    from sqlalchemy.sql.expression import Select, TextClause
+    from pandas._typing import DtypeArg, DtypeBackend, IndexLabel, Self
+    from pandas import Index
+
+def _process_parse_dates_argument(parse_dates):
+    if parse_dates is True or parse_dates is None or parse_dates is False:
+        parse_dates = []
+    elif not hasattr(parse_dates, '__iter__'):
+        parse_dates = [parse_dates]
+    return parse_dates
+
+def _handle_date_column(col, utc: bool=False, format: str | dict[str, Any] | None=None):
+    if isinstance(format, dict):
+        return to_datetime(col, **format)
+    else:
+        if format is None and (issubclass(col.dtype.type, np.floating) or issubclass(col.dtype.type, np.integer)):
+            format = 's'
+        if format in ['D', 'd', 'h', 'm', 's', 'ms', 'us', 'ns']:
+            return to_datetime(col, errors='coerce', unit=format, utc=utc)
+        elif isinstance(col.dtype, DatetimeTZDtype):
+            return to_datetime(col, utc=True)
+        else:
+            return to_datetime(col, errors='coerce', format=format, utc=utc)
+
+def _parse_date_columns(data_frame: DataFrame, parse_dates) -> DataFrame:
+    parse_dates = _process_parse_dates_argument(parse_dates)
+    for (i, (col_name, df_col)) in enumerate(data_frame.items()):
+        if isinstance(df_col.dtype, DatetimeTZDtype) or col_name in parse_dates:
+            try:
+                fmt = parse_dates[col_name]
+            except (KeyError, TypeError):
+                fmt = None
+            data_frame.isetitem(i, _handle_date_column(df_col, format=fmt))
+    return data_frame
+
+def _convert_arrays_to_dataframe(data, columns, coerce_float: bool=True, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> DataFrame:
+    content = lib.to_object_array_tuples(data)
+    idx_len = content.shape[0]
+    arrays = convert_object_array(list(content.T), dtype=None, coerce_float=coerce_float, dtype_backend=dtype_backend)
+    if dtype_backend == 'pyarrow':
+        pa = import_optional_dependency('pyarrow')
+        result_arrays = []
+        for arr in arrays:
+            pa_array = pa.array(arr, from_pandas=True)
+            if arr.dtype == 'string':
+                pa_array = pa_array.cast(pa.string())
+            result_arrays.append(ArrowExtensionArray(pa_array))
+        arrays = result_arrays
+    if arrays:
+        return DataFrame._from_arrays(arrays, columns=columns, index=range(idx_len), verify_integrity=False)
+    else:
+        return DataFrame(columns=columns)
+
+def _wrap_result(data, columns, index_col=None, coerce_float: bool=True, parse_dates=None, dtype: DtypeArg | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> DataFrame:
+    frame = _convert_arrays_to_dataframe(data, columns, coerce_float, dtype_backend)
+    if dtype:
+        frame = frame.astype(dtype)
+    frame = _parse_date_columns(frame, parse_dates)
+    if index_col is not None:
+        frame = frame.set_index(index_col)
+    return frame
+
+def _wrap_result_adbc(df: DataFrame, *, index_col=None, parse_dates=None, dtype: DtypeArg | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> DataFrame:
+    if dtype:
+        df = df.astype(dtype)
+    df = _parse_date_columns(df, parse_dates)
+    if index_col is not None:
+        df = df.set_index(index_col)
+    return df
+
+@overload
+def read_sql_table(table_name: str, con, schema=..., index_col: str | list[str] | None=..., coerce_float=..., parse_dates: list[str] | dict[str, str] | None=..., columns: list[str] | None=..., chunksize: None=..., dtype_backend: DtypeBackend | lib.NoDefault=...) -> DataFrame:
+    ...
+
+@overload
+def read_sql_table(table_name: str, con, schema=..., index_col: str | list[str] | None=..., coerce_float=..., parse_dates: list[str] | dict[str, str] | None=..., columns: list[str] | None=..., chunksize: int=..., dtype_backend: DtypeBackend | lib.NoDefault=...) -> Iterator[DataFrame]:
+    ...
+
+def read_sql_table(table_name: str, con, schema: str | None=None, index_col: str | list[str] | None=None, coerce_float: bool=True, parse_dates: list[str] | dict[str, str] | None=None, columns: list[str] | None=None, chunksize: int | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default) -> DataFrame | Iterator[DataFrame]:
+    check_dtype_backend(dtype_backend)
+    if dtype_backend is lib.no_default:
+        dtype_backend = 'numpy'
+    assert dtype_backend is not lib.no_default
+    with pandasSQL_builder(con, schema=schema, need_transaction=True) as pandas_sql:
+        if not pandas_sql.has_table(table_name):
+            raise ValueError(f'Table {table_name} not found')
+        table = pandas_sql.read_table(table_name, index_col=index_col, coerce_float=coerce_float, parse_dates=parse_dates, columns=columns, chunksize=chunksize, dtype_backend=dtype_backend)
+    if table is not None:
+        return table
+    else:
+        raise ValueError(f'Table {table_name} not found', con)
+
+@overload
+def read_sql_query(sql, con, index_col: str | list[str] | None=..., coerce_float=..., params: list[Any] | Mapping[str, Any] | None=..., parse_dates: list[str] | dict[str, str] | None=..., chunksize: None=..., dtype: DtypeArg | None=..., dtype_backend: DtypeBackend | lib.NoDefault=...) -> DataFrame:
+    ...
+
+@overload
+def read_sql_query(sql, con, index_col: str | list[str] | None=..., coerce_float=..., params: list[Any] | Mapping[str, Any] | None=..., parse_dates: list[str] | dict[str, str] | None=..., chunksize: int=..., dtype: DtypeArg | None=..., dtype_backend: DtypeBackend | lib.NoDefault=...) -> Iterator[DataFrame]:
+    ...
+
+def read_sql_query(sql, con, index_col: str | list[str] | None=None, coerce_float: bool=True, params: list[Any] | Mapping[str, Any] | None=None, parse_dates: list[str] | dict[str, str] | None=None, chunksize: int | None=None, dtype: DtypeArg | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default) -> DataFrame | Iterator[DataFrame]:
+    check_dtype_backend(dtype_backend)
+    if dtype_backend is lib.no_default:
+        dtype_backend = 'numpy'
+    assert dtype_backend is not lib.no_default
+    with pandasSQL_builder(con) as pandas_sql:
+        return pandas_sql.read_query(sql, index_col=index_col, params=params, coerce_float=coerce_float, parse_dates=parse_dates, chunksize=chunksize, dtype=dtype, dtype_backend=dtype_backend)
+
+@overload
+def read_sql(sql, con, index_col: str | list[str] | None=..., coerce_float=..., params=..., parse_dates=..., columns: list[str]=..., chunksize: None=..., dtype_backend: DtypeBackend | lib.NoDefault=..., dtype: DtypeArg | None=None) -> DataFrame:
+    ...
+
+@overload
+def read_sql(sql, con, index_col: str | list[str] | None=..., coerce_float=..., params=..., parse_dates=..., columns: list[str]=..., chunksize: int=..., dtype_backend: DtypeBackend | lib.NoDefault=..., dtype: DtypeArg | None=None) -> Iterator[DataFrame]:
+    ...
+
+def read_sql(sql, con, index_col: str | list[str] | None=None, coerce_float: bool=True, params=None, parse_dates=None, columns: list[str] | None=None, chunksize: int | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, dtype: DtypeArg | None=None) -> DataFrame | Iterator[DataFrame]:
+    check_dtype_backend(dtype_backend)
+    if dtype_backend is lib.no_default:
+        dtype_backend = 'numpy'
+    assert dtype_backend is not lib.no_default
+    with pandasSQL_builder(con) as pandas_sql:
+        if isinstance(pandas_sql, SQLiteDatabase):
+            return pandas_sql.read_query(sql, index_col=index_col, params=params, coerce_float=coerce_float, parse_dates=parse_dates, chunksize=chunksize, dtype_backend=dtype_backend, dtype=dtype)
+        try:
+            _is_table_name = pandas_sql.has_table(sql)
+        except Exception:
+            _is_table_name = False
+        if _is_table_name:
+            return pandas_sql.read_table(sql, index_col=index_col, coerce_float=coerce_float, parse_dates=parse_dates, columns=columns, chunksize=chunksize, dtype_backend=dtype_backend)
+        else:
+            return pandas_sql.read_query(sql, index_col=index_col, params=params, coerce_float=coerce_float, parse_dates=parse_dates, chunksize=chunksize, dtype_backend=dtype_backend, dtype=dtype)
+
+def to_sql(frame, name: str, con, schema: str | None=None, if_exists: Literal['fail', 'replace', 'append']='fail', index: bool=True, index_label: IndexLabel | None=None, chunksize: int | None=None, dtype: DtypeArg | None=None, method: Literal['multi'] | Callable | None=None, engine: str='auto', **engine_kwargs) -> int | None:
+    if if_exists not in ('fail', 'replace', 'append'):
+        raise ValueError(f"'{if_exists}' is not valid for if_exists")
+    if isinstance(frame, Series):
+        frame = frame.to_frame()
+    elif not isinstance(frame, DataFrame):
+        raise NotImplementedError("'frame' argument should be either a Series or a DataFrame")
+    with pandasSQL_builder(con, schema=schema, need_transaction=True) as pandas_sql:
+        return pandas_sql.to_sql(frame, name, if_exists=if_exists, index=index, index_label=index_label, schema=schema, chunksize=chunksize, dtype=dtype, method=method, engine=engine, **engine_kwargs)
+
+def has_table(table_name: str, con, schema: str | None=None) -> bool:
+    with pandasSQL_builder(con, schema=schema) as pandas_sql:
+        return pandas_sql.has_table(table_name)
+table_exists = has_table
+
+def pandasSQL_builder(con, schema: str | None=None, need_transaction: bool=False) -> PandasSQL:
+    import sqlite3
+    if isinstance(con, sqlite3.Connection) or con is None:
+        return SQLiteDatabase(con)
+    sqlalchemy = import_optional_dependency('sqlalchemy', errors='ignore')
+    if isinstance(con, str) and sqlalchemy is None:
+        raise ImportError('Using URI string without sqlalchemy installed.')
+    if sqlalchemy is not None and isinstance(con, (str, sqlalchemy.engine.Connectable)):
+        return SQLDatabase(con, schema, need_transaction)
+    adbc = import_optional_dependency('adbc_driver_manager.dbapi', errors='ignore')
+    if adbc and isinstance(con, adbc.Connection):
+        return ADBCDatabase(con)
+    warnings.warn('pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.', UserWarning, stacklevel=find_stack_level())
+    return SQLiteDatabase(con)
+
+class SQLTable(PandasObject):
+
+    def __init__(self, name: str, pandas_sql_engine, frame=None, index: bool | str | list[str] | None=True, if_exists: Literal['fail', 'replace', 'append']='fail', prefix: str='pandas', index_label=None, schema=None, keys=None, dtype: DtypeArg | None=None) -> None:
+        self.name = name
+        self.pd_sql = pandas_sql_engine
+        self.prefix = prefix
+        self.frame = frame
+        self.index = self._index_name(index, index_label)
+        self.schema = schema
+        self.if_exists = if_exists
+        self.keys = keys
+        self.dtype = dtype
+        if frame is not None:
+            self.table = self._create_table_setup()
+        else:
+            self.table = self.pd_sql.get_table(self.name, self.schema)
+        if self.table is None:
+            raise ValueError(f"Could not init table '{name}'")
+        if not len(self.name):
+            raise ValueError('Empty table name specified')
+
+    def exists(self):
+        return self.pd_sql.has_table(self.name, self.schema)
+
+    def sql_schema(self) -> str:
+        from sqlalchemy.schema import CreateTable
+        return str(CreateTable(self.table).compile(self.pd_sql.con))
+
+    def _execute_create(self) -> None:
+        self.table = self.table.to_metadata(self.pd_sql.meta)
+        with self.pd_sql.run_transaction():
+            self.table.create(bind=self.pd_sql.con)
+
+    def create(self) -> None:
+        if self.exists():
+            if self.if_exists == 'fail':
+                raise ValueError(f"Table '{self.name}' already exists.")
+            if self.if_exists == 'replace':
+                self.pd_sql.drop_table(self.name, self.schema)
+                self._execute_create()
+            elif self.if_exists == 'append':
+                pass
+            else:
+                raise ValueError(f"'{self.if_exists}' is not valid for if_exists")
+        else:
+            self._execute_create()
+
+    def _execute_insert(self, conn, keys: list[str], data_iter) -> int:
+        data = [dict(zip(keys, row)) for row in data_iter]
+        result = conn.execute(self.table.insert(), data)
+        return result.rowcount
+
+    def _execute_insert_multi(self, conn, keys: list[str], data_iter) -> int:
+        from sqlalchemy import insert
+        data = [dict(zip(keys, row)) for row in data_iter]
+        stmt = insert(self.table).values(data)
+        result = conn.execute(stmt)
+        return result.rowcount
+
+    def insert_data(self) -> tuple[list[str], list[np.ndarray]]:
+        if self.index is not None:
+            temp = self.frame.copy(deep=False)
+            temp.index.names = self.index
+            try:
+                temp.reset_index(inplace=True)
+            except ValueError as err:
+                raise ValueError(f'duplicate name in index/columns: {err}') from err
+        else:
+            temp = self.frame
+        column_names = list(map(str, temp.columns))
+        ncols = len(column_names)
+        data_list: list[np.ndarray] = [None] * ncols
+        for (i, (_, ser)) in enumerate(temp.items()):
+            if ser.dtype.kind == 'M':
+                if isinstance(ser._values, ArrowExtensionArray):
+                    import pyarrow as pa
+                    if pa.types.is_date(ser.dtype.pyarrow_dtype):
+                        d = ser._values.to_numpy(dtype=object)
+                    else:
+                        d = ser.dt.to_pydatetime()._values
+                else:
+                    d = ser._values.to_pydatetime()
+            elif ser.dtype.kind == 'm':
+                vals = ser._values
+                if isinstance(vals, ArrowExtensionArray):
+                    vals = vals.to_numpy(dtype=np.dtype('m8[ns]'))
+                d = vals.view('i8').astype(object)
+            else:
+                d = ser._values.astype(object)
+            assert isinstance(d, np.ndarray), type(d)
+            if ser._can_hold_na:
+                mask = isna(d)
+                d[mask] = None
+            data_list[i] = d
+        return (column_names, data_list)
+
+    def insert(self, chunksize: int | None=None, method: Literal['multi'] | Callable | None=None) -> int | None:
+        if method is None:
+            exec_insert = self._execute_insert
+        elif method == 'multi':
+            exec_insert = self._execute_insert_multi
+        elif callable(method):
+            exec_insert = partial(method, self)
+        else:
+            raise ValueError(f'Invalid parameter `method`: {method}')
+        (keys, data_list) = self.insert_data()
+        nrows = len(self.frame)
+        if nrows == 0:
+            return 0
+        if chunksize is None:
+            chunksize = nrows
+        elif chunksize == 0:
+            raise ValueError('chunksize argument should be non-zero')
+        chunks = nrows // chunksize + 1
+        total_inserted = None
+        with self.pd_sql.run_transaction() as conn:
+            for i in range(chunks):
+                start_i = i * chunksize
+                end_i = min((i + 1) * chunksize, nrows)
+                if start_i >= end_i:
+                    break
+                chunk_iter = zip(*(arr[start_i:end_i] for arr in data_list))
+                num_inserted = exec_insert(conn, keys, chunk_iter)
+                if num_inserted is not None:
+                    if total_inserted is None:
+                        total_inserted = num_inserted
+                    else:
+                        total_inserted += num_inserted
+        return total_inserted
+
+    def _query_iterator(self, result, exit_stack: ExitStack, chunksize: int | None, columns, coerce_float: bool=True, parse_dates=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> Generator[DataFrame, None, None]:
+        has_read_data = False
+        with exit_stack:
+            while True:
+                data = result.fetchmany(chunksize)
+                if not data:
+                    if not has_read_data:
+                        yield DataFrame.from_records([], columns=columns, coerce_float=coerce_float)
+                    break
+                has_read_data = True
+                self.frame = _convert_arrays_to_dataframe(data, columns, coerce_float, dtype_backend)
+                self._harmonize_columns(parse_dates=parse_dates, dtype_backend=dtype_backend)
+                if self.index is not None:
+                    self.frame.set_index(self.index, inplace=True)
+                yield self.frame
+
+    def read(self, exit_stack: ExitStack, coerce_float: bool=True, parse_dates=None, columns=None, chunksize: int | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> DataFrame | Iterator[DataFrame]:
+        from sqlalchemy import select
+        if columns is not None and len(columns) > 0:
+            cols = [self.table.c[n] for n in columns]
+            if self.index is not None:
+                for idx in self.index[::-1]:
+                    cols.insert(0, self.table.c[idx])
+            sql_select = select(*cols)
+        else:
+            sql_select = select(self.table)
+        result = self.pd_sql.execute(sql_select)
+        column_names = result.keys()
+        if chunksize is not None:
+            return self._query_iterator(result, exit_stack, chunksize, column_names, coerce_float=coerce_float, parse_dates=parse_dates, dtype_backend=dtype_backend)
+        else:
+            data = result.fetchall()
+            self.frame = _convert_arrays_to_dataframe(data, column_names, coerce_float, dtype_backend)
+            self._harmonize_columns(parse_dates=parse_dates, dtype_backend=dtype_backend)
+            if self.index is not None:
+                self.frame.set_index(self.index, inplace=True)
+            return self.frame
+
+    def _index_name(self, index, index_label):
+        if index is True:
+            nlevels = self.frame.index.nlevels
+            if index_label is not None:
+                if not isinstance(index_label, list):
+                    index_label = [index_label]
+                if len(index_label) != nlevels:
+                    raise ValueError(f"Length of 'index_label' should match number of levels, which is {nlevels}")
+                return index_label
+            if nlevels == 1 and 'index' not in self.frame.columns and (self.frame.index.name is None):
+                return ['index']
+            else:
+                return com.fill_missing_names(self.frame.index.names)
+        elif isinstance(index, str):
+            return [index]
+        elif isinstance(index, list):
+            return index
+        else:
+            return None
+
+    def _get_column_names_and_types(self, dtype_mapper):
+        column_names_and_types = []
+        if self.index is not None:
+            for (i, idx_label) in enumerate(self.index):
+                idx_type = dtype_mapper(self.frame.index._get_level_values(i))
+                column_names_and_types.append((str(idx_label), idx_type, True))
+        column_names_and_types += [(str(self.frame.columns[i]), dtype_mapper(self.frame.iloc[:, i]), False) for i in range(len(self.frame.columns))]
+        return column_names_and_types
+
+    def _create_table_setup(self):
+        from sqlalchemy import Column, PrimaryKeyConstraint, Table
+        from sqlalchemy.schema import MetaData
+        column_names_and_types = self._get_column_names_and_types(self._sqlalchemy_type)
+        columns: list[Any] = [Column(name, typ, index=is_index) for (name, typ, is_index) in column_names_and_types]
+        if self.keys is not None:
+            if not is_list_like(self.keys):
+                keys = [self.keys]
+            else:
+                keys = self.keys
+            pkc = PrimaryKeyConstraint(*keys, name=self.name + '_pk')
+            columns.append(pkc)
+        schema = self.schema or self.pd_sql.meta.schema
+        meta = MetaData()
+        return Table(self.name, meta, *columns, schema=schema)
+
+    def _harmonize_columns(self, parse_dates=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> None:
+        parse_dates = _process_parse_dates_argument(parse_dates)
+        for sql_col in self.table.columns:
+            col_name = sql_col.name
+            try:
+                df_col = self.frame[col_name]
+                if col_name in parse_dates:
+                    try:
+                        fmt = parse_dates[col_name]
+                    except TypeError:
+                        fmt = None
+                    self.frame[col_name] = _handle_date_column(df_col, format=fmt)
+                    continue
+                col_type = self._get_dtype(sql_col.type)
+                if col_type is datetime or col_type is date or col_type is DatetimeTZDtype:
+                    utc = col_type is DatetimeTZDtype
+                    self.frame[col_name] = _handle_date_column(df_col, utc=utc)
+                elif dtype_backend == 'numpy' and col_type is float:
+                    self.frame[col_name] = df_col.astype(col_type)
+                elif dtype_backend == 'numpy' and len(df_col) == df_col.count():
+                    if col_type is np.dtype('int64') or col_type is bool:
+                        self.frame[col_name] = df_col.astype(col_type)
+            except KeyError:
+                pass
+
+    def _sqlalchemy_type(self, col: Index | Series):
+        dtype: DtypeArg = self.dtype or {}
+        if is_dict_like(dtype):
+            dtype = cast(dict, dtype)
+            if col.name in dtype:
+                return dtype[col.name]
+        col_type = lib.infer_dtype(col, skipna=True)
+        from sqlalchemy.types import TIMESTAMP, BigInteger, Boolean, Date, DateTime, Float, Integer, SmallInteger, Text, Time
+        if col_type in ('datetime64', 'datetime'):
+            try:
+                if col.dt.tz is not None:
+                    return TIMESTAMP(timezone=True)
+            except AttributeError:
+                if getattr(col, 'tz', None) is not None:
+                    return TIMESTAMP(timezone=True)
+            return DateTime
+        if col_type == 'timedelta64':
+            warnings.warn("the 'timedelta' type is not supported, and will be written as integer values (ns frequency) to the database.", UserWarning, stacklevel=find_stack_level())
+            return BigInteger
+        elif col_type == 'floating':
+            if col.dtype == 'float32':
+                return Float(precision=23)
+            else:
+                return Float(precision=53)
+        elif col_type == 'integer':
+            if col.dtype.name.lower() in ('int8', 'uint8', 'int16'):
+                return SmallInteger
+            elif col.dtype.name.lower() in ('uint16', 'int32'):
+                return Integer
+            elif col.dtype.name.lower() == 'uint64':
+                raise ValueError('Unsigned 64 bit integer datatype is not supported')
+            else:
+                return BigInteger
+        elif col_type == 'boolean':
+            return Boolean
+        elif col_type == 'date':
+            return Date
+        elif col_type == 'time':
+            return Time
+        elif col_type == 'complex':
+            raise ValueError('Complex datatypes not supported')
+        return Text
+
+    def _get_dtype(self, sqltype):
+        from sqlalchemy.types import TIMESTAMP, Boolean, Date, DateTime, Float, Integer
+        if isinstance(sqltype, Float):
+            return float
+        elif isinstance(sqltype, Integer):
+            return np.dtype('int64')
+        elif isinstance(sqltype, TIMESTAMP):
+            if not sqltype.timezone:
+                return datetime
+            return DatetimeTZDtype
+        elif isinstance(sqltype, DateTime):
+            return datetime
+        elif isinstance(sqltype, Date):
+            return date
+        elif isinstance(sqltype, Boolean):
+            return bool
+        return object
+
+class PandasSQL(PandasObject, ABC):
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *args) -> None:
+        pass
+
+    def read_table(self, table_name: str, index_col: str | list[str] | None=None, coerce_float: bool=True, parse_dates=None, columns=None, schema: str | None=None, chunksize: int | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> DataFrame | Iterator[DataFrame]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def read_query(self, sql: str, index_col: str | list[str] | None=None, coerce_float: bool=True, parse_dates=None, params=None, chunksize: int | None=None, dtype: DtypeArg | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> DataFrame | Iterator[DataFrame]:
+        pass
+
+    @abstractmethod
+    def to_sql(self, frame, name: str, if_exists: Literal['fail', 'replace', 'append']='fail', index: bool=True, index_label=None, schema=None, chunksize: int | None=None, dtype: DtypeArg | None=None, method: Literal['multi'] | Callable | None=None, engine: str='auto', **engine_kwargs) -> int | None:
+        pass
+
+    @abstractmethod
+    def execute(self, sql: str | Select | TextClause, params=None):
+        pass
+
+    @abstractmethod
+    def has_table(self, name: str, schema: str | None=None) -> bool:
+        pass
+
+    @abstractmethod
+    def _create_sql_schema(self, frame: DataFrame, table_name: str, keys: list[str] | None=None, dtype: DtypeArg | None=None, schema: str | None=None) -> str:
+        pass
+
+class BaseEngine:
+
+    def insert_records(self, table: SQLTable, con, frame, name: str, index: bool | str | list[str] | None=True, schema=None, chunksize: int | None=None, method=None, **engine_kwargs) -> int | None:
+        raise AbstractMethodError(self)
+
+class SQLAlchemyEngine(BaseEngine):
+
+    def __init__(self) -> None:
+        import_optional_dependency('sqlalchemy', extra='sqlalchemy is required for SQL support.')
+
+    def insert_records(self, table: SQLTable, con, frame, name: str, index: bool | str | list[str] | None=True, schema=None, chunksize: int | None=None, method=None, **engine_kwargs) -> int | None:
+        from sqlalchemy import exc
+        try:
+            return table.insert(chunksize=chunksize, method=method)
+        except exc.StatementError as err:
+            msg = '(\\(1054, "Unknown column \'inf(e0)?\' in \'field list\'"\\))(?#\n            )|inf can not be used with MySQL'
+            err_text = str(err.orig)
+            if re.search(msg, err_text):
+                raise ValueError('inf cannot be used with MySQL') from err
+            raise err
+
+def get_engine(engine: str) -> BaseEngine:
+    if engine == 'auto':
+        engine = get_option('io.sql.engine')
+    if engine == 'auto':
+        engine_classes = [SQLAlchemyEngine]
+        error_msgs = ''
+        for engine_class in engine_classes:
+            try:
+                return engine_class()
+            except ImportError as err:
+                error_msgs += '\n - ' + str(err)
+        raise ImportError(f"Unable to find a usable engine; tried using: 'sqlalchemy'.\nA suitable version of sqlalchemy is required for sql I/O support.\nTrying to import the above resulted in these errors:{error_msgs}")
+    if engine == 'sqlalchemy':
+        return SQLAlchemyEngine()
+    raise ValueError("engine must be one of 'auto', 'sqlalchemy'")
+
+class SQLDatabase(PandasSQL):
+
+    def __init__(self, con, schema: str | None=None, need_transaction: bool=False) -> None:
+        from sqlalchemy import create_engine
+        from sqlalchemy.engine import Engine
+        from sqlalchemy.schema import MetaData
+        self.exit_stack = ExitStack()
+        if isinstance(con, str):
+            con = create_engine(con)
+            self.exit_stack.callback(con.dispose)
+        if isinstance(con, Engine):
+            con = self.exit_stack.enter_context(con.connect())
+        if need_transaction and (not con.in_transaction()):
+            self.exit_stack.enter_context(con.begin())
+        self.con = con
+        self.meta = MetaData(schema=schema)
+        self.returns_generator = False
+
+    def __exit__(self, *args) -> None:
+        if not self.returns_generator:
+            self.exit_stack.close()
+
+    @contextmanager
+    def run_transaction(self):
+        if not self.con.in_transaction():
+            with self.con.begin():
+                yield self.con
+        else:
+            yield self.con
+
+    def execute(self, sql: str | Select | TextClause, params=None):
+        args = [] if params is None else [params]
+        if isinstance(sql, str):
+            return self.con.exec_driver_sql(sql, *args)
+        return self.con.execute(sql, *args)
+
+    def read_table(self, table_name: str, index_col: str | list[str] | None=None, coerce_float: bool=True, parse_dates=None, columns=None, schema: str | None=None, chunksize: int | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> DataFrame | Iterator[DataFrame]:
+        self.meta.reflect(bind=self.con, only=[table_name], views=True)
+        table = SQLTable(table_name, self, index=index_col, schema=schema)
+        if chunksize is not None:
+            self.returns_generator = True
+        return table.read(self.exit_stack, coerce_float=coerce_float, parse_dates=parse_dates, columns=columns, chunksize=chunksize, dtype_backend=dtype_backend)
+
+    @staticmethod
+    def _query_iterator(result, exit_stack: ExitStack, chunksize: int, columns, index_col=None, coerce_float: bool=True, parse_dates=None, dtype: DtypeArg | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> Generator[DataFrame, None, None]:
+        has_read_data = False
+        with exit_stack:
+            while True:
+                data = result.fetchmany(chunksize)
+                if not data:
+                    if not has_read_data:
+                        yield _wrap_result([], columns, index_col=index_col, coerce_float=coerce_float, parse_dates=parse_dates, dtype=dtype, dtype_backend=dtype_backend)
+                    break
+                has_read_data = True
+                yield _wrap_result(data, columns, index_col=index_col, coerce_float=coerce_float, parse_dates=parse_dates, dtype=dtype, dtype_backend=dtype_backend)
+
+    def read_query(self, sql: str, index_col: str | list[str] | None=None, coerce_float: bool=True, parse_dates=None, params=None, chunksize: int | None=None, dtype: DtypeArg | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> DataFrame | Iterator[DataFrame]:
+        result = self.execute(sql, params)
+        columns = result.keys()
+        if chunksize is not None:
+            self.returns_generator = True
+            return self._query_iterator(result, self.exit_stack, chunksize, columns, index_col=index_col, coerce_float=coerce_float, parse_dates=parse_dates, dtype=dtype, dtype_backend=dtype_backend)
+        else:
+            data = result.fetchall()
+            frame = _wrap_result(data, columns, index_col=index_col, coerce_float=coerce_float, parse_dates=parse_dates, dtype=dtype, dtype_backend=dtype_backend)
+            return frame
+    read_sql = read_query
+
+    def prep_table(self, frame, name: str, if_exists: Literal['fail', 'replace', 'append']='fail', index: bool | str | list[str] | None=True, index_label=None, schema=None, dtype: DtypeArg | None=None) -> SQLTable:
+        if dtype:
+            if not is_dict_like(dtype):
+                dtype = {col_name: dtype for col_name in frame}
+            else:
+                dtype = cast(dict, dtype)
+            from sqlalchemy.types import TypeEngine
+            for (col, my_type) in dtype.items():
+                if isinstance(my_type, type) and issubclass(my_type, TypeEngine):
+                    pass
+                elif isinstance(my_type, TypeEngine):
+                    pass
+                else:
+                    raise ValueError(f'The type of {col} is not a SQLAlchemy type')
+        table = SQLTable(name, self, frame=frame, index=index, if_exists=if_exists, index_label=index_label, schema=schema, dtype=dtype)
+        table.create()
+        return table
+
+    def check_case_sensitive(self, name: str, schema: str | None) -> None:
+        if not name.isdigit() and (not name.islower()):
+            from sqlalchemy import inspect as sqlalchemy_inspect
+            insp = sqlalchemy_inspect(self.con)
+            table_names = insp.get_table_names(schema=schema or self.meta.schema)
+            if name not in table_names:
+                msg = f"The provided table name '{name}' is not found exactly as such in the database after writing the table, possibly due to case sensitivity issues. Consider using lower case table names."
+                warnings.warn(msg, UserWarning, stacklevel=find_stack_level())
+
+    def to_sql(self, frame, name: str, if_exists: Literal['fail', 'replace', 'append']='fail', index: bool=True, index_label=None, schema: str | None=None, chunksize: int | None=None, dtype: DtypeArg | None=None, method: Literal['multi'] | Callable | None=None, engine: str='auto', **engine_kwargs) -> int | None:
+        sql_engine = get_engine(engine)
+        table = self.prep_table(frame=frame, name=name, if_exists=if_exists, index=index, index_label=index_label, schema=schema, dtype=dtype)
+        total_inserted = sql_engine.insert_records(table=table, con=self.con, frame=frame, name=name, index=index, schema=schema, chunksize=chunksize, method=method, **engine_kwargs)
+        self.check_case_sensitive(name=name, schema=schema)
+        return total_inserted
+
+    @property
+    def tables(self):
+        return self.meta.tables
+
+    def has_table(self, name: str, schema: str | None=None) -> bool:
+        from sqlalchemy import inspect as sqlalchemy_inspect
+        insp = sqlalchemy_inspect(self.con)
+        return insp.has_table(name, schema or self.meta.schema)
+
+    def get_table(self, table_name: str, schema: str | None=None) -> Table:
+        from sqlalchemy import Numeric, Table
+        schema = schema or self.meta.schema
+        tbl = Table(table_name, self.meta, autoload_with=self.con, schema=schema)
+        for column in tbl.columns:
+            if isinstance(column.type, Numeric):
+                column.type.asdecimal = False
+        return tbl
+
+    def drop_table(self, table_name: str, schema: str | None=None) -> None:
+        schema = schema or self.meta.schema
+        if self.has_table(table_name, schema):
+            self.meta.reflect(bind=self.con, only=[table_name], schema=schema, views=True)
+            with self.run_transaction():
+                self.get_table(table_name, schema).drop(bind=self.con)
+            self.meta.clear()
+
+    def _create_sql_schema(self, frame: DataFrame, table_name: str, keys: list[str] | None=None, dtype: DtypeArg | None=None, schema: str | None=None) -> str:
+        table = SQLTable(table_name, self, frame=frame, index=False, keys=keys, dtype=dtype, schema=schema)
+        return str(table.sql_schema())
+
+class ADBCDatabase(PandasSQL):
+
+    def __init__(self, con) -> None:
+        self.con = con
+
+    @contextmanager
+    def run_transaction(self):
+        with self.con.cursor() as cur:
+            try:
+                yield cur
+            except Exception:
+                self.con.rollback()
+                raise
+            self.con.commit()
+
+    def execute(self, sql: str | Select | TextClause, params=None):
+        if not isinstance(sql, str):
+            raise TypeError('Query must be a string unless using sqlalchemy.')
+        args = [] if params is None else [params]
+        cur = self.con.cursor()
+        try:
+            cur.execute(sql, *args)
+            return cur
+        except Exception as exc:
+            try:
+                self.con.rollback()
+            except Exception as inner_exc:
+                ex = DatabaseError(f'Execution failed on sql: {sql}\n{exc}\nunable to rollback')
+                raise ex from inner_exc
+            ex = DatabaseError(f"Execution failed on sql '{sql}': {exc}")
+            raise ex from exc
+
+    def read_table(self, table_name: str, index_col: str | list[str] | None=None, coerce_float: bool=True, parse_dates=None, columns=None, schema: str | None=None, chunksize: int | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> DataFrame | Iterator[DataFrame]:
+        if coerce_float is not True:
+            raise NotImplementedError("'coerce_float' is not implemented for ADBC drivers")
+        if chunksize:
+            raise NotImplementedError("'chunksize' is not implemented for ADBC drivers")
+        if columns:
+            if index_col:
+                index_select = maybe_make_list(index_col)
+            else:
+                index_select = []
+            to_select = index_select + columns
+            select_list = ', '.join((f'"{x}"' for x in to_select))
+        else:
+            select_list = '*'
+        if schema:
+            stmt = f'SELECT {select_list} FROM {schema}.{table_name}'
+        else:
+            stmt = f'SELECT {select_list} FROM {table_name}'
+        mapping: type[ArrowDtype] | None | Callable
+        if dtype_backend == 'pyarrow':
+            mapping = ArrowDtype
+        elif dtype_backend == 'numpy_nullable':
+            from pandas.io._util import _arrow_dtype_mapping
+            mapping = _arrow_dtype_mapping().get
+        elif using_string_dtype():
+            from pandas.io._util import arrow_string_types_mapper
+            arrow_string_types_mapper()
+        else:
+            mapping = None
+        with self.con.cursor() as cur:
+            cur.execute(stmt)
+            df = cur.fetch_arrow_table().to_pandas(types_mapper=mapping)
+        return _wrap_result_adbc(df, index_col=index_col, parse_dates=parse_dates)
+
+    def read_query(self, sql: str, index_col: str | list[str] | None=None, coerce_float: bool=True, parse_dates=None, params=None, chunksize: int | None=None, dtype: DtypeArg | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> DataFrame | Iterator[DataFrame]:
+        if coerce_float is not True:
+            raise NotImplementedError("'coerce_float' is not implemented for ADBC drivers")
+        if params:
+            raise NotImplementedError("'params' is not implemented for ADBC drivers")
+        if chunksize:
+            raise NotImplementedError("'chunksize' is not implemented for ADBC drivers")
+        mapping: type[ArrowDtype] | None | Callable
+        if dtype_backend == 'pyarrow':
+            mapping = ArrowDtype
+        elif dtype_backend == 'numpy_nullable':
+            from pandas.io._util import _arrow_dtype_mapping
+            mapping = _arrow_dtype_mapping().get
+        else:
+            mapping = None
+        with self.con.cursor() as cur:
+            cur.execute(sql)
+            df = cur.fetch_arrow_table().to_pandas(types_mapper=mapping)
+        return _wrap_result_adbc(df, index_col=index_col, parse_dates=parse_dates, dtype=dtype)
+    read_sql = read_query
+
+    def to_sql(self, frame, name: str, if_exists: Literal['fail', 'replace', 'append']='fail', index: bool=True, index_label=None, schema: str | None=None, chunksize: int | None=None, dtype: DtypeArg | None=None, method: Literal['multi'] | Callable | None=None, engine: str='auto', **engine_kwargs) -> int | None:
+        if index_label:
+            raise NotImplementedError("'index_label' is not implemented for ADBC drivers")
+        if chunksize:
+            raise NotImplementedError("'chunksize' is not implemented for ADBC drivers")
+        if dtype:
+            raise NotImplementedError("'dtype' is not implemented for ADBC drivers")
+        if method:
+            raise NotImplementedError("'method' is not implemented for ADBC drivers")
+        if engine != 'auto':
+            raise NotImplementedError("engine != 'auto' not implemented for ADBC drivers")
+        if schema:
+            table_name = f'{schema}.{name}'
+        else:
+            table_name = name
+        mode = 'create'
+        if self.has_table(name, schema):
+            if if_exists == 'fail':
+                raise ValueError(f"Table '{table_name}' already exists.")
+            elif if_exists == 'replace':
+                with self.con.cursor() as cur:
+                    cur.execute(f'DROP TABLE {table_name}')
+            elif if_exists == 'append':
+                mode = 'append'
+        import pyarrow as pa
+        try:
+            tbl = pa.Table.from_pandas(frame, preserve_index=index)
+        except pa.ArrowNotImplementedError as exc:
+            raise ValueError('datatypes not supported') from exc
+        with self.con.cursor() as cur:
+            total_inserted = cur.adbc_ingest(table_name=name, data=tbl, mode=mode, db_schema_name=schema)
+        self.con.commit()
+        return total_inserted
+
+    def has_table(self, name: str, schema: str | None=None) -> bool:
+        meta = self.con.adbc_get_objects(db_schema_filter=schema, table_name_filter=name).read_all()
+        for catalog_schema in meta['catalog_db_schemas'].to_pylist():
+            if not catalog_schema:
+                continue
+            for schema_record in catalog_schema:
+                if not schema_record:
+                    continue
+                for table_record in schema_record['db_schema_tables']:
+                    if table_record['table_name'] == name:
+                        return True
+        return False
+
+    def _create_sql_schema(self, frame: DataFrame, table_name: str, keys: list[str] | None=None, dtype: DtypeArg | None=None, schema: str | None=None) -> str:
+        raise NotImplementedError('not implemented for adbc')
+_SQL_TYPES = {'string': 'TEXT', 'floating': 'REAL', 'integer': 'INTEGER', 'datetime': 'TIMESTAMP', 'date': 'DATE', 'time': 'TIME', 'boolean': 'INTEGER'}
+
+def _get_unicode_name(name: object) -> str:
+    try:
+        uname = str(name).encode('utf-8', 'strict').decode('utf-8')
+    except UnicodeError as err:
+        raise ValueError(f"Cannot convert identifier to UTF-8: '{name}'") from err
+    return uname
+
+def _get_valid_sqlite_name(name: object) -> str:
+    uname = _get_unicode_name(name)
+    if not len(uname):
+        raise ValueError('Empty table or column name specified')
+    nul_index = uname.find('\x00')
+    if nul_index >= 0:
+        raise ValueError('SQLite identifier cannot contain NULs')
+    return '"' + uname.replace('"', '""') + '"'
+
+class SQLiteTable(SQLTable):
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._register_date_adapters()
+
+    def _register_date_adapters(self) -> None:
+        import sqlite3
+
+        def _adapt_time(t) -> str:
+            return f'{t.hour:02d}:{t.minute:02d}:{t.second:02d}.{t.microsecond:06d}'
+        adapt_date_iso = lambda val: val.isoformat()
+        adapt_datetime_iso = lambda val: val.isoformat(' ')
+        sqlite3.register_adapter(time, _adapt_time)
+        sqlite3.register_adapter(date, adapt_date_iso)
+        sqlite3.register_adapter(datetime, adapt_datetime_iso)
+        convert_date = lambda val: date.fromisoformat(val.decode())
+        convert_timestamp = lambda val: datetime.fromisoformat(val.decode())
+        sqlite3.register_converter('date', convert_date)
+        sqlite3.register_converter('timestamp', convert_timestamp)
+
+    def sql_schema(self) -> str:
+        return str(';\n'.join(self.table))
+
+    def _execute_create(self) -> None:
+        with self.pd_sql.run_transaction() as conn:
+            for stmt in self.table:
+                conn.execute(stmt)
+
+    def insert_statement(self, *, num_rows: int) -> str:
+        names = list(map(str, self.frame.columns))
+        wld = '?'
+        escape = _get_valid_sqlite_name
+        if self.index is not None:
+            for idx in self.index[::-1]:
+                names.insert(0, idx)
+        bracketed_names = [escape(column) for column in names]
+        col_names = ','.join(bracketed_names)
+        row_wildcards = ','.join([wld] * len(names))
+        wildcards = ','.join([f'({row_wildcards})' for _ in range(num_rows)])
+        insert_statement = f'INSERT INTO {escape(self.name)} ({col_names}) VALUES {wildcards}'
+        return insert_statement
+
+    def _execute_insert(self, conn, keys, data_iter) -> int:
+        data_list = list(data_iter)
+        conn.executemany(self.insert_statement(num_rows=1), data_list)
+        return conn.rowcount
+
+    def _execute_insert_multi(self, conn, keys, data_iter) -> int:
+        data_list = list(data_iter)
+        flattened_data = [x for row in data_list for x in row]
+        conn.execute(self.insert_statement(num_rows=len(data_list)), flattened_data)
+        return conn.rowcount
+
+    def _create_table_setup(self):
+        column_names_and_types = self._get_column_names_and_types(self._sql_type_name)
+        escape = _get_valid_sqlite_name
+        create_tbl_stmts = [escape(cname) + ' ' + ctype for (cname, ctype, _) in column_names_and_types]
+        if self.keys is not None and len(self.keys):
+            if not is_list_like(self.keys):
+                keys = [self.keys]
+            else:
+                keys = self.keys
+            cnames_br = ', '.join([escape(c) for c in keys])
+            create_tbl_stmts.append(f'CONSTRAINT {self.name}_pk PRIMARY KEY ({cnames_br})')
+        if self.schema:
+            schema_name = self.schema + '.'
+        else:
+            schema_name = ''
+        create_stmts = ['CREATE TABLE ' + schema_name + escape(self.name) + ' (\n' + ',\n  '.join(create_tbl_stmts) + '\n)']
+        ix_cols = [cname for (cname, _, is_index) in column_names_and_types if is_index]
+        if len(ix_cols):
+            cnames = '_'.join(ix_cols)
+            cnames_br = ','.join([escape(c) for c in ix_cols])
+            create_stmts.append('CREATE INDEX ' + escape('ix_' + self.name + '_' + cnames) + 'ON ' + escape(self.name) + ' (' + cnames_br + ')')
+        return create_stmts
+
+    def _sql_type_name(self, col):
+        dtype: DtypeArg = self.dtype or {}
+        if is_dict_like(dtype):
+            dtype = cast(dict, dtype)
+            if col.name in dtype:
+                return dtype[col.name]
+        col_type = lib.infer_dtype(col, skipna=True)
+        if col_type == 'timedelta64':
+            warnings.warn("the 'timedelta' type is not supported, and will be written as integer values (ns frequency) to the database.", UserWarning, stacklevel=find_stack_level())
+            col_type = 'integer'
+        elif col_type == 'datetime64':
+            col_type = 'datetime'
+        elif col_type == 'empty':
+            col_type = 'string'
+        elif col_type == 'complex':
+            raise ValueError('Complex datatypes not supported')
+        if col_type not in _SQL_TYPES:
+            col_type = 'string'
+        return _SQL_TYPES[col_type]
+
+class SQLiteDatabase(PandasSQL):
+
+    def __init__(self, con) -> None:
+        self.con = con
+
+    @contextmanager
+    def run_transaction(self):
+        cur = self.con.cursor()
+        try:
+            yield cur
+            self.con.commit()
+        except Exception:
+            self.con.rollback()
+            raise
+        finally:
+            cur.close()
+
+    def execute(self, sql: str | Select | TextClause, params=None):
+        if not isinstance(sql, str):
+            raise TypeError('Query must be a string unless using sqlalchemy.')
+        args = [] if params is None else [params]
+        cur = self.con.cursor()
+        try:
+            cur.execute(sql, *args)
+            return cur
+        except Exception as exc:
+            try:
+                self.con.rollback()
+            except Exception as inner_exc:
+                ex = DatabaseError(f'Execution failed on sql: {sql}\n{exc}\nunable to rollback')
+                raise ex from inner_exc
+            ex = DatabaseError(f"Execution failed on sql '{sql}': {exc}")
+            raise ex from exc
+
+    @staticmethod
+    def _query_iterator(cursor, chunksize: int, columns, index_col=None, coerce_float: bool=True, parse_dates=None, dtype: DtypeArg | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> Generator[DataFrame, None, None]:
+        has_read_data = False
+        while True:
+            data = cursor.fetchmany(chunksize)
+            if type(data) == tuple:
+                data = list(data)
+            if not data:
+                cursor.close()
+                if not has_read_data:
+                    result = DataFrame.from_records([], columns=columns, coerce_float=coerce_float)
+                    if dtype:
+                        result = result.astype(dtype)
+                    yield result
+                break
+            has_read_data = True
+            yield _wrap_result(data, columns, index_col=index_col, coerce_float=coerce_float, parse_dates=parse_dates, dtype=dtype, dtype_backend=dtype_backend)
+
+    def read_query(self, sql, index_col=None, coerce_float: bool=True, parse_dates=None, params=None, chunksize: int | None=None, dtype: DtypeArg | None=None, dtype_backend: DtypeBackend | Literal['numpy']='numpy') -> DataFrame | Iterator[DataFrame]:
+        cursor = self.execute(sql, params)
+        columns = [col_desc[0] for col_desc in cursor.description]
+        if chunksize is not None:
+            return self._query_iterator(cursor, chunksize, columns, index_col=index_col, coerce_float=coerce_float, parse_dates=parse_dates, dtype=dtype, dtype_backend=dtype_backend)
+        else:
+            data = self._fetchall_as_list(cursor)
+            cursor.close()
+            frame = _wrap_result(data, columns, index_col=index_col, coerce_float=coerce_float, parse_dates=parse_dates, dtype=dtype, dtype_backend=dtype_backend)
+            return frame
+
+    def _fetchall_as_list(self, cur):
+        result = cur.fetchall()
+        if not isinstance(result, list):
+            result = list(result)
+        return result
+
+    def to_sql(self, frame, name: str, if_exists: str='fail', index: bool=True, index_label=None, schema=None, chunksize: int | None=None, dtype: DtypeArg | None=None, method: Literal['multi'] | Callable | None=None, engine: str='auto', **engine_kwargs) -> int | None:
+        if dtype:
+            if not is_dict_like(dtype):
+                dtype = {col_name: dtype for col_name in frame}
+            else:
+                dtype = cast(dict, dtype)
+            for (col, my_type) in dtype.items():
+                if not isinstance(my_type, str):
+                    raise ValueError(f'{col} ({my_type}) not a string')
+        table = SQLiteTable(name, self, frame=frame, index=index, if_exists=if_exists, index_label=index_label, dtype=dtype)
+        table.create()
+        return table.insert(chunksize, method)
+
+    def has_table(self, name: str, schema: str | None=None) -> bool:
+        wld = '?'
+        query = f"\n        SELECT\n            name\n        FROM\n            sqlite_master\n        WHERE\n            type IN ('table', 'view')\n            AND name={wld};\n        "
+        return len(self.execute(query, [name]).fetchall()) > 0
+
+    def get_table(self, table_name: str, schema: str | None=None) -> None:
+        return None
+
+    def drop_table(self, name: str, schema: str | None=None) -> None:
+        drop_sql = f'DROP TABLE {_get_valid_sqlite_name(name)}'
+        self.execute(drop_sql)
+
+    def _create_sql_schema(self, frame, table_name: str, keys=None, dtype: DtypeArg | None=None, schema: str | None=None) -> str:
+        table = SQLiteTable(table_name, self, frame=frame, index=False, keys=keys, dtype=dtype, schema=schema)
+        return str(table.sql_schema())
+
+def get_schema(frame, name: str, keys=None, con=None, dtype: DtypeArg | None=None, schema: str | None=None) -> str:
+    with pandasSQL_builder(con=con) as pandas_sql:
+        return pandas_sql._create_sql_schema(frame, name, keys=keys, dtype=dtype, schema=schema)
+
+# File: pandas-main/pandas/io/stata.py
+""""""
+from __future__ import annotations
+from collections import abc
+from datetime import datetime, timedelta
+from io import BytesIO
+import os
+import struct
+import sys
+from typing import IO, TYPE_CHECKING, AnyStr, Final, cast
+import warnings
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.lib import infer_dtype
+from pandas._libs.writers import max_len_string_array
+from pandas.errors import CategoricalConversionWarning, InvalidColumnName, PossiblePrecisionLoss, ValueLabelTypeMismatch
+from pandas.util._decorators import Appender, doc
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.base import ExtensionDtype
+from pandas.core.dtypes.common import ensure_object, is_numeric_dtype, is_string_dtype
+from pandas.core.dtypes.dtypes import CategoricalDtype
+from pandas import Categorical, DatetimeIndex, NaT, Timestamp, isna, to_datetime
+from pandas.core.frame import DataFrame
+from pandas.core.indexes.base import Index
+from pandas.core.indexes.range import RangeIndex
+from pandas.core.series import Series
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.common import get_handle
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Sequence
+    from types import TracebackType
+    from typing import Literal
+    from pandas._typing import CompressionOptions, FilePath, ReadBuffer, Self, StorageOptions, WriteBuffer
+_version_error = 'Version of given Stata file is {version}. pandas supports importing versions 102, 103, 104, 105, 108, 110 (Stata 7), 111 (Stata 7SE),  113 (Stata 8/9), 114 (Stata 10/11), 115 (Stata 12), 117 (Stata 13), 118 (Stata 14/15/16), and 119 (Stata 15/16, over 32,767 variables).'
+_statafile_processing_params1 = 'convert_dates : bool, default True\n    Convert date variables to DataFrame time values.\nconvert_categoricals : bool, default True\n    Read value labels and convert columns to Categorical/Factor variables.'
+_statafile_processing_params2 = 'index_col : str, optional\n    Column to set as index.\nconvert_missing : bool, default False\n    Flag indicating whether to convert missing values to their Stata\n    representations.  If False, missing values are replaced with nan.\n    If True, columns containing missing values are returned with\n    object data types and missing values are represented by\n    StataMissingValue objects.\npreserve_dtypes : bool, default True\n    Preserve Stata datatypes. If False, numeric data are upcast to pandas\n    default types for foreign data (float64 or int64).\ncolumns : list or None\n    Columns to retain.  Columns will be returned in the given order.  None\n    returns all columns.\norder_categoricals : bool, default True\n    Flag indicating whether converted categorical data are ordered.'
+_chunksize_params = 'chunksize : int, default None\n    Return StataReader object for iterations, returns chunks with\n    given number of lines.'
+_iterator_params = 'iterator : bool, default False\n    Return StataReader object.'
+_reader_notes = 'Notes\n-----\nCategorical variables read through an iterator may not have the same\ncategories and dtype. This occurs when  a variable stored in a DTA\nfile is associated to an incomplete set of value labels that only\nlabel a strict subset of the values.'
+_read_stata_doc = f"""\nRead Stata file into DataFrame.\n\nParameters\n----------\nfilepath_or_buffer : str, path object or file-like object\n    Any valid string path is acceptable. The string could be a URL. Valid\n    URL schemes include http, ftp, s3, and file. For file URLs, a host is\n    expected. A local file could be: ``file://localhost/path/to/table.dta``.\n\n    If you want to pass in a path object, pandas accepts any ``os.PathLike``.\n\n    By file-like object, we refer to objects with a ``read()`` method,\n    such as a file handle (e.g. via builtin ``open`` function)\n    or ``StringIO``.\n{_statafile_processing_params1}\n{_statafile_processing_params2}\n{_chunksize_params}\n{_iterator_params}\n{_shared_docs['decompression_options'] % 'filepath_or_buffer'}\n{_shared_docs['storage_options']}\n\nReturns\n-------\nDataFrame, pandas.api.typing.StataReader\n    If iterator or chunksize, returns StataReader, else DataFrame.\n\nSee Also\n--------\nio.stata.StataReader : Low-level reader for Stata data files.\nDataFrame.to_stata: Export Stata data files.\n\n{_reader_notes}\n\nExamples\n--------\n\nCreating a dummy stata for this example\n\n>>> df = pd.DataFrame({{'animal': ['falcon', 'parrot', 'falcon', 'parrot'],\n...                   'speed': [350, 18, 361, 15]}})  # doctest: +SKIP\n>>> df.to_stata('animals.dta')  # doctest: +SKIP\n\nRead a Stata dta file:\n\n>>> df = pd.read_stata('animals.dta')  # doctest: +SKIP\n\nRead a Stata dta file in 10,000 line chunks:\n\n>>> values = np.random.randint(0, 10, size=(20_000, 1), dtype="uint8")  # doctest: +SKIP\n>>> df = pd.DataFrame(values, columns=["i"])  # doctest: +SKIP\n>>> df.to_stata('filename.dta')  # doctest: +SKIP\n\n>>> with pd.read_stata('filename.dta', chunksize=10000) as itr:  # doctest: +SKIP\n>>>     for chunk in itr:\n...         # Operate on a single chunk, e.g., chunk.mean()\n...         pass  # doctest: +SKIP\n"""
+_read_method_doc = f'Reads observations from Stata file, converting them into a dataframe\n\nParameters\n----------\nnrows : int\n    Number of lines to read from data file, if None read whole file.\n{_statafile_processing_params1}\n{_statafile_processing_params2}\n\nReturns\n-------\nDataFrame\n'
+_stata_reader_doc = f"Class for reading Stata dta files.\n\nParameters\n----------\npath_or_buf : path (string), buffer or path object\n    string, pathlib.Path or object\n    implementing a binary read() functions.\n{_statafile_processing_params1}\n{_statafile_processing_params2}\n{_chunksize_params}\n{_shared_docs['decompression_options']}\n{_shared_docs['storage_options']}\n\n{_reader_notes}\n"
+_date_formats = ['%tc', '%tC', '%td', '%d', '%tw', '%tm', '%tq', '%th', '%ty']
+stata_epoch: Final = datetime(1960, 1, 1)
+unix_epoch: Final = datetime(1970, 1, 1)
+
+def _stata_elapsed_date_to_datetime_vec(dates: Series, fmt: str) -> Series:
+    if fmt.startswith(('%tc', 'tc')):
+        td = np.timedelta64(stata_epoch - unix_epoch, 'ms')
+        res = np.array(dates._values, dtype='M8[ms]') + td
+        return Series(res, index=dates.index)
+    elif fmt.startswith(('%td', 'td', '%d', 'd')):
+        td = np.timedelta64(stata_epoch - unix_epoch, 'D')
+        res = np.array(dates._values, dtype='M8[D]') + td
+        return Series(res, index=dates.index)
+    elif fmt.startswith(('%tm', 'tm')):
+        ordinals = dates + (stata_epoch.year - unix_epoch.year) * 12
+        res = np.array(ordinals, dtype='M8[M]').astype('M8[s]')
+        return Series(res, index=dates.index)
+    elif fmt.startswith(('%tq', 'tq')):
+        ordinals = dates + (stata_epoch.year - unix_epoch.year) * 4
+        res = np.array(ordinals, dtype='M8[3M]').astype('M8[s]')
+        return Series(res, index=dates.index)
+    elif fmt.startswith(('%th', 'th')):
+        ordinals = dates + (stata_epoch.year - unix_epoch.year) * 2
+        res = np.array(ordinals, dtype='M8[6M]').astype('M8[s]')
+        return Series(res, index=dates.index)
+    elif fmt.startswith(('%ty', 'ty')):
+        ordinals = dates - 1970
+        res = np.array(ordinals, dtype='M8[Y]').astype('M8[s]')
+        return Series(res, index=dates.index)
+    bad_locs = np.isnan(dates)
+    has_bad_values = False
+    if bad_locs.any():
+        has_bad_values = True
+        dates._values[bad_locs] = 1.0
+    dates = dates.astype(np.int64)
+    if fmt.startswith(('%tC', 'tC')):
+        warnings.warn('Encountered %tC format. Leaving in Stata Internal Format.', stacklevel=find_stack_level())
+        conv_dates = Series(dates, dtype=object)
+        if has_bad_values:
+            conv_dates[bad_locs] = NaT
+        return conv_dates
+    elif fmt.startswith(('%tw', 'tw')):
+        year = stata_epoch.year + dates // 52
+        days = dates % 52 * 7
+        per_y = (year - 1970).array.view('Period[Y]')
+        per_d = per_y.asfreq('D', how='S')
+        per_d_shifted = per_d + days._values
+        per_s = per_d_shifted.asfreq('s', how='S')
+        conv_dates_arr = per_s.view('M8[s]')
+        conv_dates = Series(conv_dates_arr, index=dates.index)
+    else:
+        raise ValueError(f'Date fmt {fmt} not understood')
+    if has_bad_values:
+        conv_dates[bad_locs] = NaT
+    return conv_dates
+
+def _datetime_to_stata_elapsed_vec(dates: Series, fmt: str) -> Series:
+    index = dates.index
+    NS_PER_DAY = 24 * 3600 * 1000 * 1000 * 1000
+    US_PER_DAY = NS_PER_DAY / 1000
+    MS_PER_DAY = NS_PER_DAY / 1000000
+
+    def parse_dates_safe(dates: Series, delta: bool=False, year: bool=False, days: bool=False) -> DataFrame:
+        d = {}
+        if lib.is_np_dtype(dates.dtype, 'M'):
+            if delta:
+                time_delta = dates.dt.as_unit('ms') - Timestamp(stata_epoch).as_unit('ms')
+                d['delta'] = time_delta._values.view(np.int64)
+            if days or year:
+                date_index = DatetimeIndex(dates)
+                d['year'] = date_index._data.year
+                d['month'] = date_index._data.month
+            if days:
+                year_start = np.asarray(dates).astype('M8[Y]').astype(dates.dtype)
+                diff = dates - year_start
+                d['days'] = np.asarray(diff).astype('m8[D]').view('int64')
+        elif infer_dtype(dates, skipna=False) == 'datetime':
+            if delta:
+                delta = dates._values - stata_epoch
+
+                def f(x: timedelta) -> float:
+                    return US_PER_DAY * x.days + 1000000 * x.seconds + x.microseconds
+                v = np.vectorize(f)
+                d['delta'] = v(delta)
+            if year:
+                year_month = dates.apply(lambda x: 100 * x.year + x.month)
+                d['year'] = year_month._values // 100
+                d['month'] = year_month._values - d['year'] * 100
+            if days:
+
+                def g(x: datetime) -> int:
+                    return (x - datetime(x.year, 1, 1)).days
+                v = np.vectorize(g)
+                d['days'] = v(dates)
+        else:
+            raise ValueError('Columns containing dates must contain either datetime64, datetime or null values.')
+        return DataFrame(d, index=index)
+    bad_loc = isna(dates)
+    index = dates.index
+    if bad_loc.any():
+        if lib.is_np_dtype(dates.dtype, 'M'):
+            dates._values[bad_loc] = to_datetime(stata_epoch)
+        else:
+            dates._values[bad_loc] = stata_epoch
+    if fmt in ['%tc', 'tc']:
+        d = parse_dates_safe(dates, delta=True)
+        conv_dates = d.delta
+    elif fmt in ['%tC', 'tC']:
+        warnings.warn('Stata Internal Format tC not supported.', stacklevel=find_stack_level())
+        conv_dates = dates
+    elif fmt in ['%td', 'td']:
+        d = parse_dates_safe(dates, delta=True)
+        conv_dates = d.delta // MS_PER_DAY
+    elif fmt in ['%tw', 'tw']:
+        d = parse_dates_safe(dates, year=True, days=True)
+        conv_dates = 52 * (d.year - stata_epoch.year) + d.days // 7
+    elif fmt in ['%tm', 'tm']:
+        d = parse_dates_safe(dates, year=True)
+        conv_dates = 12 * (d.year - stata_epoch.year) + d.month - 1
+    elif fmt in ['%tq', 'tq']:
+        d = parse_dates_safe(dates, year=True)
+        conv_dates = 4 * (d.year - stata_epoch.year) + (d.month - 1) // 3
+    elif fmt in ['%th', 'th']:
+        d = parse_dates_safe(dates, year=True)
+        conv_dates = 2 * (d.year - stata_epoch.year) + (d.month > 6).astype(int)
+    elif fmt in ['%ty', 'ty']:
+        d = parse_dates_safe(dates, year=True)
+        conv_dates = d.year
+    else:
+        raise ValueError(f'Format {fmt} is not a known Stata date format')
+    conv_dates = Series(conv_dates, dtype=np.float64, copy=False)
+    missing_value = struct.unpack('<d', b'\x00\x00\x00\x00\x00\x00\xe0\x7f')[0]
+    conv_dates[bad_loc] = missing_value
+    return Series(conv_dates, index=index, copy=False)
+excessive_string_length_error: Final = "\nFixed width strings in Stata .dta files are limited to 244 (or fewer)\ncharacters.  Column '{0}' does not satisfy this restriction. Use the\n'version=117' parameter to write the newer (Stata 13 and later) format.\n"
+precision_loss_doc: Final = '\nColumn converted from {0} to {1}, and some data are outside of the lossless\nconversion range. This may result in a loss of precision in the saved data.\n'
+value_label_mismatch_doc: Final = '\nStata value labels (pandas categories) must be strings. Column {0} contains\nnon-string labels which will be converted to strings.  Please check that the\nStata data file created has not lost information due to duplicate labels.\n'
+invalid_name_doc: Final = '\nNot all pandas column names were valid Stata variable names.\nThe following replacements have been made:\n\n    {0}\n\nIf this is not what you expect, please make sure you have Stata-compliant\ncolumn names in your DataFrame (strings only, max 32 characters, only\nalphanumerics and underscores, no Stata reserved words)\n'
+categorical_conversion_warning: Final = '\nOne or more series with value labels are not fully labeled. Reading this\ndataset with an iterator results in categorical variable with different\ncategories. This occurs since it is not possible to know all possible values\nuntil the entire dataset has been read. To avoid this warning, you can either\nread dataset without an iterator, or manually convert categorical data by\n``convert_categoricals`` to False and then accessing the variable labels\nthrough the value_labels method of the reader.\n'
+
+def _cast_to_stata_types(data: DataFrame) -> DataFrame:
+    ws = ''
+    conversion_data: tuple[tuple[type, type, type], tuple[type, type, type], tuple[type, type, type], tuple[type, type, type], tuple[type, type, type]] = ((np.bool_, np.int8, np.int8), (np.uint8, np.int8, np.int16), (np.uint16, np.int16, np.int32), (np.uint32, np.int32, np.int64), (np.uint64, np.int64, np.float64))
+    float32_max = struct.unpack('<f', b'\xff\xff\xff~')[0]
+    float64_max = struct.unpack('<d', b'\xff\xff\xff\xff\xff\xff\xdf\x7f')[0]
+    for col in data:
+        is_nullable_int = isinstance(data[col].dtype, ExtensionDtype) and data[col].dtype.kind in 'iub'
+        orig_missing = data[col].isna()
+        if is_nullable_int:
+            fv = 0 if data[col].dtype.kind in 'iu' else False
+            data[col] = data[col].fillna(fv).astype(data[col].dtype.numpy_dtype)
+        elif isinstance(data[col].dtype, ExtensionDtype):
+            if getattr(data[col].dtype, 'numpy_dtype', None) is not None:
+                data[col] = data[col].astype(data[col].dtype.numpy_dtype)
+            elif is_string_dtype(data[col].dtype):
+                data[col] = data[col].astype('object')
+        dtype = data[col].dtype
+        empty_df = data.shape[0] == 0
+        for c_data in conversion_data:
+            if dtype == c_data[0]:
+                if empty_df or data[col].max() <= np.iinfo(c_data[1]).max:
+                    dtype = c_data[1]
+                else:
+                    dtype = c_data[2]
+                if c_data[2] == np.int64:
+                    if data[col].max() >= 2 ** 53:
+                        ws = precision_loss_doc.format('uint64', 'float64')
+                data[col] = data[col].astype(dtype)
+        if dtype == np.int8 and (not empty_df):
+            if data[col].max() > 100 or data[col].min() < -127:
+                data[col] = data[col].astype(np.int16)
+        elif dtype == np.int16 and (not empty_df):
+            if data[col].max() > 32740 or data[col].min() < -32767:
+                data[col] = data[col].astype(np.int32)
+        elif dtype == np.int64:
+            if empty_df or (data[col].max() <= 2147483620 and data[col].min() >= -2147483647):
+                data[col] = data[col].astype(np.int32)
+            else:
+                data[col] = data[col].astype(np.float64)
+                if data[col].max() >= 2 ** 53 or data[col].min() <= -2 ** 53:
+                    ws = precision_loss_doc.format('int64', 'float64')
+        elif dtype in (np.float32, np.float64):
+            if np.isinf(data[col]).any():
+                raise ValueError(f'Column {col} contains infinity or -infinitywhich is outside the range supported by Stata.')
+            value = data[col].max()
+            if dtype == np.float32 and value > float32_max:
+                data[col] = data[col].astype(np.float64)
+            elif dtype == np.float64:
+                if value > float64_max:
+                    raise ValueError(f'Column {col} has a maximum value ({value}) outside the range supported by Stata ({float64_max})')
+        if is_nullable_int:
+            if orig_missing.any():
+                sentinel = StataMissingValue.BASE_MISSING_VALUES[data[col].dtype.name]
+                data.loc[orig_missing, col] = sentinel
+    if ws:
+        warnings.warn(ws, PossiblePrecisionLoss, stacklevel=find_stack_level())
+    return data
+
+class StataValueLabel:
+
+    def __init__(self, catarray: Series, encoding: Literal['latin-1', 'utf-8']='latin-1') -> None:
+        if encoding not in ('latin-1', 'utf-8'):
+            raise ValueError('Only latin-1 and utf-8 are supported.')
+        self.labname = catarray.name
+        self._encoding = encoding
+        categories = catarray.cat.categories
+        self.value_labels = enumerate(categories)
+        self._prepare_value_labels()
+
+    def _prepare_value_labels(self) -> None:
+        self.text_len = 0
+        self.txt: list[bytes] = []
+        self.n = 0
+        self.off = np.array([], dtype=np.int32)
+        self.val = np.array([], dtype=np.int32)
+        self.len = 0
+        offsets: list[int] = []
+        values: list[float] = []
+        for vl in self.value_labels:
+            category: str | bytes = vl[1]
+            if not isinstance(category, str):
+                category = str(category)
+                warnings.warn(value_label_mismatch_doc.format(self.labname), ValueLabelTypeMismatch, stacklevel=find_stack_level())
+            category = category.encode(self._encoding)
+            offsets.append(self.text_len)
+            self.text_len += len(category) + 1
+            values.append(vl[0])
+            self.txt.append(category)
+            self.n += 1
+        if self.text_len > 32000:
+            raise ValueError('Stata value labels for a single variable must have a combined length less than 32,000 characters.')
+        self.off = np.array(offsets, dtype=np.int32)
+        self.val = np.array(values, dtype=np.int32)
+        self.len = 4 + 4 + 4 * self.n + 4 * self.n + self.text_len
+
+    def generate_value_label(self, byteorder: str) -> bytes:
+        encoding = self._encoding
+        bio = BytesIO()
+        null_byte = b'\x00'
+        bio.write(struct.pack(byteorder + 'i', self.len))
+        labname = str(self.labname)[:32].encode(encoding)
+        lab_len = 32 if encoding not in ('utf-8', 'utf8') else 128
+        labname = _pad_bytes(labname, lab_len + 1)
+        bio.write(labname)
+        for i in range(3):
+            bio.write(struct.pack('c', null_byte))
+        bio.write(struct.pack(byteorder + 'i', self.n))
+        bio.write(struct.pack(byteorder + 'i', self.text_len))
+        for offset in self.off:
+            bio.write(struct.pack(byteorder + 'i', offset))
+        for value in self.val:
+            bio.write(struct.pack(byteorder + 'i', value))
+        for text in self.txt:
+            bio.write(text + null_byte)
+        return bio.getvalue()
+
+class StataNonCatValueLabel(StataValueLabel):
+
+    def __init__(self, labname: str, value_labels: dict[float, str], encoding: Literal['latin-1', 'utf-8']='latin-1') -> None:
+        if encoding not in ('latin-1', 'utf-8'):
+            raise ValueError('Only latin-1 and utf-8 are supported.')
+        self.labname = labname
+        self._encoding = encoding
+        self.value_labels = sorted(value_labels.items(), key=lambda x: x[0])
+        self._prepare_value_labels()
+
+class StataMissingValue:
+    MISSING_VALUES: dict[float, str] = {}
+    bases: Final = (101, 32741, 2147483621)
+    for b in bases:
+        MISSING_VALUES[b] = '.'
+        for i in range(1, 27):
+            MISSING_VALUES[i + b] = '.' + chr(96 + i)
+    float32_base: bytes = b'\x00\x00\x00\x7f'
+    increment_32: int = struct.unpack('<i', b'\x00\x08\x00\x00')[0]
+    for i in range(27):
+        key = struct.unpack('<f', float32_base)[0]
+        MISSING_VALUES[key] = '.'
+        if i > 0:
+            MISSING_VALUES[key] += chr(96 + i)
+        int_value = struct.unpack('<i', struct.pack('<f', key))[0] + increment_32
+        float32_base = struct.pack('<i', int_value)
+    float64_base: bytes = b'\x00\x00\x00\x00\x00\x00\xe0\x7f'
+    increment_64 = struct.unpack('q', b'\x00\x00\x00\x00\x00\x01\x00\x00')[0]
+    for i in range(27):
+        key = struct.unpack('<d', float64_base)[0]
+        MISSING_VALUES[key] = '.'
+        if i > 0:
+            MISSING_VALUES[key] += chr(96 + i)
+        int_value = struct.unpack('q', struct.pack('<d', key))[0] + increment_64
+        float64_base = struct.pack('q', int_value)
+    BASE_MISSING_VALUES: Final = {'int8': 101, 'int16': 32741, 'int32': 2147483621, 'float32': struct.unpack('<f', float32_base)[0], 'float64': struct.unpack('<d', float64_base)[0]}
+
+    def __init__(self, value: float) -> None:
+        self._value = value
+        value = int(value) if value < 2147483648 else float(value)
+        self._str = self.MISSING_VALUES[value]
+
+    @property
+    def string(self) -> str:
+        return self._str
+
+    @property
+    def value(self) -> float:
+        return self._value
+
+    def __str__(self) -> str:
+        return self.string
+
+    def __repr__(self) -> str:
+        return f'{type(self)}({self})'
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, type(self)) and self.string == other.string and (self.value == other.value)
+
+    @classmethod
+    def get_base_missing_value(cls, dtype: np.dtype) -> float:
+        if dtype.type is np.int8:
+            value = cls.BASE_MISSING_VALUES['int8']
+        elif dtype.type is np.int16:
+            value = cls.BASE_MISSING_VALUES['int16']
+        elif dtype.type is np.int32:
+            value = cls.BASE_MISSING_VALUES['int32']
+        elif dtype.type is np.float32:
+            value = cls.BASE_MISSING_VALUES['float32']
+        elif dtype.type is np.float64:
+            value = cls.BASE_MISSING_VALUES['float64']
+        else:
+            raise ValueError('Unsupported dtype')
+        return value
+
+class StataParser:
+
+    def __init__(self) -> None:
+        self.DTYPE_MAP = dict([(i, np.dtype(f'S{i}')) for i in range(1, 245)] + [(251, np.dtype(np.int8)), (252, np.dtype(np.int16)), (253, np.dtype(np.int32)), (254, np.dtype(np.float32)), (255, np.dtype(np.float64))])
+        self.DTYPE_MAP_XML: dict[int, np.dtype] = {32768: np.dtype(np.uint8), 65526: np.dtype(np.float64), 65527: np.dtype(np.float32), 65528: np.dtype(np.int32), 65529: np.dtype(np.int16), 65530: np.dtype(np.int8)}
+        self.TYPE_MAP = list(tuple(range(251)) + tuple('bhlfd'))
+        self.TYPE_MAP_XML = {32768: 'Q', 65526: 'd', 65527: 'f', 65528: 'l', 65529: 'h', 65530: 'b'}
+        float32_min = b'\xff\xff\xff\xfe'
+        float32_max = b'\xff\xff\xff~'
+        float64_min = b'\xff\xff\xff\xff\xff\xff\xef\xff'
+        float64_max = b'\xff\xff\xff\xff\xff\xff\xdf\x7f'
+        self.VALID_RANGE = {'b': (-127, 100), 'h': (-32767, 32740), 'l': (-2147483647, 2147483620), 'f': (np.float32(struct.unpack('<f', float32_min)[0]), np.float32(struct.unpack('<f', float32_max)[0])), 'd': (np.float64(struct.unpack('<d', float64_min)[0]), np.float64(struct.unpack('<d', float64_max)[0]))}
+        self.OLD_VALID_RANGE = {'b': (-128, 126), 'h': (-32768, 32766), 'l': (-2147483648, 2147483646), 'f': (np.float32(struct.unpack('<f', float32_min)[0]), np.float32(struct.unpack('<f', float32_max)[0])), 'd': (np.float64(struct.unpack('<d', float64_min)[0]), np.float64(struct.unpack('<d', float64_max)[0]))}
+        self.OLD_TYPE_MAPPING = {98: 251, 105: 252, 108: 253, 102: 254, 100: 255}
+        self.MISSING_VALUES: dict[str, int | np.float32 | np.float64] = {'b': 101, 'h': 32741, 'l': 2147483621, 'f': np.float32(struct.unpack('<f', b'\x00\x00\x00\x7f')[0]), 'd': np.float64(struct.unpack('<d', b'\x00\x00\x00\x00\x00\x00\xe0\x7f')[0])}
+        self.NUMPY_TYPE_MAP = {'b': 'i1', 'h': 'i2', 'l': 'i4', 'f': 'f4', 'd': 'f8', 'Q': 'u8'}
+        self.RESERVED_WORDS = {'aggregate', 'array', 'boolean', 'break', 'byte', 'case', 'catch', 'class', 'colvector', 'complex', 'const', 'continue', 'default', 'delegate', 'delete', 'do', 'double', 'else', 'eltypedef', 'end', 'enum', 'explicit', 'export', 'external', 'float', 'for', 'friend', 'function', 'global', 'goto', 'if', 'inline', 'int', 'local', 'long', 'NULL', 'pragma', 'protected', 'quad', 'rowvector', 'short', 'typedef', 'typename', 'virtual', '_all', '_N', '_skip', '_b', '_pi', 'str#', 'in', '_pred', 'strL', '_coef', '_rc', 'using', '_cons', '_se', 'with', '_n'}
+
+class StataReader(StataParser, abc.Iterator):
+    __doc__ = _stata_reader_doc
+    _path_or_buf: IO[bytes]
+
+    def __init__(self, path_or_buf: FilePath | ReadBuffer[bytes], convert_dates: bool=True, convert_categoricals: bool=True, index_col: str | None=None, convert_missing: bool=False, preserve_dtypes: bool=True, columns: Sequence[str] | None=None, order_categoricals: bool=True, chunksize: int | None=None, compression: CompressionOptions='infer', storage_options: StorageOptions | None=None) -> None:
+        super().__init__()
+        self._convert_dates = convert_dates
+        self._convert_categoricals = convert_categoricals
+        self._index_col = index_col
+        self._convert_missing = convert_missing
+        self._preserve_dtypes = preserve_dtypes
+        self._columns = columns
+        self._order_categoricals = order_categoricals
+        self._original_path_or_buf = path_or_buf
+        self._compression = compression
+        self._storage_options = storage_options
+        self._encoding = ''
+        self._chunksize = chunksize
+        self._using_iterator = False
+        self._entered = False
+        if self._chunksize is None:
+            self._chunksize = 1
+        elif not isinstance(chunksize, int) or chunksize <= 0:
+            raise ValueError('chunksize must be a positive integer when set.')
+        self._close_file: Callable[[], None] | None = None
+        self._column_selector_set = False
+        self._value_label_dict: dict[str, dict[int, str]] = {}
+        self._value_labels_read = False
+        self._dtype: np.dtype | None = None
+        self._lines_read = 0
+        self._native_byteorder = _set_endianness(sys.byteorder)
+
+    def _ensure_open(self) -> None:
+        if not hasattr(self, '_path_or_buf'):
+            self._open_file()
+
+    def _open_file(self) -> None:
+        if not self._entered:
+            warnings.warn('StataReader is being used without using a context manager. Using StataReader as a context manager is the only supported method.', ResourceWarning, stacklevel=find_stack_level())
+        handles = get_handle(self._original_path_or_buf, 'rb', storage_options=self._storage_options, is_text=False, compression=self._compression)
+        if hasattr(handles.handle, 'seekable') and handles.handle.seekable():
+            self._path_or_buf = handles.handle
+            self._close_file = handles.close
+        else:
+            with handles:
+                self._path_or_buf = BytesIO(handles.handle.read())
+            self._close_file = self._path_or_buf.close
+        self._read_header()
+        self._setup_dtype()
+
+    def __enter__(self) -> Self:
+        self._entered = True
+        return self
+
+    def __exit__(self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None) -> None:
+        if self._close_file:
+            self._close_file()
+
+    def _set_encoding(self) -> None:
+        if self._format_version < 118:
+            self._encoding = 'latin-1'
+        else:
+            self._encoding = 'utf-8'
+
+    def _read_int8(self) -> int:
+        return struct.unpack('b', self._path_or_buf.read(1))[0]
+
+    def _read_uint8(self) -> int:
+        return struct.unpack('B', self._path_or_buf.read(1))[0]
+
+    def _read_uint16(self) -> int:
+        return struct.unpack(f'{self._byteorder}H', self._path_or_buf.read(2))[0]
+
+    def _read_uint32(self) -> int:
+        return struct.unpack(f'{self._byteorder}I', self._path_or_buf.read(4))[0]
+
+    def _read_uint64(self) -> int:
+        return struct.unpack(f'{self._byteorder}Q', self._path_or_buf.read(8))[0]
+
+    def _read_int16(self) -> int:
+        return struct.unpack(f'{self._byteorder}h', self._path_or_buf.read(2))[0]
+
+    def _read_int32(self) -> int:
+        return struct.unpack(f'{self._byteorder}i', self._path_or_buf.read(4))[0]
+
+    def _read_int64(self) -> int:
+        return struct.unpack(f'{self._byteorder}q', self._path_or_buf.read(8))[0]
+
+    def _read_char8(self) -> bytes:
+        return struct.unpack('c', self._path_or_buf.read(1))[0]
+
+    def _read_int16_count(self, count: int) -> tuple[int, ...]:
+        return struct.unpack(f"{self._byteorder}{'h' * count}", self._path_or_buf.read(2 * count))
+
+    def _read_header(self) -> None:
+        first_char = self._read_char8()
+        if first_char == b'<':
+            self._read_new_header()
+        else:
+            self._read_old_header(first_char)
+
+    def _read_new_header(self) -> None:
+        self._path_or_buf.read(27)
+        self._format_version = int(self._path_or_buf.read(3))
+        if self._format_version not in [117, 118, 119]:
+            raise ValueError(_version_error.format(version=self._format_version))
+        self._set_encoding()
+        self._path_or_buf.read(21)
+        self._byteorder = '>' if self._path_or_buf.read(3) == b'MSF' else '<'
+        self._path_or_buf.read(15)
+        self._nvar = self._read_uint16() if self._format_version <= 118 else self._read_uint32()
+        self._path_or_buf.read(7)
+        self._nobs = self._get_nobs()
+        self._path_or_buf.read(11)
+        self._data_label = self._get_data_label()
+        self._path_or_buf.read(19)
+        self._time_stamp = self._get_time_stamp()
+        self._path_or_buf.read(26)
+        self._path_or_buf.read(8)
+        self._path_or_buf.read(8)
+        self._seek_vartypes = self._read_int64() + 16
+        self._seek_varnames = self._read_int64() + 10
+        self._seek_sortlist = self._read_int64() + 10
+        self._seek_formats = self._read_int64() + 9
+        self._seek_value_label_names = self._read_int64() + 19
+        self._seek_variable_labels = self._get_seek_variable_labels()
+        self._path_or_buf.read(8)
+        self._data_location = self._read_int64() + 6
+        self._seek_strls = self._read_int64() + 7
+        self._seek_value_labels = self._read_int64() + 14
+        (self._typlist, self._dtyplist) = self._get_dtypes(self._seek_vartypes)
+        self._path_or_buf.seek(self._seek_varnames)
+        self._varlist = self._get_varlist()
+        self._path_or_buf.seek(self._seek_sortlist)
+        self._srtlist = self._read_int16_count(self._nvar + 1)[:-1]
+        self._path_or_buf.seek(self._seek_formats)
+        self._fmtlist = self._get_fmtlist()
+        self._path_or_buf.seek(self._seek_value_label_names)
+        self._lbllist = self._get_lbllist()
+        self._path_or_buf.seek(self._seek_variable_labels)
+        self._variable_labels = self._get_variable_labels()
+
+    def _get_dtypes(self, seek_vartypes: int) -> tuple[list[int | str], list[str | np.dtype]]:
+        self._path_or_buf.seek(seek_vartypes)
+        typlist = []
+        dtyplist = []
+        for _ in range(self._nvar):
+            typ = self._read_uint16()
+            if typ <= 2045:
+                typlist.append(typ)
+                dtyplist.append(str(typ))
+            else:
+                try:
+                    typlist.append(self.TYPE_MAP_XML[typ])
+                    dtyplist.append(self.DTYPE_MAP_XML[typ])
+                except KeyError as err:
+                    raise ValueError(f'cannot convert stata types [{typ}]') from err
+        return (typlist, dtyplist)
+
+    def _get_varlist(self) -> list[str]:
+        b = 33 if self._format_version < 118 else 129
+        return [self._decode(self._path_or_buf.read(b)) for _ in range(self._nvar)]
+
+    def _get_fmtlist(self) -> list[str]:
+        if self._format_version >= 118:
+            b = 57
+        elif self._format_version > 113:
+            b = 49
+        elif self._format_version > 104:
+            b = 12
+        else:
+            b = 7
+        return [self._decode(self._path_or_buf.read(b)) for _ in range(self._nvar)]
+
+    def _get_lbllist(self) -> list[str]:
+        if self._format_version >= 118:
+            b = 129
+        elif self._format_version > 108:
+            b = 33
+        else:
+            b = 9
+        return [self._decode(self._path_or_buf.read(b)) for _ in range(self._nvar)]
+
+    def _get_variable_labels(self) -> list[str]:
+        if self._format_version >= 118:
+            vlblist = [self._decode(self._path_or_buf.read(321)) for _ in range(self._nvar)]
+        elif self._format_version > 105:
+            vlblist = [self._decode(self._path_or_buf.read(81)) for _ in range(self._nvar)]
+        else:
+            vlblist = [self._decode(self._path_or_buf.read(32)) for _ in range(self._nvar)]
+        return vlblist
+
+    def _get_nobs(self) -> int:
+        if self._format_version >= 118:
+            return self._read_uint64()
+        elif self._format_version >= 103:
+            return self._read_uint32()
+        else:
+            return self._read_uint16()
+
+    def _get_data_label(self) -> str:
+        if self._format_version >= 118:
+            strlen = self._read_uint16()
+            return self._decode(self._path_or_buf.read(strlen))
+        elif self._format_version == 117:
+            strlen = self._read_int8()
+            return self._decode(self._path_or_buf.read(strlen))
+        elif self._format_version > 105:
+            return self._decode(self._path_or_buf.read(81))
+        else:
+            return self._decode(self._path_or_buf.read(32))
+
+    def _get_time_stamp(self) -> str:
+        if self._format_version >= 118:
+            strlen = self._read_int8()
+            return self._path_or_buf.read(strlen).decode('utf-8')
+        elif self._format_version == 117:
+            strlen = self._read_int8()
+            return self._decode(self._path_or_buf.read(strlen))
+        elif self._format_version > 104:
+            return self._decode(self._path_or_buf.read(18))
+        else:
+            raise ValueError
+
+    def _get_seek_variable_labels(self) -> int:
+        if self._format_version == 117:
+            self._path_or_buf.read(8)
+            return self._seek_value_label_names + 33 * self._nvar + 20 + 17
+        elif self._format_version >= 118:
+            return self._read_int64() + 17
+        else:
+            raise ValueError
+
+    def _read_old_header(self, first_char: bytes) -> None:
+        self._format_version = int(first_char[0])
+        if self._format_version not in [102, 103, 104, 105, 108, 110, 111, 113, 114, 115]:
+            raise ValueError(_version_error.format(version=self._format_version))
+        self._set_encoding()
+        self._byteorder = '>' if self._read_int8() == 1 else '<'
+        self._filetype = self._read_int8()
+        self._path_or_buf.read(1)
+        self._nvar = self._read_uint16()
+        self._nobs = self._get_nobs()
+        self._data_label = self._get_data_label()
+        if self._format_version >= 105:
+            self._time_stamp = self._get_time_stamp()
+        if self._format_version >= 111:
+            typlist = [int(c) for c in self._path_or_buf.read(self._nvar)]
+        else:
+            buf = self._path_or_buf.read(self._nvar)
+            typlistb = np.frombuffer(buf, dtype=np.uint8)
+            typlist = []
+            for tp in typlistb:
+                if tp in self.OLD_TYPE_MAPPING:
+                    typlist.append(self.OLD_TYPE_MAPPING[tp])
+                else:
+                    typlist.append(tp - 127)
+        try:
+            self._typlist = [self.TYPE_MAP[typ] for typ in typlist]
+        except ValueError as err:
+            invalid_types = ','.join([str(x) for x in typlist])
+            raise ValueError(f'cannot convert stata types [{invalid_types}]') from err
+        try:
+            self._dtyplist = [self.DTYPE_MAP[typ] for typ in typlist]
+        except ValueError as err:
+            invalid_dtypes = ','.join([str(x) for x in typlist])
+            raise ValueError(f'cannot convert stata dtypes [{invalid_dtypes}]') from err
+        if self._format_version > 108:
+            self._varlist = [self._decode(self._path_or_buf.read(33)) for _ in range(self._nvar)]
+        else:
+            self._varlist = [self._decode(self._path_or_buf.read(9)) for _ in range(self._nvar)]
+        self._srtlist = self._read_int16_count(self._nvar + 1)[:-1]
+        self._fmtlist = self._get_fmtlist()
+        self._lbllist = self._get_lbllist()
+        self._variable_labels = self._get_variable_labels()
+        if self._format_version > 104:
+            while True:
+                data_type = self._read_int8()
+                if self._format_version > 108:
+                    data_len = self._read_int32()
+                else:
+                    data_len = self._read_int16()
+                if data_type == 0:
+                    break
+                self._path_or_buf.read(data_len)
+        self._data_location = self._path_or_buf.tell()
+
+    def _setup_dtype(self) -> np.dtype:
+        if self._dtype is not None:
+            return self._dtype
+        dtypes = []
+        for (i, typ) in enumerate(self._typlist):
+            if typ in self.NUMPY_TYPE_MAP:
+                typ = cast(str, typ)
+                dtypes.append((f's{i}', f'{self._byteorder}{self.NUMPY_TYPE_MAP[typ]}'))
+            else:
+                dtypes.append((f's{i}', f'S{typ}'))
+        self._dtype = np.dtype(dtypes)
+        return self._dtype
+
+    def _decode(self, s: bytes) -> str:
+        s = s.partition(b'\x00')[0]
+        try:
+            return s.decode(self._encoding)
+        except UnicodeDecodeError:
+            encoding = self._encoding
+            msg = f'\nOne or more strings in the dta file could not be decoded using {encoding}, and\nso the fallback encoding of latin-1 is being used.  This can happen when a file\nhas been incorrectly encoded by Stata or some other software. You should verify\nthe string values returned are correct.'
+            warnings.warn(msg, UnicodeWarning, stacklevel=find_stack_level())
+            return s.decode('latin-1')
+
+    def _read_new_value_labels(self) -> None:
+        if self._format_version >= 117:
+            self._path_or_buf.seek(self._seek_value_labels)
+        else:
+            assert self._dtype is not None
+            offset = self._nobs * self._dtype.itemsize
+            self._path_or_buf.seek(self._data_location + offset)
+        while True:
+            if self._format_version >= 117:
+                if self._path_or_buf.read(5) == b'</val':
+                    break
+            slength = self._path_or_buf.read(4)
+            if not slength:
+                break
+            if self._format_version == 108:
+                labname = self._decode(self._path_or_buf.read(9))
+            elif self._format_version <= 117:
+                labname = self._decode(self._path_or_buf.read(33))
+            else:
+                labname = self._decode(self._path_or_buf.read(129))
+            self._path_or_buf.read(3)
+            n = self._read_uint32()
+            txtlen = self._read_uint32()
+            off = np.frombuffer(self._path_or_buf.read(4 * n), dtype=f'{self._byteorder}i4', count=n)
+            val = np.frombuffer(self._path_or_buf.read(4 * n), dtype=f'{self._byteorder}i4', count=n)
+            ii = np.argsort(off)
+            off = off[ii]
+            val = val[ii]
+            txt = self._path_or_buf.read(txtlen)
+            self._value_label_dict[labname] = {}
+            for i in range(n):
+                end = off[i + 1] if i < n - 1 else txtlen
+                self._value_label_dict[labname][val[i]] = self._decode(txt[off[i]:end])
+            if self._format_version >= 117:
+                self._path_or_buf.read(6)
+
+    def _read_old_value_labels(self) -> None:
+        assert self._dtype is not None
+        offset = self._nobs * self._dtype.itemsize
+        self._path_or_buf.seek(self._data_location + offset)
+        while True:
+            if not self._path_or_buf.read(2):
+                break
+            self._path_or_buf.seek(-2, os.SEEK_CUR)
+            n = self._read_uint16()
+            labname = self._decode(self._path_or_buf.read(9))
+            self._path_or_buf.read(1)
+            codes = np.frombuffer(self._path_or_buf.read(2 * n), dtype=f'{self._byteorder}i2', count=n)
+            self._value_label_dict[labname] = {}
+            for i in range(n):
+                self._value_label_dict[labname][codes[i]] = self._decode(self._path_or_buf.read(8))
+
+    def _read_value_labels(self) -> None:
+        self._ensure_open()
+        if self._value_labels_read:
+            return
+        if self._format_version >= 108:
+            self._read_new_value_labels()
+        else:
+            self._read_old_value_labels()
+        self._value_labels_read = True
+
+    def _read_strls(self) -> None:
+        self._path_or_buf.seek(self._seek_strls)
+        self.GSO = {'0': ''}
+        while True:
+            if self._path_or_buf.read(3) != b'GSO':
+                break
+            if self._format_version == 117:
+                v_o = self._read_uint64()
+            else:
+                buf = self._path_or_buf.read(12)
+                v_size = 2 if self._format_version == 118 else 3
+                if self._byteorder == '<':
+                    buf = buf[0:v_size] + buf[4:12 - v_size]
+                else:
+                    buf = buf[4 - v_size:4] + buf[4 + v_size:]
+                v_o = struct.unpack(f'{self._byteorder}Q', buf)[0]
+            typ = self._read_uint8()
+            length = self._read_uint32()
+            va = self._path_or_buf.read(length)
+            if typ == 130:
+                decoded_va = va[0:-1].decode(self._encoding)
+            else:
+                decoded_va = str(va)
+            self.GSO[str(v_o)] = decoded_va
+
+    def __next__(self) -> DataFrame:
+        self._using_iterator = True
+        return self.read(nrows=self._chunksize)
+
+    def get_chunk(self, size: int | None=None) -> DataFrame:
+        if size is None:
+            size = self._chunksize
+        return self.read(nrows=size)
+
+    @Appender(_read_method_doc)
+    def read(self, nrows: int | None=None, convert_dates: bool | None=None, convert_categoricals: bool | None=None, index_col: str | None=None, convert_missing: bool | None=None, preserve_dtypes: bool | None=None, columns: Sequence[str] | None=None, order_categoricals: bool | None=None) -> DataFrame:
+        self._ensure_open()
+        if convert_dates is None:
+            convert_dates = self._convert_dates
+        if convert_categoricals is None:
+            convert_categoricals = self._convert_categoricals
+        if convert_missing is None:
+            convert_missing = self._convert_missing
+        if preserve_dtypes is None:
+            preserve_dtypes = self._preserve_dtypes
+        if columns is None:
+            columns = self._columns
+        if order_categoricals is None:
+            order_categoricals = self._order_categoricals
+        if index_col is None:
+            index_col = self._index_col
+        if nrows is None:
+            nrows = self._nobs
+        if self._nobs == 0 and nrows == 0:
+            data = DataFrame(columns=self._varlist)
+            for (i, col) in enumerate(data.columns):
+                dt = self._dtyplist[i]
+                if isinstance(dt, np.dtype):
+                    if dt.char != 'S':
+                        data[col] = data[col].astype(dt)
+            if columns is not None:
+                data = self._do_select_columns(data, columns)
+            return data
+        if self._format_version >= 117 and (not self._value_labels_read):
+            self._read_strls()
+        assert self._dtype is not None
+        dtype = self._dtype
+        max_read_len = (self._nobs - self._lines_read) * dtype.itemsize
+        read_len = nrows * dtype.itemsize
+        read_len = min(read_len, max_read_len)
+        if read_len <= 0:
+            if convert_categoricals:
+                self._read_value_labels()
+            raise StopIteration
+        offset = self._lines_read * dtype.itemsize
+        self._path_or_buf.seek(self._data_location + offset)
+        read_lines = min(nrows, self._nobs - self._lines_read)
+        raw_data = np.frombuffer(self._path_or_buf.read(read_len), dtype=dtype, count=read_lines)
+        self._lines_read += read_lines
+        if self._byteorder != self._native_byteorder:
+            raw_data = raw_data.byteswap().view(raw_data.dtype.newbyteorder())
+        if convert_categoricals:
+            self._read_value_labels()
+        if len(raw_data) == 0:
+            data = DataFrame(columns=self._varlist)
+        else:
+            data = DataFrame.from_records(raw_data)
+            data.columns = Index(self._varlist)
+        if index_col is None:
+            data.index = RangeIndex(self._lines_read - read_lines, self._lines_read)
+        if columns is not None:
+            data = self._do_select_columns(data, columns)
+        for (col, typ) in zip(data, self._typlist):
+            if isinstance(typ, int):
+                data[col] = data[col].apply(self._decode)
+        data = self._insert_strls(data)
+        valid_dtypes = [i for (i, dtyp) in enumerate(self._dtyplist) if dtyp is not None]
+        object_type = np.dtype(object)
+        for idx in valid_dtypes:
+            dtype = data.iloc[:, idx].dtype
+            if dtype not in (object_type, self._dtyplist[idx]):
+                data.isetitem(idx, data.iloc[:, idx].astype(dtype))
+        data = self._do_convert_missing(data, convert_missing)
+        if convert_dates:
+            for (i, fmt) in enumerate(self._fmtlist):
+                if any((fmt.startswith(date_fmt) for date_fmt in _date_formats)):
+                    data.isetitem(i, _stata_elapsed_date_to_datetime_vec(data.iloc[:, i], fmt))
+        if convert_categoricals:
+            data = self._do_convert_categoricals(data, self._value_label_dict, self._lbllist, order_categoricals)
+        if not preserve_dtypes:
+            retyped_data = []
+            convert = False
+            for col in data:
+                dtype = data[col].dtype
+                if dtype in (np.dtype(np.float16), np.dtype(np.float32)):
+                    dtype = np.dtype(np.float64)
+                    convert = True
+                elif dtype in (np.dtype(np.int8), np.dtype(np.int16), np.dtype(np.int32)):
+                    dtype = np.dtype(np.int64)
+                    convert = True
+                retyped_data.append((col, data[col].astype(dtype)))
+            if convert:
+                data = DataFrame.from_dict(dict(retyped_data))
+        if index_col is not None:
+            data = data.set_index(data.pop(index_col))
+        return data
+
+    def _do_convert_missing(self, data: DataFrame, convert_missing: bool) -> DataFrame:
+        old_missingdouble = float.fromhex('0x1.0p333')
+        replacements = {}
+        for i in range(len(data.columns)):
+            fmt = self._typlist[i]
+            if self._format_version <= 105 and fmt == 'd':
+                data.iloc[:, i] = data.iloc[:, i].replace(old_missingdouble, self.MISSING_VALUES['d'])
+            if self._format_version <= 111:
+                if fmt not in self.OLD_VALID_RANGE:
+                    continue
+                fmt = cast(str, fmt)
+                (nmin, nmax) = self.OLD_VALID_RANGE[fmt]
+            else:
+                if fmt not in self.VALID_RANGE:
+                    continue
+                fmt = cast(str, fmt)
+                (nmin, nmax) = self.VALID_RANGE[fmt]
+            series = data.iloc[:, i]
+            svals = series._values
+            missing = (svals < nmin) | (svals > nmax)
+            if not missing.any():
+                continue
+            if convert_missing:
+                missing_loc = np.nonzero(np.asarray(missing))[0]
+                (umissing, umissing_loc) = np.unique(series[missing], return_inverse=True)
+                replacement = Series(series, dtype=object)
+                for (j, um) in enumerate(umissing):
+                    if self._format_version <= 111:
+                        missing_value = StataMissingValue(float(self.MISSING_VALUES[fmt]))
+                    else:
+                        missing_value = StataMissingValue(um)
+                    loc = missing_loc[umissing_loc == j]
+                    replacement.iloc[loc] = missing_value
+            else:
+                dtype = series.dtype
+                if dtype not in (np.float32, np.float64):
+                    dtype = np.float64
+                replacement = Series(series, dtype=dtype)
+                replacement._values[missing] = np.nan
+            replacements[i] = replacement
+        if replacements:
+            for (idx, value) in replacements.items():
+                data.isetitem(idx, value)
+        return data
+
+    def _insert_strls(self, data: DataFrame) -> DataFrame:
+        if not hasattr(self, 'GSO') or len(self.GSO) == 0:
+            return data
+        for (i, typ) in enumerate(self._typlist):
+            if typ != 'Q':
+                continue
+            data.isetitem(i, [self.GSO[str(k)] for k in data.iloc[:, i]])
+        return data
+
+    def _do_select_columns(self, data: DataFrame, columns: Sequence[str]) -> DataFrame:
+        if not self._column_selector_set:
+            column_set = set(columns)
+            if len(column_set) != len(columns):
+                raise ValueError('columns contains duplicate entries')
+            unmatched = column_set.difference(data.columns)
+            if unmatched:
+                joined = ', '.join(list(unmatched))
+                raise ValueError(f'The following columns were not found in the Stata data set: {joined}')
+            dtyplist = []
+            typlist = []
+            fmtlist = []
+            lbllist = []
+            for col in columns:
+                i = data.columns.get_loc(col)
+                dtyplist.append(self._dtyplist[i])
+                typlist.append(self._typlist[i])
+                fmtlist.append(self._fmtlist[i])
+                lbllist.append(self._lbllist[i])
+            self._dtyplist = dtyplist
+            self._typlist = typlist
+            self._fmtlist = fmtlist
+            self._lbllist = lbllist
+            self._column_selector_set = True
+        return data[columns]
+
+    def _do_convert_categoricals(self, data: DataFrame, value_label_dict: dict[str, dict[int, str]], lbllist: Sequence[str], order_categoricals: bool) -> DataFrame:
+        if not value_label_dict:
+            return data
+        cat_converted_data = []
+        for (col, label) in zip(data, lbllist):
+            if label in value_label_dict:
+                vl = value_label_dict[label]
+                keys = np.array(list(vl.keys()))
+                column = data[col]
+                key_matches = column.isin(keys)
+                if self._using_iterator and key_matches.all():
+                    initial_categories: np.ndarray | None = keys
+                else:
+                    if self._using_iterator:
+                        warnings.warn(categorical_conversion_warning, CategoricalConversionWarning, stacklevel=find_stack_level())
+                    initial_categories = None
+                cat_data = Categorical(column, categories=initial_categories, ordered=order_categoricals)
+                if initial_categories is None:
+                    categories = []
+                    for category in cat_data.categories:
+                        if category in vl:
+                            categories.append(vl[category])
+                        else:
+                            categories.append(category)
+                else:
+                    categories = list(vl.values())
+                try:
+                    cat_data = cat_data.rename_categories(categories)
+                except ValueError as err:
+                    vc = Series(categories, copy=False).value_counts()
+                    repeated_cats = list(vc.index[vc > 1])
+                    repeats = '-' * 80 + '\n' + '\n'.join(repeated_cats)
+                    msg = f'\nValue labels for column {col} are not unique. These cannot be converted to\npandas categoricals.\n\nEither read the file with `convert_categoricals` set to False or use the\nlow level interface in `StataReader` to separately read the values and the\nvalue_labels.\n\nThe repeated labels are:\n{repeats}\n'
+                    raise ValueError(msg) from err
+                cat_series = Series(cat_data, index=data.index, copy=False)
+                cat_converted_data.append((col, cat_series))
+            else:
+                cat_converted_data.append((col, data[col]))
+        data = DataFrame(dict(cat_converted_data), copy=False)
+        return data
+
+    @property
+    def data_label(self) -> str:
+        self._ensure_open()
+        return self._data_label
+
+    @property
+    def time_stamp(self) -> str:
+        self._ensure_open()
+        return self._time_stamp
+
+    def variable_labels(self) -> dict[str, str]:
+        self._ensure_open()
+        return dict(zip(self._varlist, self._variable_labels))
+
+    def value_labels(self) -> dict[str, dict[int, str]]:
+        if not self._value_labels_read:
+            self._read_value_labels()
+        return self._value_label_dict
+
+@Appender(_read_stata_doc)
+def read_stata(filepath_or_buffer: FilePath | ReadBuffer[bytes], *, convert_dates: bool=True, convert_categoricals: bool=True, index_col: str | None=None, convert_missing: bool=False, preserve_dtypes: bool=True, columns: Sequence[str] | None=None, order_categoricals: bool=True, chunksize: int | None=None, iterator: bool=False, compression: CompressionOptions='infer', storage_options: StorageOptions | None=None) -> DataFrame | StataReader:
+    reader = StataReader(filepath_or_buffer, convert_dates=convert_dates, convert_categoricals=convert_categoricals, index_col=index_col, convert_missing=convert_missing, preserve_dtypes=preserve_dtypes, columns=columns, order_categoricals=order_categoricals, chunksize=chunksize, storage_options=storage_options, compression=compression)
+    if iterator or chunksize:
+        return reader
+    with reader:
+        return reader.read()
+
+def _set_endianness(endianness: str) -> str:
+    if endianness.lower() in ['<', 'little']:
+        return '<'
+    elif endianness.lower() in ['>', 'big']:
+        return '>'
+    else:
+        raise ValueError(f'Endianness {endianness} not understood')
+
+def _pad_bytes(name: AnyStr, length: int) -> AnyStr:
+    if isinstance(name, bytes):
+        return name + b'\x00' * (length - len(name))
+    return name + '\x00' * (length - len(name))
+
+def _convert_datetime_to_stata_type(fmt: str) -> np.dtype:
+    if fmt in ['tc', '%tc', 'td', '%td', 'tw', '%tw', 'tm', '%tm', 'tq', '%tq', 'th', '%th', 'ty', '%ty']:
+        return np.dtype(np.float64)
+    else:
+        raise NotImplementedError(f'Format {fmt} not implemented')
+
+def _maybe_convert_to_int_keys(convert_dates: dict, varlist: list[Hashable]) -> dict:
+    new_dict = {}
+    for key in convert_dates:
+        if not convert_dates[key].startswith('%'):
+            convert_dates[key] = '%' + convert_dates[key]
+        if key in varlist:
+            new_dict.update({varlist.index(key): convert_dates[key]})
+        else:
+            if not isinstance(key, int):
+                raise ValueError('convert_dates key must be a column or an integer')
+            new_dict.update({key: convert_dates[key]})
+    return new_dict
+
+def _dtype_to_stata_type(dtype: np.dtype, column: Series) -> int:
+    if dtype.type is np.object_:
+        itemsize = max_len_string_array(ensure_object(column._values))
+        return max(itemsize, 1)
+    elif dtype.type is np.float64:
+        return 255
+    elif dtype.type is np.float32:
+        return 254
+    elif dtype.type is np.int32:
+        return 253
+    elif dtype.type is np.int16:
+        return 252
+    elif dtype.type is np.int8:
+        return 251
+    else:
+        raise NotImplementedError(f'Data type {dtype} not supported.')
+
+def _dtype_to_default_stata_fmt(dtype: np.dtype, column: Series, dta_version: int=114, force_strl: bool=False) -> str:
+    if dta_version < 117:
+        max_str_len = 244
+    else:
+        max_str_len = 2045
+        if force_strl:
+            return '%9s'
+    if dtype.type is np.object_:
+        itemsize = max_len_string_array(ensure_object(column._values))
+        if itemsize > max_str_len:
+            if dta_version >= 117:
+                return '%9s'
+            else:
+                raise ValueError(excessive_string_length_error.format(column.name))
+        return '%' + str(max(itemsize, 1)) + 's'
+    elif dtype == np.float64:
+        return '%10.0g'
+    elif dtype == np.float32:
+        return '%9.0g'
+    elif dtype == np.int32:
+        return '%12.0g'
+    elif dtype in (np.int8, np.int16):
+        return '%8.0g'
+    else:
+        raise NotImplementedError(f'Data type {dtype} not supported.')
+
+@doc(storage_options=_shared_docs['storage_options'], compression_options=_shared_docs['compression_options'] % 'fname')
+class StataWriter(StataParser):
+    _max_string_length = 244
+    _encoding: Literal['latin-1', 'utf-8'] = 'latin-1'
+
+    def __init__(self, fname: FilePath | WriteBuffer[bytes], data: DataFrame, convert_dates: dict[Hashable, str] | None=None, write_index: bool=True, byteorder: str | None=None, time_stamp: datetime | None=None, data_label: str | None=None, variable_labels: dict[Hashable, str] | None=None, compression: CompressionOptions='infer', storage_options: StorageOptions | None=None, *, value_labels: dict[Hashable, dict[float, str]] | None=None) -> None:
+        super().__init__()
+        self.data = data
+        self._convert_dates = {} if convert_dates is None else convert_dates
+        self._write_index = write_index
+        self._time_stamp = time_stamp
+        self._data_label = data_label
+        self._variable_labels = variable_labels
+        self._non_cat_value_labels = value_labels
+        self._value_labels: list[StataValueLabel] = []
+        self._has_value_labels = np.array([], dtype=bool)
+        self._compression = compression
+        self._output_file: IO[bytes] | None = None
+        self._converted_names: dict[Hashable, str] = {}
+        self._prepare_pandas(data)
+        self.storage_options = storage_options
+        if byteorder is None:
+            byteorder = sys.byteorder
+        self._byteorder = _set_endianness(byteorder)
+        self._fname = fname
+        self.type_converters = {253: np.int32, 252: np.int16, 251: np.int8}
+
+    def _write(self, to_write: str) -> None:
+        self.handles.handle.write(to_write.encode(self._encoding))
+
+    def _write_bytes(self, value: bytes) -> None:
+        self.handles.handle.write(value)
+
+    def _prepare_non_cat_value_labels(self, data: DataFrame) -> list[StataNonCatValueLabel]:
+        non_cat_value_labels: list[StataNonCatValueLabel] = []
+        if self._non_cat_value_labels is None:
+            return non_cat_value_labels
+        for (labname, labels) in self._non_cat_value_labels.items():
+            if labname in self._converted_names:
+                colname = self._converted_names[labname]
+            elif labname in data.columns:
+                colname = str(labname)
+            else:
+                raise KeyError(f"Can't create value labels for {labname}, it wasn't found in the dataset.")
+            if not is_numeric_dtype(data[colname].dtype):
+                raise ValueError(f"Can't create value labels for {labname}, value labels can only be applied to numeric columns.")
+            svl = StataNonCatValueLabel(colname, labels, self._encoding)
+            non_cat_value_labels.append(svl)
+        return non_cat_value_labels
+
+    def _prepare_categoricals(self, data: DataFrame) -> DataFrame:
+        is_cat = [isinstance(dtype, CategoricalDtype) for dtype in data.dtypes]
+        if not any(is_cat):
+            return data
+        self._has_value_labels |= np.array(is_cat)
+        get_base_missing_value = StataMissingValue.get_base_missing_value
+        data_formatted = []
+        for (col, col_is_cat) in zip(data, is_cat):
+            if col_is_cat:
+                svl = StataValueLabel(data[col], encoding=self._encoding)
+                self._value_labels.append(svl)
+                dtype = data[col].cat.codes.dtype
+                if dtype == np.int64:
+                    raise ValueError('It is not possible to export int64-based categorical data to Stata.')
+                values = data[col].cat.codes._values.copy()
+                if values.max() >= get_base_missing_value(dtype):
+                    if dtype == np.int8:
+                        dtype = np.dtype(np.int16)
+                    elif dtype == np.int16:
+                        dtype = np.dtype(np.int32)
+                    else:
+                        dtype = np.dtype(np.float64)
+                    values = np.array(values, dtype=dtype)
+                values[values == -1] = get_base_missing_value(dtype)
+                data_formatted.append((col, values))
+            else:
+                data_formatted.append((col, data[col]))
+        return DataFrame.from_dict(dict(data_formatted))
+
+    def _replace_nans(self, data: DataFrame) -> DataFrame:
+        for c in data:
+            dtype = data[c].dtype
+            if dtype in (np.float32, np.float64):
+                if dtype == np.float32:
+                    replacement = self.MISSING_VALUES['f']
+                else:
+                    replacement = self.MISSING_VALUES['d']
+                data[c] = data[c].fillna(replacement)
+        return data
+
+    def _update_strl_names(self) -> None:
+
+    def _validate_variable_name(self, name: str) -> str:
+        for c in name:
+            if (c < 'A' or c > 'Z') and (c < 'a' or c > 'z') and (c < '0' or c > '9') and (c != '_'):
+                name = name.replace(c, '_')
+        return name
+
+    def _check_column_names(self, data: DataFrame) -> DataFrame:
+        converted_names: dict[Hashable, str] = {}
+        columns = list(data.columns)
+        original_columns = columns[:]
+        duplicate_var_id = 0
+        for (j, name) in enumerate(columns):
+            orig_name = name
+            if not isinstance(name, str):
+                name = str(name)
+            name = self._validate_variable_name(name)
+            if name in self.RESERVED_WORDS:
+                name = '_' + name
+            if '0' <= name[0] <= '9':
+                name = '_' + name
+            name = name[:min(len(name), 32)]
+            if not name == orig_name:
+                while columns.count(name) > 0:
+                    name = '_' + str(duplicate_var_id) + name
+                    name = name[:min(len(name), 32)]
+                    duplicate_var_id += 1
+                converted_names[orig_name] = name
+            columns[j] = name
+        data.columns = Index(columns)
+        if self._convert_dates:
+            for (c, o) in zip(columns, original_columns):
+                if c != o:
+                    self._convert_dates[c] = self._convert_dates[o]
+                    del self._convert_dates[o]
+        if converted_names:
+            conversion_warning = []
+            for (orig_name, name) in converted_names.items():
+                msg = f'{orig_name}   ->   {name}'
+                conversion_warning.append(msg)
+            ws = invalid_name_doc.format('\n    '.join(conversion_warning))
+            warnings.warn(ws, InvalidColumnName, stacklevel=find_stack_level())
+        self._converted_names = converted_names
+        self._update_strl_names()
+        return data
+
+    def _set_formats_and_types(self, dtypes: Series) -> None:
+        self.fmtlist: list[str] = []
+        self.typlist: list[int] = []
+        for (col, dtype) in dtypes.items():
+            self.fmtlist.append(_dtype_to_default_stata_fmt(dtype, self.data[col]))
+            self.typlist.append(_dtype_to_stata_type(dtype, self.data[col]))
+
+    def _prepare_pandas(self, data: DataFrame) -> None:
+        data = data.copy()
+        if self._write_index:
+            temp = data.reset_index()
+            if isinstance(temp, DataFrame):
+                data = temp
+        data = self._check_column_names(data)
+        data = _cast_to_stata_types(data)
+        data = self._replace_nans(data)
+        self._has_value_labels = np.repeat(False, data.shape[1])
+        non_cat_value_labels = self._prepare_non_cat_value_labels(data)
+        non_cat_columns = [svl.labname for svl in non_cat_value_labels]
+        has_non_cat_val_labels = data.columns.isin(non_cat_columns)
+        self._has_value_labels |= has_non_cat_val_labels
+        self._value_labels.extend(non_cat_value_labels)
+        data = self._prepare_categoricals(data)
+        (self.nobs, self.nvar) = data.shape
+        self.data = data
+        self.varlist = data.columns.tolist()
+        dtypes = data.dtypes
+        for col in data:
+            if col in self._convert_dates:
+                continue
+            if lib.is_np_dtype(data[col].dtype, 'M'):
+                self._convert_dates[col] = 'tc'
+        self._convert_dates = _maybe_convert_to_int_keys(self._convert_dates, self.varlist)
+        for key in self._convert_dates:
+            new_type = _convert_datetime_to_stata_type(self._convert_dates[key])
+            dtypes.iloc[key] = np.dtype(new_type)
+        self._encode_strings()
+        self._set_formats_and_types(dtypes)
+        if self._convert_dates is not None:
+            for key in self._convert_dates:
+                if isinstance(key, int):
+                    self.fmtlist[key] = self._convert_dates[key]
+
+    def _encode_strings(self) -> None:
+        convert_dates = self._convert_dates
+        convert_strl = getattr(self, '_convert_strl', [])
+        for (i, col) in enumerate(self.data):
+            if i in convert_dates or col in convert_strl:
+                continue
+            column = self.data[col]
+            dtype = column.dtype
+            if dtype.type is np.object_:
+                inferred_dtype = infer_dtype(column, skipna=True)
+                if not (inferred_dtype == 'string' or len(column) == 0):
+                    col = column.name
+                    raise ValueError(f'Column `{col}` cannot be exported.\n\nOnly string-like object arrays\ncontaining all strings or a mix of strings and None can be exported.\nObject arrays containing only null values are prohibited. Other object\ntypes cannot be exported and must first be converted to one of the\nsupported types.')
+                encoded = self.data[col].str.encode(self._encoding)
+                if max_len_string_array(ensure_object(encoded._values)) <= self._max_string_length:
+                    self.data[col] = encoded
+
+    def write_file(self) -> None:
+        with get_handle(self._fname, 'wb', compression=self._compression, is_text=False, storage_options=self.storage_options) as self.handles:
+            if self.handles.compression['method'] is not None:
+                (self._output_file, self.handles.handle) = (self.handles.handle, BytesIO())
+                self.handles.created_handles.append(self.handles.handle)
+            try:
+                self._write_header(data_label=self._data_label, time_stamp=self._time_stamp)
+                self._write_map()
+                self._write_variable_types()
+                self._write_varnames()
+                self._write_sortlist()
+                self._write_formats()
+                self._write_value_label_names()
+                self._write_variable_labels()
+                self._write_expansion_fields()
+                self._write_characteristics()
+                records = self._prepare_data()
+                self._write_data(records)
+                self._write_strls()
+                self._write_value_labels()
+                self._write_file_close_tag()
+                self._write_map()
+                self._close()
+            except Exception as exc:
+                self.handles.close()
+                if isinstance(self._fname, (str, os.PathLike)) and os.path.isfile(self._fname):
+                    try:
+                        os.unlink(self._fname)
+                    except OSError:
+                        warnings.warn(f'This save was not successful but {self._fname} could not be deleted. This file is not valid.', ResourceWarning, stacklevel=find_stack_level())
+                raise exc
+
+    def _close(self) -> None:
+        if self._output_file is not None:
+            assert isinstance(self.handles.handle, BytesIO)
+            (bio, self.handles.handle) = (self.handles.handle, self._output_file)
+            self.handles.handle.write(bio.getvalue())
+
+    def _write_map(self) -> None:
+
+    def _write_file_close_tag(self) -> None:
+
+    def _write_characteristics(self) -> None:
+
+    def _write_strls(self) -> None:
+
+    def _write_expansion_fields(self) -> None:
+        self._write(_pad_bytes('', 5))
+
+    def _write_value_labels(self) -> None:
+        for vl in self._value_labels:
+            self._write_bytes(vl.generate_value_label(self._byteorder))
+
+    def _write_header(self, data_label: str | None=None, time_stamp: datetime | None=None) -> None:
+        byteorder = self._byteorder
+        self._write_bytes(struct.pack('b', 114))
+        self._write(byteorder == '>' and '\x01' or '\x02')
+        self._write('\x01')
+        self._write('\x00')
+        self._write_bytes(struct.pack(byteorder + 'h', self.nvar)[:2])
+        self._write_bytes(struct.pack(byteorder + 'i', self.nobs)[:4])
+        if data_label is None:
+            self._write_bytes(self._null_terminate_bytes(_pad_bytes('', 80)))
+        else:
+            self._write_bytes(self._null_terminate_bytes(_pad_bytes(data_label[:80], 80)))
+        if time_stamp is None:
+            time_stamp = datetime.now()
+        elif not isinstance(time_stamp, datetime):
+            raise ValueError('time_stamp should be datetime type')
+        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+        month_lookup = {i + 1: month for (i, month) in enumerate(months)}
+        ts = time_stamp.strftime('%d ') + month_lookup[time_stamp.month] + time_stamp.strftime(' %Y %H:%M')
+        self._write_bytes(self._null_terminate_bytes(ts))
+
+    def _write_variable_types(self) -> None:
+        for typ in self.typlist:
+            self._write_bytes(struct.pack('B', typ))
+
+    def _write_varnames(self) -> None:
+        for name in self.varlist:
+            name = self._null_terminate_str(name)
+            name = _pad_bytes(name[:32], 33)
+            self._write(name)
+
+    def _write_sortlist(self) -> None:
+        srtlist = _pad_bytes('', 2 * (self.nvar + 1))
+        self._write(srtlist)
+
+    def _write_formats(self) -> None:
+        for fmt in self.fmtlist:
+            self._write(_pad_bytes(fmt, 49))
+
+    def _write_value_label_names(self) -> None:
+        for i in range(self.nvar):
+            if self._has_value_labels[i]:
+                name = self.varlist[i]
+                name = self._null_terminate_str(name)
+                name = _pad_bytes(name[:32], 33)
+                self._write(name)
+            else:
+                self._write(_pad_bytes('', 33))
+
+    def _write_variable_labels(self) -> None:
+        blank = _pad_bytes('', 81)
+        if self._variable_labels is None:
+            for i in range(self.nvar):
+                self._write(blank)
+            return
+        for col in self.data:
+            if col in self._variable_labels:
+                label = self._variable_labels[col]
+                if len(label) > 80:
+                    raise ValueError('Variable labels must be 80 characters or fewer')
+                is_latin1 = all((ord(c) < 256 for c in label))
+                if not is_latin1:
+                    raise ValueError('Variable labels must contain only characters that can be encoded in Latin-1')
+                self._write(_pad_bytes(label, 81))
+            else:
+                self._write(blank)
+
+    def _convert_strls(self, data: DataFrame) -> DataFrame:
+        return data
+
+    def _prepare_data(self) -> np.rec.recarray:
+        data = self.data
+        typlist = self.typlist
+        convert_dates = self._convert_dates
+        if self._convert_dates is not None:
+            for (i, col) in enumerate(data):
+                if i in convert_dates:
+                    data[col] = _datetime_to_stata_elapsed_vec(data[col], self.fmtlist[i])
+        data = self._convert_strls(data)
+        dtypes = {}
+        native_byteorder = self._byteorder == _set_endianness(sys.byteorder)
+        for (i, col) in enumerate(data):
+            typ = typlist[i]
+            if typ <= self._max_string_length:
+                dc = data[col].fillna('')
+                data[col] = dc.apply(_pad_bytes, args=(typ,))
+                stype = f'S{typ}'
+                dtypes[col] = stype
+                data[col] = data[col].astype(stype)
+            else:
+                dtype = data[col].dtype
+                if not native_byteorder:
+                    dtype = dtype.newbyteorder(self._byteorder)
+                dtypes[col] = dtype
+        return data.to_records(index=False, column_dtypes=dtypes)
+
+    def _write_data(self, records: np.rec.recarray) -> None:
+        self._write_bytes(records.tobytes())
+
+    @staticmethod
+    def _null_terminate_str(s: str) -> str:
+        s += '\x00'
+        return s
+
+    def _null_terminate_bytes(self, s: str) -> bytes:
+        return self._null_terminate_str(s).encode(self._encoding)
+
+def _dtype_to_stata_type_117(dtype: np.dtype, column: Series, force_strl: bool) -> int:
+    if force_strl:
+        return 32768
+    if dtype.type is np.object_:
+        itemsize = max_len_string_array(ensure_object(column._values))
+        itemsize = max(itemsize, 1)
+        if itemsize <= 2045:
+            return itemsize
+        return 32768
+    elif dtype.type is np.float64:
+        return 65526
+    elif dtype.type is np.float32:
+        return 65527
+    elif dtype.type is np.int32:
+        return 65528
+    elif dtype.type is np.int16:
+        return 65529
+    elif dtype.type is np.int8:
+        return 65530
+    else:
+        raise NotImplementedError(f'Data type {dtype} not supported.')
+
+def _pad_bytes_new(name: str | bytes, length: int) -> bytes:
+    if isinstance(name, str):
+        name = bytes(name, 'utf-8')
+    return name + b'\x00' * (length - len(name))
+
+class StataStrLWriter:
+
+    def __init__(self, df: DataFrame, columns: Sequence[str], version: int=117, byteorder: str | None=None) -> None:
+        if version not in (117, 118, 119):
+            raise ValueError('Only dta versions 117, 118 and 119 supported')
+        self._dta_ver = version
+        self.df = df
+        self.columns = columns
+        self._gso_table = {'': (0, 0)}
+        if byteorder is None:
+            byteorder = sys.byteorder
+        self._byteorder = _set_endianness(byteorder)
+        self._native_byteorder = self._byteorder == _set_endianness(sys.byteorder)
+        gso_v_type = 'I'
+        gso_o_type = 'Q'
+        self._encoding = 'utf-8'
+        if version == 117:
+            o_size = 4
+            gso_o_type = 'I'
+            self._encoding = 'latin-1'
+        elif version == 118:
+            o_size = 6
+        else:
+            o_size = 5
+        if self._native_byteorder:
+            self._o_offet = 2 ** (8 * (8 - o_size))
+        else:
+            self._o_offet = 2 ** (8 * o_size)
+        self._gso_o_type = gso_o_type
+        self._gso_v_type = gso_v_type
+
+    def _convert_key(self, key: tuple[int, int]) -> int:
+        (v, o) = key
+        if self._native_byteorder:
+            return v + self._o_offet * o
+        else:
+            return o + self._o_offet * v
+
+    def generate_table(self) -> tuple[dict[str, tuple[int, int]], DataFrame]:
+        gso_table = self._gso_table
+        gso_df = self.df
+        columns = list(gso_df.columns)
+        selected = gso_df[self.columns]
+        col_index = [(col, columns.index(col)) for col in self.columns]
+        keys = np.empty(selected.shape, dtype=np.uint64)
+        for (o, (idx, row)) in enumerate(selected.iterrows()):
+            for (j, (col, v)) in enumerate(col_index):
+                val = row[col]
+                val = '' if val is None else val
+                key = gso_table.get(val, None)
+                if key is None:
+                    key = (v + 1, o + 1)
+                    gso_table[val] = key
+                keys[o, j] = self._convert_key(key)
+        for (i, col) in enumerate(self.columns):
+            gso_df[col] = keys[:, i]
+        return (gso_table, gso_df)
+
+    def generate_blob(self, gso_table: dict[str, tuple[int, int]]) -> bytes:
+        bio = BytesIO()
+        gso = bytes('GSO', 'ascii')
+        gso_type = struct.pack(self._byteorder + 'B', 130)
+        null = struct.pack(self._byteorder + 'B', 0)
+        v_type = self._byteorder + self._gso_v_type
+        o_type = self._byteorder + self._gso_o_type
+        len_type = self._byteorder + 'I'
+        for (strl, vo) in gso_table.items():
+            if vo == (0, 0):
+                continue
+            (v, o) = vo
+            bio.write(gso)
+            bio.write(struct.pack(v_type, v))
+            bio.write(struct.pack(o_type, o))
+            bio.write(gso_type)
+            utf8_string = bytes(strl, 'utf-8')
+            bio.write(struct.pack(len_type, len(utf8_string) + 1))
+            bio.write(utf8_string)
+            bio.write(null)
+        return bio.getvalue()
+
+class StataWriter117(StataWriter):
+    _max_string_length = 2045
+    _dta_version = 117
+
+    def __init__(self, fname: FilePath | WriteBuffer[bytes], data: DataFrame, convert_dates: dict[Hashable, str] | None=None, write_index: bool=True, byteorder: str | None=None, time_stamp: datetime | None=None, data_label: str | None=None, variable_labels: dict[Hashable, str] | None=None, convert_strl: Sequence[Hashable] | None=None, compression: CompressionOptions='infer', storage_options: StorageOptions | None=None, *, value_labels: dict[Hashable, dict[float, str]] | None=None) -> None:
+        self._convert_strl: list[Hashable] = []
+        if convert_strl is not None:
+            self._convert_strl.extend(convert_strl)
+        super().__init__(fname, data, convert_dates, write_index, byteorder=byteorder, time_stamp=time_stamp, data_label=data_label, variable_labels=variable_labels, value_labels=value_labels, compression=compression, storage_options=storage_options)
+        self._map: dict[str, int] = {}
+        self._strl_blob = b''
+
+    @staticmethod
+    def _tag(val: str | bytes, tag: str) -> bytes:
+        if isinstance(val, str):
+            val = bytes(val, 'utf-8')
+        return bytes('<' + tag + '>', 'utf-8') + val + bytes('</' + tag + '>', 'utf-8')
+
+    def _update_map(self, tag: str) -> None:
+        assert self.handles.handle is not None
+        self._map[tag] = self.handles.handle.tell()
+
+    def _write_header(self, data_label: str | None=None, time_stamp: datetime | None=None) -> None:
+        byteorder = self._byteorder
+        self._write_bytes(bytes('<stata_dta>', 'utf-8'))
+        bio = BytesIO()
+        bio.write(self._tag(bytes(str(self._dta_version), 'utf-8'), 'release'))
+        bio.write(self._tag(byteorder == '>' and 'MSF' or 'LSF', 'byteorder'))
+        nvar_type = 'H' if self._dta_version <= 118 else 'I'
+        bio.write(self._tag(struct.pack(byteorder + nvar_type, self.nvar), 'K'))
+        nobs_size = 'I' if self._dta_version == 117 else 'Q'
+        bio.write(self._tag(struct.pack(byteorder + nobs_size, self.nobs), 'N'))
+        label = data_label[:80] if data_label is not None else ''
+        encoded_label = label.encode(self._encoding)
+        label_size = 'B' if self._dta_version == 117 else 'H'
+        label_len = struct.pack(byteorder + label_size, len(encoded_label))
+        encoded_label = label_len + encoded_label
+        bio.write(self._tag(encoded_label, 'label'))
+        if time_stamp is None:
+            time_stamp = datetime.now()
+        elif not isinstance(time_stamp, datetime):
+            raise ValueError('time_stamp should be datetime type')
+        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+        month_lookup = {i + 1: month for (i, month) in enumerate(months)}
+        ts = time_stamp.strftime('%d ') + month_lookup[time_stamp.month] + time_stamp.strftime(' %Y %H:%M')
+        stata_ts = b'\x11' + bytes(ts, 'utf-8')
+        bio.write(self._tag(stata_ts, 'timestamp'))
+        self._write_bytes(self._tag(bio.getvalue(), 'header'))
+
+    def _write_map(self) -> None:
+        if not self._map:
+            self._map = {'stata_data': 0, 'map': self.handles.handle.tell(), 'variable_types': 0, 'varnames': 0, 'sortlist': 0, 'formats': 0, 'value_label_names': 0, 'variable_labels': 0, 'characteristics': 0, 'data': 0, 'strls': 0, 'value_labels': 0, 'stata_data_close': 0, 'end-of-file': 0}
+        self.handles.handle.seek(self._map['map'])
+        bio = BytesIO()
+        for val in self._map.values():
+            bio.write(struct.pack(self._byteorder + 'Q', val))
+        self._write_bytes(self._tag(bio.getvalue(), 'map'))
+
+    def _write_variable_types(self) -> None:
+        self._update_map('variable_types')
+        bio = BytesIO()
+        for typ in self.typlist:
+            bio.write(struct.pack(self._byteorder + 'H', typ))
+        self._write_bytes(self._tag(bio.getvalue(), 'variable_types'))
+
+    def _write_varnames(self) -> None:
+        self._update_map('varnames')
+        bio = BytesIO()
+        vn_len = 32 if self._dta_version == 117 else 128
+        for name in self.varlist:
+            name = self._null_terminate_str(name)
+            name = _pad_bytes_new(name[:32].encode(self._encoding), vn_len + 1)
+            bio.write(name)
+        self._write_bytes(self._tag(bio.getvalue(), 'varnames'))
+
+    def _write_sortlist(self) -> None:
+        self._update_map('sortlist')
+        sort_size = 2 if self._dta_version < 119 else 4
+        self._write_bytes(self._tag(b'\x00' * sort_size * (self.nvar + 1), 'sortlist'))
+
+    def _write_formats(self) -> None:
+        self._update_map('formats')
+        bio = BytesIO()
+        fmt_len = 49 if self._dta_version == 117 else 57
+        for fmt in self.fmtlist:
+            bio.write(_pad_bytes_new(fmt.encode(self._encoding), fmt_len))
+        self._write_bytes(self._tag(bio.getvalue(), 'formats'))
+
+    def _write_value_label_names(self) -> None:
+        self._update_map('value_label_names')
+        bio = BytesIO()
+        vl_len = 32 if self._dta_version == 117 else 128
+        for i in range(self.nvar):
+            name = ''
+            if self._has_value_labels[i]:
+                name = self.varlist[i]
+            name = self._null_terminate_str(name)
+            encoded_name = _pad_bytes_new(name[:32].encode(self._encoding), vl_len + 1)
+            bio.write(encoded_name)
+        self._write_bytes(self._tag(bio.getvalue(), 'value_label_names'))
+
+    def _write_variable_labels(self) -> None:
+        self._update_map('variable_labels')
+        bio = BytesIO()
+        vl_len = 80 if self._dta_version == 117 else 320
+        blank = _pad_bytes_new('', vl_len + 1)
+        if self._variable_labels is None:
+            for _ in range(self.nvar):
+                bio.write(blank)
+            self._write_bytes(self._tag(bio.getvalue(), 'variable_labels'))
+            return
+        for col in self.data:
+            if col in self._variable_labels:
+                label = self._variable_labels[col]
+                if len(label) > 80:
+                    raise ValueError('Variable labels must be 80 characters or fewer')
+                try:
+                    encoded = label.encode(self._encoding)
+                except UnicodeEncodeError as err:
+                    raise ValueError(f'Variable labels must contain only characters that can be encoded in {self._encoding}') from err
+                bio.write(_pad_bytes_new(encoded, vl_len + 1))
+            else:
+                bio.write(blank)
+        self._write_bytes(self._tag(bio.getvalue(), 'variable_labels'))
+
+    def _write_characteristics(self) -> None:
+        self._update_map('characteristics')
+        self._write_bytes(self._tag(b'', 'characteristics'))
+
+    def _write_data(self, records: np.rec.recarray) -> None:
+        self._update_map('data')
+        self._write_bytes(b'<data>')
+        self._write_bytes(records.tobytes())
+        self._write_bytes(b'</data>')
+
+    def _write_strls(self) -> None:
+        self._update_map('strls')
+        self._write_bytes(self._tag(self._strl_blob, 'strls'))
+
+    def _write_expansion_fields(self) -> None:
+
+    def _write_value_labels(self) -> None:
+        self._update_map('value_labels')
+        bio = BytesIO()
+        for vl in self._value_labels:
+            lab = vl.generate_value_label(self._byteorder)
+            lab = self._tag(lab, 'lbl')
+            bio.write(lab)
+        self._write_bytes(self._tag(bio.getvalue(), 'value_labels'))
+
+    def _write_file_close_tag(self) -> None:
+        self._update_map('stata_data_close')
+        self._write_bytes(bytes('</stata_dta>', 'utf-8'))
+        self._update_map('end-of-file')
+
+    def _update_strl_names(self) -> None:
+        for (orig, new) in self._converted_names.items():
+            if orig in self._convert_strl:
+                idx = self._convert_strl.index(orig)
+                self._convert_strl[idx] = new
+
+    def _convert_strls(self, data: DataFrame) -> DataFrame:
+        convert_cols = [col for (i, col) in enumerate(data) if self.typlist[i] == 32768 or col in self._convert_strl]
+        if convert_cols:
+            ssw = StataStrLWriter(data, convert_cols, version=self._dta_version, byteorder=self._byteorder)
+            (tab, new_data) = ssw.generate_table()
+            data = new_data
+            self._strl_blob = ssw.generate_blob(tab)
+        return data
+
+    def _set_formats_and_types(self, dtypes: Series) -> None:
+        self.typlist = []
+        self.fmtlist = []
+        for (col, dtype) in dtypes.items():
+            force_strl = col in self._convert_strl
+            fmt = _dtype_to_default_stata_fmt(dtype, self.data[col], dta_version=self._dta_version, force_strl=force_strl)
+            self.fmtlist.append(fmt)
+            self.typlist.append(_dtype_to_stata_type_117(dtype, self.data[col], force_strl))
+
+class StataWriterUTF8(StataWriter117):
+    _encoding: Literal['utf-8'] = 'utf-8'
+
+    def __init__(self, fname: FilePath | WriteBuffer[bytes], data: DataFrame, convert_dates: dict[Hashable, str] | None=None, write_index: bool=True, byteorder: str | None=None, time_stamp: datetime | None=None, data_label: str | None=None, variable_labels: dict[Hashable, str] | None=None, convert_strl: Sequence[Hashable] | None=None, version: int | None=None, compression: CompressionOptions='infer', storage_options: StorageOptions | None=None, *, value_labels: dict[Hashable, dict[float, str]] | None=None) -> None:
+        if version is None:
+            version = 118 if data.shape[1] <= 32767 else 119
+        elif version not in (118, 119):
+            raise ValueError('version must be either 118 or 119.')
+        elif version == 118 and data.shape[1] > 32767:
+            raise ValueError('You must use version 119 for data sets containing more than32,767 variables')
+        super().__init__(fname, data, convert_dates=convert_dates, write_index=write_index, byteorder=byteorder, time_stamp=time_stamp, data_label=data_label, variable_labels=variable_labels, value_labels=value_labels, convert_strl=convert_strl, compression=compression, storage_options=storage_options)
+        self._dta_version = version
+
+    def _validate_variable_name(self, name: str) -> str:
+        for c in name:
+            if ord(c) < 128 and (c < 'A' or c > 'Z') and (c < 'a' or c > 'z') and (c < '0' or c > '9') and (c != '_') or 128 <= ord(c) < 192 or c in {'×', '÷'}:
+                name = name.replace(c, '_')
+        return name
+
+# File: pandas-main/pandas/io/xml.py
+""""""
+from __future__ import annotations
+import io
+from os import PathLike
+from typing import TYPE_CHECKING, Any
+from pandas._libs import lib
+from pandas.compat._optional import import_optional_dependency
+from pandas.errors import AbstractMethodError, ParserError
+from pandas.util._decorators import doc
+from pandas.util._validators import check_dtype_backend
+from pandas.core.dtypes.common import is_list_like
+from pandas.core.shared_docs import _shared_docs
+from pandas.io.common import get_handle, infer_compression, is_fsspec_url, is_url, stringify_path
+from pandas.io.parsers import TextParser
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+    from xml.etree.ElementTree import Element
+    from lxml import etree
+    from pandas._typing import CompressionOptions, ConvertersArg, DtypeArg, DtypeBackend, FilePath, ParseDatesArg, ReadBuffer, StorageOptions, XMLParsers
+    from pandas import DataFrame
+
+@doc(storage_options=_shared_docs['storage_options'], decompression_options=_shared_docs['decompression_options'] % 'path_or_buffer')
+class _XMLFrameParser:
+
+    def __init__(self, path_or_buffer: FilePath | ReadBuffer[bytes] | ReadBuffer[str], xpath: str, namespaces: dict[str, str] | None, elems_only: bool, attrs_only: bool, names: Sequence[str] | None, dtype: DtypeArg | None, converters: ConvertersArg | None, parse_dates: ParseDatesArg | None, encoding: str | None, stylesheet: FilePath | ReadBuffer[bytes] | ReadBuffer[str] | None, iterparse: dict[str, list[str]] | None, compression: CompressionOptions, storage_options: StorageOptions) -> None:
+        self.path_or_buffer = path_or_buffer
+        self.xpath = xpath
+        self.namespaces = namespaces
+        self.elems_only = elems_only
+        self.attrs_only = attrs_only
+        self.names = names
+        self.dtype = dtype
+        self.converters = converters
+        self.parse_dates = parse_dates
+        self.encoding = encoding
+        self.stylesheet = stylesheet
+        self.iterparse = iterparse
+        self.compression: CompressionOptions = compression
+        self.storage_options = storage_options
+
+    def parse_data(self) -> list[dict[str, str | None]]:
+        raise AbstractMethodError(self)
+
+    def _parse_nodes(self, elems: list[Any]) -> list[dict[str, str | None]]:
+        dicts: list[dict[str, str | None]]
+        if self.elems_only and self.attrs_only:
+            raise ValueError('Either element or attributes can be parsed not both.')
+        if self.elems_only:
+            if self.names:
+                dicts = [{**({el.tag: el.text} if el.text and (not el.text.isspace()) else {}), **{nm: ch.text if ch.text else None for (nm, ch) in zip(self.names, el.findall('*'))}} for el in elems]
+            else:
+                dicts = [{ch.tag: ch.text if ch.text else None for ch in el.findall('*')} for el in elems]
+        elif self.attrs_only:
+            dicts = [{k: v if v else None for (k, v) in el.attrib.items()} for el in elems]
+        elif self.names:
+            dicts = [{**el.attrib, **({el.tag: el.text} if el.text and (not el.text.isspace()) else {}), **{nm: ch.text if ch.text else None for (nm, ch) in zip(self.names, el.findall('*'))}} for el in elems]
+        else:
+            dicts = [{**el.attrib, **({el.tag: el.text} if el.text and (not el.text.isspace()) else {}), **{ch.tag: ch.text if ch.text else None for ch in el.findall('*')}} for el in elems]
+        dicts = [{k.split('}')[1] if '}' in k else k: v for (k, v) in d.items()} for d in dicts]
+        keys = list(dict.fromkeys([k for d in dicts for k in d.keys()]))
+        dicts = [{k: d[k] if k in d.keys() else None for k in keys} for d in dicts]
+        if self.names:
+            dicts = [dict(zip(self.names, d.values())) for d in dicts]
+        return dicts
+
+    def _iterparse_nodes(self, iterparse: Callable) -> list[dict[str, str | None]]:
+        dicts: list[dict[str, str | None]] = []
+        row: dict[str, str | None] | None = None
+        if not isinstance(self.iterparse, dict):
+            raise TypeError(f'{type(self.iterparse).__name__} is not a valid type for iterparse')
+        row_node = next(iter(self.iterparse.keys())) if self.iterparse else ''
+        if not is_list_like(self.iterparse[row_node]):
+            raise TypeError(f'{type(self.iterparse[row_node])} is not a valid type for value in iterparse')
+        if not hasattr(self.path_or_buffer, 'read') and (not isinstance(self.path_or_buffer, (str, PathLike)) or is_url(self.path_or_buffer) or is_fsspec_url(self.path_or_buffer) or (isinstance(self.path_or_buffer, str) and self.path_or_buffer.startswith(('<?xml', '<'))) or (infer_compression(self.path_or_buffer, 'infer') is not None)):
+            raise ParserError('iterparse is designed for large XML files that are fully extracted on local disk and not as compressed files or online sources.')
+        iterparse_repeats = len(self.iterparse[row_node]) != len(set(self.iterparse[row_node]))
+        for (event, elem) in iterparse(self.path_or_buffer, events=('start', 'end')):
+            curr_elem = elem.tag.split('}')[1] if '}' in elem.tag else elem.tag
+            if event == 'start':
+                if curr_elem == row_node:
+                    row = {}
+            if row is not None:
+                if self.names and iterparse_repeats:
+                    for (col, nm) in zip(self.iterparse[row_node], self.names):
+                        if curr_elem == col:
+                            elem_val = elem.text if elem.text else None
+                            if elem_val not in row.values() and nm not in row:
+                                row[nm] = elem_val
+                        if col in elem.attrib:
+                            if elem.attrib[col] not in row.values() and nm not in row:
+                                row[nm] = elem.attrib[col]
+                else:
+                    for col in self.iterparse[row_node]:
+                        if curr_elem == col:
+                            row[col] = elem.text if elem.text else None
+                        if col in elem.attrib:
+                            row[col] = elem.attrib[col]
+            if event == 'end':
+                if curr_elem == row_node and row is not None:
+                    dicts.append(row)
+                    row = None
+                elem.clear()
+                if hasattr(elem, 'getprevious'):
+                    while elem.getprevious() is not None and elem.getparent() is not None:
+                        del elem.getparent()[0]
+        if dicts == []:
+            raise ParserError('No result from selected items in iterparse.')
+        keys = list(dict.fromkeys([k for d in dicts for k in d.keys()]))
+        dicts = [{k: d[k] if k in d.keys() else None for k in keys} for d in dicts]
+        if self.names:
+            dicts = [dict(zip(self.names, d.values())) for d in dicts]
+        return dicts
+
+    def _validate_path(self) -> list[Any]:
+        raise AbstractMethodError(self)
+
+    def _validate_names(self) -> None:
+        raise AbstractMethodError(self)
+
+    def _parse_doc(self, raw_doc: FilePath | ReadBuffer[bytes] | ReadBuffer[str]) -> Element | etree._Element:
+        raise AbstractMethodError(self)
+
+class _EtreeFrameParser(_XMLFrameParser):
+
+    def parse_data(self) -> list[dict[str, str | None]]:
+        from xml.etree.ElementTree import iterparse
+        if self.stylesheet is not None:
+            raise ValueError('To use stylesheet, you need lxml installed and selected as parser.')
+        if self.iterparse is None:
+            self.xml_doc = self._parse_doc(self.path_or_buffer)
+            elems = self._validate_path()
+        self._validate_names()
+        xml_dicts: list[dict[str, str | None]] = self._parse_nodes(elems) if self.iterparse is None else self._iterparse_nodes(iterparse)
+        return xml_dicts
+
+    def _validate_path(self) -> list[Any]:
+        msg = 'xpath does not return any nodes or attributes. Be sure to specify in `xpath` the parent nodes of children and attributes to parse. If document uses namespaces denoted with xmlns, be sure to define namespaces and use them in xpath.'
+        try:
+            elems = self.xml_doc.findall(self.xpath, namespaces=self.namespaces)
+            children = [ch for el in elems for ch in el.findall('*')]
+            attrs = {k: v for el in elems for (k, v) in el.attrib.items()}
+            if elems is None:
+                raise ValueError(msg)
+            if elems is not None:
+                if self.elems_only and children == []:
+                    raise ValueError(msg)
+                if self.attrs_only and attrs == {}:
+                    raise ValueError(msg)
+                if children == [] and attrs == {}:
+                    raise ValueError(msg)
+        except (KeyError, SyntaxError) as err:
+            raise SyntaxError('You have used an incorrect or unsupported XPath expression for etree library or you used an undeclared namespace prefix.') from err
+        return elems
+
+    def _validate_names(self) -> None:
+        children: list[Any]
+        if self.names:
+            if self.iterparse:
+                children = self.iterparse[next(iter(self.iterparse))]
+            else:
+                parent = self.xml_doc.find(self.xpath, namespaces=self.namespaces)
+                children = parent.findall('*') if parent is not None else []
+            if is_list_like(self.names):
+                if len(self.names) < len(children):
+                    raise ValueError('names does not match length of child elements in xpath.')
+            else:
+                raise TypeError(f'{type(self.names).__name__} is not a valid type for names')
+
+    def _parse_doc(self, raw_doc: FilePath | ReadBuffer[bytes] | ReadBuffer[str]) -> Element:
+        from xml.etree.ElementTree import XMLParser, parse
+        handle_data = get_data_from_filepath(filepath_or_buffer=raw_doc, encoding=self.encoding, compression=self.compression, storage_options=self.storage_options)
+        with handle_data as xml_data:
+            curr_parser = XMLParser(encoding=self.encoding)
+            document = parse(xml_data, parser=curr_parser)
+        return document.getroot()
+
+class _LxmlFrameParser(_XMLFrameParser):
+
+    def parse_data(self) -> list[dict[str, str | None]]:
+        from lxml.etree import iterparse
+        if self.iterparse is None:
+            self.xml_doc = self._parse_doc(self.path_or_buffer)
+            if self.stylesheet:
+                self.xsl_doc = self._parse_doc(self.stylesheet)
+                self.xml_doc = self._transform_doc()
+            elems = self._validate_path()
+        self._validate_names()
+        xml_dicts: list[dict[str, str | None]] = self._parse_nodes(elems) if self.iterparse is None else self._iterparse_nodes(iterparse)
+        return xml_dicts
+
+    def _validate_path(self) -> list[Any]:
+        msg = 'xpath does not return any nodes or attributes. Be sure to specify in `xpath` the parent nodes of children and attributes to parse. If document uses namespaces denoted with xmlns, be sure to define namespaces and use them in xpath.'
+        elems = self.xml_doc.xpath(self.xpath, namespaces=self.namespaces)
+        children = [ch for el in elems for ch in el.xpath('*')]
+        attrs = {k: v for el in elems for (k, v) in el.attrib.items()}
+        if elems == []:
+            raise ValueError(msg)
+        if elems != []:
+            if self.elems_only and children == []:
+                raise ValueError(msg)
+            if self.attrs_only and attrs == {}:
+                raise ValueError(msg)
+            if children == [] and attrs == {}:
+                raise ValueError(msg)
+        return elems
+
+    def _validate_names(self) -> None:
+        children: list[Any]
+        if self.names:
+            if self.iterparse:
+                children = self.iterparse[next(iter(self.iterparse))]
+            else:
+                children = self.xml_doc.xpath(self.xpath + '[1]/*', namespaces=self.namespaces)
+            if is_list_like(self.names):
+                if len(self.names) < len(children):
+                    raise ValueError('names does not match length of child elements in xpath.')
+            else:
+                raise TypeError(f'{type(self.names).__name__} is not a valid type for names')
+
+    def _parse_doc(self, raw_doc: FilePath | ReadBuffer[bytes] | ReadBuffer[str]) -> etree._Element:
+        from lxml.etree import XMLParser, fromstring, parse
+        handle_data = get_data_from_filepath(filepath_or_buffer=raw_doc, encoding=self.encoding, compression=self.compression, storage_options=self.storage_options)
+        with handle_data as xml_data:
+            curr_parser = XMLParser(encoding=self.encoding)
+            if isinstance(xml_data, io.StringIO):
+                if self.encoding is None:
+                    raise TypeError('Can not pass encoding None when input is StringIO.')
+                document = fromstring(xml_data.getvalue().encode(self.encoding), parser=curr_parser)
+            else:
+                document = parse(xml_data, parser=curr_parser)
+        return document
+
+    def _transform_doc(self) -> etree._XSLTResultTree:
+        from lxml.etree import XSLT
+        transformer = XSLT(self.xsl_doc)
+        new_doc = transformer(self.xml_doc)
+        return new_doc
+
+def get_data_from_filepath(filepath_or_buffer: FilePath | bytes | ReadBuffer[bytes] | ReadBuffer[str], encoding: str | None, compression: CompressionOptions, storage_options: StorageOptions):
+    filepath_or_buffer = stringify_path(filepath_or_buffer)
+    with get_handle(filepath_or_buffer, 'r', encoding=encoding, compression=compression, storage_options=storage_options) as handle_obj:
+        return preprocess_data(handle_obj.handle.read()) if hasattr(handle_obj.handle, 'read') else handle_obj.handle
+
+def preprocess_data(data) -> io.StringIO | io.BytesIO:
+    if isinstance(data, str):
+        data = io.StringIO(data)
+    elif isinstance(data, bytes):
+        data = io.BytesIO(data)
+    return data
+
+def _data_to_frame(data, **kwargs) -> DataFrame:
+    tags = next(iter(data))
+    nodes = [list(d.values()) for d in data]
+    try:
+        with TextParser(nodes, names=tags, **kwargs) as tp:
+            return tp.read()
+    except ParserError as err:
+        raise ParserError('XML document may be too complex for import. Try to flatten document and use distinct element and attribute names.') from err
+
+def _parse(path_or_buffer: FilePath | ReadBuffer[bytes] | ReadBuffer[str], xpath: str, namespaces: dict[str, str] | None, elems_only: bool, attrs_only: bool, names: Sequence[str] | None, dtype: DtypeArg | None, converters: ConvertersArg | None, parse_dates: ParseDatesArg | None, encoding: str | None, parser: XMLParsers, stylesheet: FilePath | ReadBuffer[bytes] | ReadBuffer[str] | None, iterparse: dict[str, list[str]] | None, compression: CompressionOptions, storage_options: StorageOptions, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default, **kwargs) -> DataFrame:
+    p: _EtreeFrameParser | _LxmlFrameParser
+    if parser == 'lxml':
+        lxml = import_optional_dependency('lxml.etree', errors='ignore')
+        if lxml is not None:
+            p = _LxmlFrameParser(path_or_buffer, xpath, namespaces, elems_only, attrs_only, names, dtype, converters, parse_dates, encoding, stylesheet, iterparse, compression, storage_options)
+        else:
+            raise ImportError('lxml not found, please install or use the etree parser.')
+    elif parser == 'etree':
+        p = _EtreeFrameParser(path_or_buffer, xpath, namespaces, elems_only, attrs_only, names, dtype, converters, parse_dates, encoding, stylesheet, iterparse, compression, storage_options)
+    else:
+        raise ValueError('Values for parser can only be lxml or etree.')
+    data_dicts = p.parse_data()
+    return _data_to_frame(data=data_dicts, dtype=dtype, converters=converters, parse_dates=parse_dates, dtype_backend=dtype_backend, **kwargs)
+
+@doc(storage_options=_shared_docs['storage_options'], decompression_options=_shared_docs['decompression_options'] % 'path_or_buffer')
+def read_xml(path_or_buffer: FilePath | ReadBuffer[bytes] | ReadBuffer[str], *, xpath: str='./*', namespaces: dict[str, str] | None=None, elems_only: bool=False, attrs_only: bool=False, names: Sequence[str] | None=None, dtype: DtypeArg | None=None, converters: ConvertersArg | None=None, parse_dates: ParseDatesArg | None=None, encoding: str | None='utf-8', parser: XMLParsers='lxml', stylesheet: FilePath | ReadBuffer[bytes] | ReadBuffer[str] | None=None, iterparse: dict[str, list[str]] | None=None, compression: CompressionOptions='infer', storage_options: StorageOptions | None=None, dtype_backend: DtypeBackend | lib.NoDefault=lib.no_default) -> DataFrame:
+    check_dtype_backend(dtype_backend)
+    return _parse(path_or_buffer=path_or_buffer, xpath=xpath, namespaces=namespaces, elems_only=elems_only, attrs_only=attrs_only, names=names, dtype=dtype, converters=converters, parse_dates=parse_dates, encoding=encoding, parser=parser, stylesheet=stylesheet, iterparse=iterparse, compression=compression, storage_options=storage_options, dtype_backend=dtype_backend)
+
+# File: pandas-main/pandas/plotting/__init__.py
+""""""
+from pandas.plotting._core import PlotAccessor, boxplot, boxplot_frame, boxplot_frame_groupby, hist_frame, hist_series
+from pandas.plotting._misc import andrews_curves, autocorrelation_plot, bootstrap_plot, deregister as deregister_matplotlib_converters, lag_plot, parallel_coordinates, plot_params, radviz, register as register_matplotlib_converters, scatter_matrix, table
+__all__ = ['PlotAccessor', 'boxplot', 'boxplot_frame', 'boxplot_frame_groupby', 'hist_frame', 'hist_series', 'scatter_matrix', 'radviz', 'andrews_curves', 'bootstrap_plot', 'parallel_coordinates', 'lag_plot', 'autocorrelation_plot', 'table', 'plot_params', 'register_matplotlib_converters', 'deregister_matplotlib_converters']
+
+# File: pandas-main/pandas/plotting/_core.py
+from __future__ import annotations
+import importlib
+from typing import TYPE_CHECKING, Literal
+from pandas._config import get_option
+from pandas.util._decorators import Appender, Substitution
+from pandas.core.dtypes.common import is_integer, is_list_like
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.base import PandasObject
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable, Sequence
+    import types
+    from matplotlib.axes import Axes
+    import numpy as np
+    from pandas._typing import IndexLabel
+    from pandas import DataFrame, Index, Series
+    from pandas.core.groupby.generic import DataFrameGroupBy
+
+def holds_integer(column: Index) -> bool:
+    return column.inferred_type in {'integer', 'mixed-integer'}
+
+def hist_series(self: Series, by=None, ax=None, grid: bool=True, xlabelsize: int | None=None, xrot: float | None=None, ylabelsize: int | None=None, yrot: float | None=None, figsize: tuple[int, int] | None=None, bins: int | Sequence[int]=10, backend: str | None=None, legend: bool=False, **kwargs):
+    plot_backend = _get_plot_backend(backend)
+    return plot_backend.hist_series(self, by=by, ax=ax, grid=grid, xlabelsize=xlabelsize, xrot=xrot, ylabelsize=ylabelsize, yrot=yrot, figsize=figsize, bins=bins, legend=legend, **kwargs)
+
+def hist_frame(data: DataFrame, column: IndexLabel | None=None, by=None, grid: bool=True, xlabelsize: int | None=None, xrot: float | None=None, ylabelsize: int | None=None, yrot: float | None=None, ax=None, sharex: bool=False, sharey: bool=False, figsize: tuple[int, int] | None=None, layout: tuple[int, int] | None=None, bins: int | Sequence[int]=10, backend: str | None=None, legend: bool=False, **kwargs):
+    plot_backend = _get_plot_backend(backend)
+    return plot_backend.hist_frame(data, column=column, by=by, grid=grid, xlabelsize=xlabelsize, xrot=xrot, ylabelsize=ylabelsize, yrot=yrot, ax=ax, sharex=sharex, sharey=sharey, figsize=figsize, layout=layout, legend=legend, bins=bins, **kwargs)
+_boxplot_doc = "\nMake a box plot from DataFrame columns.\n\nMake a box-and-whisker plot from DataFrame columns, optionally grouped\nby some other columns. A box plot is a method for graphically depicting\ngroups of numerical data through their quartiles.\nThe box extends from the Q1 to Q3 quartile values of the data,\nwith a line at the median (Q2). The whiskers extend from the edges\nof box to show the range of the data. By default, they extend no more than\n`1.5 * IQR (IQR = Q3 - Q1)` from the edges of the box, ending at the farthest\ndata point within that interval. Outliers are plotted as separate dots.\n\nFor further details see\nWikipedia's entry for `boxplot <https://en.wikipedia.org/wiki/Box_plot>`_.\n\nParameters\n----------\n%(data)scolumn : str or list of str, optional\n    Column name or list of names, or vector.\n    Can be any valid input to :meth:`pandas.DataFrame.groupby`.\nby : str or array-like, optional\n    Column in the DataFrame to :meth:`pandas.DataFrame.groupby`.\n    One box-plot will be done per value of columns in `by`.\nax : object of class matplotlib.axes.Axes, optional\n    The matplotlib axes to be used by boxplot.\nfontsize : float or str\n    Tick label font size in points or as a string (e.g., `large`).\nrot : float, default 0\n    The rotation angle of labels (in degrees)\n    with respect to the screen coordinate system.\ngrid : bool, default True\n    Setting this to True will show the grid.\nfigsize : A tuple (width, height) in inches\n    The size of the figure to create in matplotlib.\nlayout : tuple (rows, columns), optional\n    For example, (3, 5) will display the subplots\n    using 3 rows and 5 columns, starting from the top-left.\nreturn_type : {'axes', 'dict', 'both'} or None, default 'axes'\n    The kind of object to return. The default is ``axes``.\n\n    * 'axes' returns the matplotlib axes the boxplot is drawn on.\n    * 'dict' returns a dictionary whose values are the matplotlib\n      Lines of the boxplot.\n    * 'both' returns a namedtuple with the axes and dict.\n    * when grouping with ``by``, a Series mapping columns to\n      ``return_type`` is returned.\n\n      If ``return_type`` is `None`, a NumPy array\n      of axes with the same shape as ``layout`` is returned.\n%(backend)s\n**kwargs\n    All other plotting keyword arguments to be passed to\n    :func:`matplotlib.pyplot.boxplot`.\n\nReturns\n-------\nresult\n    See Notes.\n\nSee Also\n--------\nSeries.plot.hist: Make a histogram.\nmatplotlib.pyplot.boxplot : Matplotlib equivalent plot.\n\nNotes\n-----\nThe return type depends on the `return_type` parameter:\n\n* 'axes' : object of class matplotlib.axes.Axes\n* 'dict' : dict of matplotlib.lines.Line2D objects\n* 'both' : a namedtuple with structure (ax, lines)\n\nFor data grouped with ``by``, return a Series of the above or a numpy\narray:\n\n* :class:`~pandas.Series`\n* :class:`~numpy.array` (for ``return_type = None``)\n\nUse ``return_type='dict'`` when you want to tweak the appearance\nof the lines after plotting. In this case a dict containing the Lines\nmaking up the boxes, caps, fliers, medians, and whiskers is returned.\n\nExamples\n--------\n\nBoxplots can be created for every column in the dataframe\nby ``df.boxplot()`` or indicating the columns to be used:\n\n.. plot::\n    :context: close-figs\n\n    >>> np.random.seed(1234)\n    >>> df = pd.DataFrame(np.random.randn(10, 4),\n    ...                   columns=['Col1', 'Col2', 'Col3', 'Col4'])\n    >>> boxplot = df.boxplot(column=['Col1', 'Col2', 'Col3'])  # doctest: +SKIP\n\nBoxplots of variables distributions grouped by the values of a third\nvariable can be created using the option ``by``. For instance:\n\n.. plot::\n    :context: close-figs\n\n    >>> df = pd.DataFrame(np.random.randn(10, 2),\n    ...                   columns=['Col1', 'Col2'])\n    >>> df['X'] = pd.Series(['A', 'A', 'A', 'A', 'A',\n    ...                      'B', 'B', 'B', 'B', 'B'])\n    >>> boxplot = df.boxplot(by='X')\n\nA list of strings (i.e. ``['X', 'Y']``) can be passed to boxplot\nin order to group the data by combination of the variables in the x-axis:\n\n.. plot::\n    :context: close-figs\n\n    >>> df = pd.DataFrame(np.random.randn(10, 3),\n    ...                   columns=['Col1', 'Col2', 'Col3'])\n    >>> df['X'] = pd.Series(['A', 'A', 'A', 'A', 'A',\n    ...                      'B', 'B', 'B', 'B', 'B'])\n    >>> df['Y'] = pd.Series(['A', 'B', 'A', 'B', 'A',\n    ...                      'B', 'A', 'B', 'A', 'B'])\n    >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by=['X', 'Y'])\n\nThe layout of boxplot can be adjusted giving a tuple to ``layout``:\n\n.. plot::\n    :context: close-figs\n\n    >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',\n    ...                      layout=(2, 1))\n\nAdditional formatting can be done to the boxplot, like suppressing the grid\n(``grid=False``), rotating the labels in the x-axis (i.e. ``rot=45``)\nor changing the fontsize (i.e. ``fontsize=15``):\n\n.. plot::\n    :context: close-figs\n\n    >>> boxplot = df.boxplot(grid=False, rot=45, fontsize=15)  # doctest: +SKIP\n\nThe parameter ``return_type`` can be used to select the type of element\nreturned by `boxplot`.  When ``return_type='axes'`` is selected,\nthe matplotlib axes on which the boxplot is drawn are returned:\n\n    >>> boxplot = df.boxplot(column=['Col1', 'Col2'], return_type='axes')\n    >>> type(boxplot)\n    <class 'matplotlib.axes._axes.Axes'>\n\nWhen grouping with ``by``, a Series mapping columns to ``return_type``\nis returned:\n\n    >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',\n    ...                      return_type='axes')\n    >>> type(boxplot)\n    <class 'pandas.core.series.Series'>\n\nIf ``return_type`` is `None`, a NumPy array of axes with the same shape\nas ``layout`` is returned:\n\n    >>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X',\n    ...                      return_type=None)\n    >>> type(boxplot)\n    <class 'numpy.ndarray'>\n"
+_backend_doc = "backend : str, default None\n    Backend to use instead of the backend specified in the option\n    ``plotting.backend``. For instance, 'matplotlib'. Alternatively, to\n    specify the ``plotting.backend`` for the whole session, set\n    ``pd.options.plotting.backend``.\n"
+_bar_or_line_doc = "\n        Parameters\n        ----------\n        x : label or position, optional\n            Allows plotting of one column versus another. If not specified,\n            the index of the DataFrame is used.\n        y : label or position, optional\n            Allows plotting of one column versus another. If not specified,\n            all numerical columns are used.\n        color : str, array-like, or dict, optional\n            The color for each of the DataFrame's columns. Possible values are:\n\n            - A single color string referred to by name, RGB or RGBA code,\n                for instance 'red' or '#a98d19'.\n\n            - A sequence of color strings referred to by name, RGB or RGBA\n                code, which will be used for each column recursively. For\n                instance ['green','yellow'] each column's %(kind)s will be filled in\n                green or yellow, alternatively. If there is only a single column to\n                be plotted, then only the first color from the color list will be\n                used.\n\n            - A dict of the form {column name : color}, so that each column will be\n                colored accordingly. For example, if your columns are called `a` and\n                `b`, then passing {'a': 'green', 'b': 'red'} will color %(kind)ss for\n                column `a` in green and %(kind)ss for column `b` in red.\n\n        **kwargs\n            Additional keyword arguments are documented in\n            :meth:`DataFrame.plot`.\n\n        Returns\n        -------\n        matplotlib.axes.Axes or np.ndarray of them\n            An ndarray is returned with one :class:`matplotlib.axes.Axes`\n            per column when ``subplots=True``.\n"
+
+@Substitution(data='data : DataFrame\n    The data to visualize.\n', backend='')
+@Appender(_boxplot_doc)
+def boxplot(data: DataFrame, column: str | list[str] | None=None, by: str | list[str] | None=None, ax: Axes | None=None, fontsize: float | str | None=None, rot: int=0, grid: bool=True, figsize: tuple[float, float] | None=None, layout: tuple[int, int] | None=None, return_type: str | None=None, **kwargs):
+    plot_backend = _get_plot_backend('matplotlib')
+    return plot_backend.boxplot(data, column=column, by=by, ax=ax, fontsize=fontsize, rot=rot, grid=grid, figsize=figsize, layout=layout, return_type=return_type, **kwargs)
+
+@Substitution(data='', backend=_backend_doc)
+@Appender(_boxplot_doc)
+def boxplot_frame(self: DataFrame, column=None, by=None, ax=None, fontsize: int | None=None, rot: int=0, grid: bool=True, figsize: tuple[float, float] | None=None, layout=None, return_type=None, backend=None, **kwargs):
+    plot_backend = _get_plot_backend(backend)
+    return plot_backend.boxplot_frame(self, column=column, by=by, ax=ax, fontsize=fontsize, rot=rot, grid=grid, figsize=figsize, layout=layout, return_type=return_type, **kwargs)
+
+def boxplot_frame_groupby(grouped: DataFrameGroupBy, subplots: bool=True, column=None, fontsize: int | None=None, rot: int=0, grid: bool=True, ax=None, figsize: tuple[float, float] | None=None, layout=None, sharex: bool=False, sharey: bool=True, backend=None, **kwargs):
+    plot_backend = _get_plot_backend(backend)
+    return plot_backend.boxplot_frame_groupby(grouped, subplots=subplots, column=column, fontsize=fontsize, rot=rot, grid=grid, ax=ax, figsize=figsize, layout=layout, sharex=sharex, sharey=sharey, **kwargs)
+
+class PlotAccessor(PandasObject):
+    _common_kinds = ('line', 'bar', 'barh', 'kde', 'density', 'area', 'hist', 'box')
+    _series_kinds = ('pie',)
+    _dataframe_kinds = ('scatter', 'hexbin')
+    _kind_aliases = {'density': 'kde'}
+    _all_kinds = _common_kinds + _series_kinds + _dataframe_kinds
+
+    def __init__(self, data: Series | DataFrame) -> None:
+        self._parent = data
+
+    @staticmethod
+    def _get_call_args(backend_name: str, data: Series | DataFrame, args, kwargs):
+        if isinstance(data, ABCSeries):
+            arg_def = [('kind', 'line'), ('ax', None), ('figsize', None), ('use_index', True), ('title', None), ('grid', None), ('legend', False), ('style', None), ('logx', False), ('logy', False), ('loglog', False), ('xticks', None), ('yticks', None), ('xlim', None), ('ylim', None), ('rot', None), ('fontsize', None), ('colormap', None), ('table', False), ('yerr', None), ('xerr', None), ('label', None), ('secondary_y', False), ('xlabel', None), ('ylabel', None)]
+        elif isinstance(data, ABCDataFrame):
+            arg_def = [('x', None), ('y', None), ('kind', 'line'), ('ax', None), ('subplots', False), ('sharex', None), ('sharey', False), ('layout', None), ('figsize', None), ('use_index', True), ('title', None), ('grid', None), ('legend', True), ('style', None), ('logx', False), ('logy', False), ('loglog', False), ('xticks', None), ('yticks', None), ('xlim', None), ('ylim', None), ('rot', None), ('fontsize', None), ('colormap', None), ('table', False), ('yerr', None), ('xerr', None), ('secondary_y', False), ('xlabel', None), ('ylabel', None)]
+        else:
+            raise TypeError(f'Called plot accessor for type {type(data).__name__}, expected Series or DataFrame')
+        if args and isinstance(data, ABCSeries):
+            positional_args = str(args)[1:-1]
+            keyword_args = ', '.join([f'{name}={value!r}' for ((name, _), value) in zip(arg_def, args)])
+            msg = f'`Series.plot()` should not be called with positional arguments, only keyword arguments. The order of positional arguments will change in the future. Use `Series.plot({keyword_args})` instead of `Series.plot({positional_args})`.'
+            raise TypeError(msg)
+        pos_args = {name: value for ((name, _), value) in zip(arg_def, args)}
+        if backend_name == 'pandas.plotting._matplotlib':
+            kwargs = dict(arg_def, **pos_args, **kwargs)
+        else:
+            kwargs = dict(pos_args, **kwargs)
+        x = kwargs.pop('x', None)
+        y = kwargs.pop('y', None)
+        kind = kwargs.pop('kind', 'line')
+        return (x, y, kind, kwargs)
+
+    def __call__(self, *args, **kwargs):
+        plot_backend = _get_plot_backend(kwargs.pop('backend', None))
+        (x, y, kind, kwargs) = self._get_call_args(plot_backend.__name__, self._parent, args, kwargs)
+        kind = self._kind_aliases.get(kind, kind)
+        if plot_backend.__name__ != 'pandas.plotting._matplotlib':
+            return plot_backend.plot(self._parent, x=x, y=y, kind=kind, **kwargs)
+        if kind not in self._all_kinds:
+            raise ValueError(f'{kind} is not a valid plot kind Valid plot kinds: {self._all_kinds}')
+        data = self._parent
+        if isinstance(data, ABCSeries):
+            kwargs['reuse_plot'] = True
+        if kind in self._dataframe_kinds:
+            if isinstance(data, ABCDataFrame):
+                return plot_backend.plot(data, x=x, y=y, kind=kind, **kwargs)
+            else:
+                raise ValueError(f'plot kind {kind} can only be used for data frames')
+        elif kind in self._series_kinds:
+            if isinstance(data, ABCDataFrame):
+                if y is None and kwargs.get('subplots') is False:
+                    raise ValueError(f"{kind} requires either y column or 'subplots=True'")
+                if y is not None:
+                    if is_integer(y) and (not holds_integer(data.columns)):
+                        y = data.columns[y]
+                    data = data[y].copy(deep=False)
+                    data.index.name = y
+        elif isinstance(data, ABCDataFrame):
+            data_cols = data.columns
+            if x is not None:
+                if is_integer(x) and (not holds_integer(data.columns)):
+                    x = data_cols[x]
+                elif not isinstance(data[x], ABCSeries):
+                    raise ValueError('x must be a label or position')
+                data = data.set_index(x)
+            if y is not None:
+                int_ylist = is_list_like(y) and all((is_integer(c) for c in y))
+                int_y_arg = is_integer(y) or int_ylist
+                if int_y_arg and (not holds_integer(data.columns)):
+                    y = data_cols[y]
+                label_kw = kwargs['label'] if 'label' in kwargs else False
+                for kw in ['xerr', 'yerr']:
+                    if kw in kwargs and (isinstance(kwargs[kw], str) or is_integer(kwargs[kw])):
+                        try:
+                            kwargs[kw] = data[kwargs[kw]]
+                        except (IndexError, KeyError, TypeError):
+                            pass
+                data = data[y]
+                if isinstance(data, ABCSeries):
+                    label_name = label_kw or y
+                    data.name = label_name
+                else:
+                    match = is_list_like(label_kw) and len(label_kw) == len(y)
+                    if label_kw and (not match):
+                        raise ValueError('label should be list-like and same length as y')
+                    label_name = label_kw or data.columns
+                    data.columns = label_name
+        return plot_backend.plot(data, kind=kind, **kwargs)
+    __call__.__doc__ = __doc__
+
+    @Appender('\n        See Also\n        --------\n        matplotlib.pyplot.plot : Plot y versus x as lines and/or markers.\n\n        Examples\n        --------\n\n        .. plot::\n            :context: close-figs\n\n            >>> s = pd.Series([1, 3, 2])\n            >>> s.plot.line()  # doctest: +SKIP\n\n        .. plot::\n            :context: close-figs\n\n            The following example shows the populations for some animals\n            over the years.\n\n            >>> df = pd.DataFrame({\n            ...     \'pig\': [20, 18, 489, 675, 1776],\n            ...     \'horse\': [4, 25, 281, 600, 1900]\n            ... }, index=[1990, 1997, 2003, 2009, 2014])\n            >>> lines = df.plot.line()\n\n        .. plot::\n           :context: close-figs\n\n           An example with subplots, so an array of axes is returned.\n\n           >>> axes = df.plot.line(subplots=True)\n           >>> type(axes)\n           <class \'numpy.ndarray\'>\n\n        .. plot::\n           :context: close-figs\n\n           Let\'s repeat the same example, but specifying colors for\n           each column (in this case, for each animal).\n\n           >>> axes = df.plot.line(\n           ...     subplots=True, color={"pig": "pink", "horse": "#742802"}\n           ... )\n\n        .. plot::\n            :context: close-figs\n\n            The following example shows the relationship between both\n            populations.\n\n            >>> lines = df.plot.line(x=\'pig\', y=\'horse\')\n        ')
+    @Substitution(kind='line')
+    @Appender(_bar_or_line_doc)
+    def line(self, x: Hashable | None=None, y: Hashable | None=None, color: str | Sequence[str] | dict | None=None, **kwargs) -> PlotAccessor:
+        if color is not None:
+            kwargs['color'] = color
+        return self(kind='line', x=x, y=y, **kwargs)
+
+    @Appender('\n        See Also\n        --------\n        DataFrame.plot.barh : Horizontal bar plot.\n        DataFrame.plot : Make plots of a DataFrame.\n        matplotlib.pyplot.bar : Make a bar plot with matplotlib.\n\n        Examples\n        --------\n        Basic plot.\n\n        .. plot::\n            :context: close-figs\n\n            >>> df = pd.DataFrame({\'lab\': [\'A\', \'B\', \'C\'], \'val\': [10, 30, 20]})\n            >>> ax = df.plot.bar(x=\'lab\', y=\'val\', rot=0)\n\n        Plot a whole dataframe to a bar plot. Each column is assigned a\n        distinct color, and each row is nested in a group along the\n        horizontal axis.\n\n        .. plot::\n            :context: close-figs\n\n            >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88]\n            >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28]\n            >>> index = [\'snail\', \'pig\', \'elephant\',\n            ...          \'rabbit\', \'giraffe\', \'coyote\', \'horse\']\n            >>> df = pd.DataFrame({\'speed\': speed,\n            ...                    \'lifespan\': lifespan}, index=index)\n            >>> ax = df.plot.bar(rot=0)\n\n        Plot stacked bar charts for the DataFrame\n\n        .. plot::\n            :context: close-figs\n\n            >>> ax = df.plot.bar(stacked=True)\n\n        Instead of nesting, the figure can be split by column with\n        ``subplots=True``. In this case, a :class:`numpy.ndarray` of\n        :class:`matplotlib.axes.Axes` are returned.\n\n        .. plot::\n            :context: close-figs\n\n            >>> axes = df.plot.bar(rot=0, subplots=True)\n            >>> axes[1].legend(loc=2)  # doctest: +SKIP\n\n        If you don\'t like the default colours, you can specify how you\'d\n        like each column to be colored.\n\n        .. plot::\n            :context: close-figs\n\n            >>> axes = df.plot.bar(\n            ...     rot=0, subplots=True, color={"speed": "red", "lifespan": "green"}\n            ... )\n            >>> axes[1].legend(loc=2)  # doctest: +SKIP\n\n        Plot a single column.\n\n        .. plot::\n            :context: close-figs\n\n            >>> ax = df.plot.bar(y=\'speed\', rot=0)\n\n        Plot only selected categories for the DataFrame.\n\n        .. plot::\n            :context: close-figs\n\n            >>> ax = df.plot.bar(x=\'lifespan\', rot=0)\n    ')
+    @Substitution(kind='bar')
+    @Appender(_bar_or_line_doc)
+    def bar(self, x: Hashable | None=None, y: Hashable | None=None, color: str | Sequence[str] | dict | None=None, **kwargs) -> PlotAccessor:
+        if color is not None:
+            kwargs['color'] = color
+        return self(kind='bar', x=x, y=y, **kwargs)
+
+    @Appender('\n        See Also\n        --------\n        DataFrame.plot.bar : Vertical bar plot.\n        DataFrame.plot : Make plots of DataFrame using matplotlib.\n        matplotlib.axes.Axes.bar : Plot a vertical bar plot using matplotlib.\n\n        Examples\n        --------\n        Basic example\n\n        .. plot::\n            :context: close-figs\n\n            >>> df = pd.DataFrame({\'lab\': [\'A\', \'B\', \'C\'], \'val\': [10, 30, 20]})\n            >>> ax = df.plot.barh(x=\'lab\', y=\'val\')\n\n        Plot a whole DataFrame to a horizontal bar plot\n\n        .. plot::\n            :context: close-figs\n\n            >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88]\n            >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28]\n            >>> index = [\'snail\', \'pig\', \'elephant\',\n            ...          \'rabbit\', \'giraffe\', \'coyote\', \'horse\']\n            >>> df = pd.DataFrame({\'speed\': speed,\n            ...                    \'lifespan\': lifespan}, index=index)\n            >>> ax = df.plot.barh()\n\n        Plot stacked barh charts for the DataFrame\n\n        .. plot::\n            :context: close-figs\n\n            >>> ax = df.plot.barh(stacked=True)\n\n        We can specify colors for each column\n\n        .. plot::\n            :context: close-figs\n\n            >>> ax = df.plot.barh(color={"speed": "red", "lifespan": "green"})\n\n        Plot a column of the DataFrame to a horizontal bar plot\n\n        .. plot::\n            :context: close-figs\n\n            >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88]\n            >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28]\n            >>> index = [\'snail\', \'pig\', \'elephant\',\n            ...          \'rabbit\', \'giraffe\', \'coyote\', \'horse\']\n            >>> df = pd.DataFrame({\'speed\': speed,\n            ...                    \'lifespan\': lifespan}, index=index)\n            >>> ax = df.plot.barh(y=\'speed\')\n\n        Plot DataFrame versus the desired column\n\n        .. plot::\n            :context: close-figs\n\n            >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88]\n            >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28]\n            >>> index = [\'snail\', \'pig\', \'elephant\',\n            ...          \'rabbit\', \'giraffe\', \'coyote\', \'horse\']\n            >>> df = pd.DataFrame({\'speed\': speed,\n            ...                    \'lifespan\': lifespan}, index=index)\n            >>> ax = df.plot.barh(x=\'lifespan\')\n    ')
+    @Substitution(kind='bar')
+    @Appender(_bar_or_line_doc)
+    def barh(self, x: Hashable | None=None, y: Hashable | None=None, color: str | Sequence[str] | dict | None=None, **kwargs) -> PlotAccessor:
+        if color is not None:
+            kwargs['color'] = color
+        return self(kind='barh', x=x, y=y, **kwargs)
+
+    def box(self, by: IndexLabel | None=None, **kwargs) -> PlotAccessor:
+        return self(kind='box', by=by, **kwargs)
+
+    def hist(self, by: IndexLabel | None=None, bins: int=10, **kwargs) -> PlotAccessor:
+        return self(kind='hist', by=by, bins=bins, **kwargs)
+
+    def kde(self, bw_method: Literal['scott', 'silverman'] | float | Callable | None=None, ind: np.ndarray | int | None=None, weights: np.ndarray | None=None, **kwargs) -> PlotAccessor:
+        return self(kind='kde', bw_method=bw_method, ind=ind, weights=weights, **kwargs)
+    density = kde
+
+    def area(self, x: Hashable | None=None, y: Hashable | None=None, stacked: bool=True, **kwargs) -> PlotAccessor:
+        return self(kind='area', x=x, y=y, stacked=stacked, **kwargs)
+
+    def pie(self, y: IndexLabel | None=None, **kwargs) -> PlotAccessor:
+        if y is not None:
+            kwargs['y'] = y
+        if isinstance(self._parent, ABCDataFrame) and kwargs.get('y', None) is None and (not kwargs.get('subplots', False)):
+            raise ValueError("pie requires either y column or 'subplots=True'")
+        return self(kind='pie', **kwargs)
+
+    def scatter(self, x: Hashable, y: Hashable, s: Hashable | Sequence[Hashable] | None=None, c: Hashable | Sequence[Hashable] | None=None, **kwargs) -> PlotAccessor:
+        return self(kind='scatter', x=x, y=y, s=s, c=c, **kwargs)
+
+    def hexbin(self, x: Hashable, y: Hashable, C: Hashable | None=None, reduce_C_function: Callable | None=None, gridsize: int | tuple[int, int] | None=None, **kwargs) -> PlotAccessor:
+        if reduce_C_function is not None:
+            kwargs['reduce_C_function'] = reduce_C_function
+        if gridsize is not None:
+            kwargs['gridsize'] = gridsize
+        return self(kind='hexbin', x=x, y=y, C=C, **kwargs)
+_backends: dict[str, types.ModuleType] = {}
+
+def _load_backend(backend: str) -> types.ModuleType:
+    from importlib.metadata import entry_points
+    if backend == 'matplotlib':
+        try:
+            module = importlib.import_module('pandas.plotting._matplotlib')
+        except ImportError:
+            raise ImportError('matplotlib is required for plotting when the default backend "matplotlib" is selected.') from None
+        return module
+    found_backend = False
+    eps = entry_points()
+    key = 'pandas_plotting_backends'
+    if hasattr(eps, 'select'):
+        entry = eps.select(group=key)
+    else:
+        entry = eps.get(key, ())
+    for entry_point in entry:
+        found_backend = entry_point.name == backend
+        if found_backend:
+            module = entry_point.load()
+            break
+    if not found_backend:
+        try:
+            module = importlib.import_module(backend)
+            found_backend = True
+        except ImportError:
+            pass
+    if found_backend:
+        if hasattr(module, 'plot'):
+            return module
+    raise ValueError(f"Could not find plotting backend '{backend}'. Ensure that you've installed the package providing the '{backend}' entrypoint, or that the package has a top-level `.plot` method.")
+
+def _get_plot_backend(backend: str | None=None):
+    backend_str: str = backend or get_option('plotting.backend')
+    if backend_str in _backends:
+        return _backends[backend_str]
+    module = _load_backend(backend_str)
+    _backends[backend_str] = module
+    return module
+
+# File: pandas-main/pandas/plotting/_matplotlib/__init__.py
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from pandas.plotting._matplotlib.boxplot import BoxPlot, boxplot, boxplot_frame, boxplot_frame_groupby
+from pandas.plotting._matplotlib.converter import deregister, register
+from pandas.plotting._matplotlib.core import AreaPlot, BarhPlot, BarPlot, HexBinPlot, LinePlot, PiePlot, ScatterPlot
+from pandas.plotting._matplotlib.hist import HistPlot, KdePlot, hist_frame, hist_series
+from pandas.plotting._matplotlib.misc import andrews_curves, autocorrelation_plot, bootstrap_plot, lag_plot, parallel_coordinates, radviz, scatter_matrix
+from pandas.plotting._matplotlib.tools import table
+if TYPE_CHECKING:
+    from pandas.plotting._matplotlib.core import MPLPlot
+PLOT_CLASSES: dict[str, type[MPLPlot]] = {'line': LinePlot, 'bar': BarPlot, 'barh': BarhPlot, 'box': BoxPlot, 'hist': HistPlot, 'kde': KdePlot, 'area': AreaPlot, 'pie': PiePlot, 'scatter': ScatterPlot, 'hexbin': HexBinPlot}
+
+def plot(data, kind, **kwargs):
+    import matplotlib.pyplot as plt
+    if kwargs.pop('reuse_plot', False):
+        ax = kwargs.get('ax')
+        if ax is None and len(plt.get_fignums()) > 0:
+            with plt.rc_context():
+                ax = plt.gca()
+            kwargs['ax'] = getattr(ax, 'left_ax', ax)
+    plot_obj = PLOT_CLASSES[kind](data, **kwargs)
+    plot_obj.generate()
+    plt.draw_if_interactive()
+    return plot_obj.result
+__all__ = ['plot', 'hist_series', 'hist_frame', 'boxplot', 'boxplot_frame', 'boxplot_frame_groupby', 'table', 'andrews_curves', 'autocorrelation_plot', 'bootstrap_plot', 'lag_plot', 'parallel_coordinates', 'radviz', 'scatter_matrix', 'register', 'deregister']
+
+# File: pandas-main/pandas/plotting/_matplotlib/boxplot.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, Literal, NamedTuple
+import warnings
+import matplotlib as mpl
+import numpy as np
+from pandas._libs import lib
+from pandas.util._decorators import cache_readonly
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import is_dict_like
+from pandas.core.dtypes.generic import ABCSeries
+from pandas.core.dtypes.missing import remove_na_arraylike
+import pandas as pd
+import pandas.core.common as com
+from pandas.io.formats.printing import pprint_thing
+from pandas.plotting._matplotlib.core import LinePlot, MPLPlot
+from pandas.plotting._matplotlib.groupby import create_iter_data_given_by
+from pandas.plotting._matplotlib.style import get_standard_colors
+from pandas.plotting._matplotlib.tools import create_subplots, flatten_axes, maybe_adjust_figure
+if TYPE_CHECKING:
+    from collections.abc import Collection
+    from matplotlib.axes import Axes
+    from matplotlib.figure import Figure
+    from matplotlib.lines import Line2D
+    from pandas._typing import MatplotlibColor
+
+def _set_ticklabels(ax: Axes, labels: list[str], is_vertical: bool, **kwargs) -> None:
+    ticks = ax.get_xticks() if is_vertical else ax.get_yticks()
+    if len(ticks) != len(labels):
+        (i, remainder) = divmod(len(ticks), len(labels))
+        assert remainder == 0, remainder
+        labels *= i
+    if is_vertical:
+        ax.set_xticklabels(labels, **kwargs)
+    else:
+        ax.set_yticklabels(labels, **kwargs)
+
+class BoxPlot(LinePlot):
+
+    @property
+    def _kind(self) -> Literal['box']:
+        return 'box'
+    _layout_type = 'horizontal'
+    _valid_return_types = (None, 'axes', 'dict', 'both')
+
+    class BP(NamedTuple):
+        ax: Axes
+        lines: dict[str, list[Line2D]]
+
+    def __init__(self, data, return_type: str='axes', **kwargs) -> None:
+        if return_type not in self._valid_return_types:
+            raise ValueError("return_type must be {None, 'axes', 'dict', 'both'}")
+        self.return_type = return_type
+        MPLPlot.__init__(self, data, **kwargs)
+        if self.subplots:
+            if self.orientation == 'vertical':
+                self.sharex = False
+            else:
+                self.sharey = False
+
+    @classmethod
+    def _plot(cls, ax: Axes, y: np.ndarray, column_num=None, return_type: str='axes', **kwds):
+        ys: np.ndarray | list[np.ndarray]
+        if y.ndim == 2:
+            ys = [remove_na_arraylike(v) for v in y]
+            ys = [v if v.size > 0 else np.array([np.nan]) for v in ys]
+        else:
+            ys = remove_na_arraylike(y)
+        bp = ax.boxplot(ys, **kwds)
+        if return_type == 'dict':
+            return (bp, bp)
+        elif return_type == 'both':
+            return (cls.BP(ax=ax, lines=bp), bp)
+        else:
+            return (ax, bp)
+
+    def _validate_color_args(self, color, colormap):
+        if color is lib.no_default:
+            return None
+        if colormap is not None:
+            warnings.warn("'color' and 'colormap' cannot be used simultaneously. Using 'color'", stacklevel=find_stack_level())
+        if isinstance(color, dict):
+            valid_keys = ['boxes', 'whiskers', 'medians', 'caps']
+            for key in color:
+                if key not in valid_keys:
+                    raise ValueError(f"color dict contains invalid key '{key}'. The key must be either {valid_keys}")
+        return color
+
+    @cache_readonly
+    def _color_attrs(self):
+        return get_standard_colors(num_colors=3, colormap=self.colormap, color=None)
+
+    @cache_readonly
+    def _boxes_c(self):
+        return self._color_attrs[0]
+
+    @cache_readonly
+    def _whiskers_c(self):
+        return self._color_attrs[0]
+
+    @cache_readonly
+    def _medians_c(self):
+        return self._color_attrs[2]
+
+    @cache_readonly
+    def _caps_c(self):
+        return self._color_attrs[0]
+
+    def _get_colors(self, num_colors=None, color_kwds: dict[str, MatplotlibColor] | MatplotlibColor | Collection[MatplotlibColor] | None='color') -> None:
+        pass
+
+    def maybe_color_bp(self, bp) -> None:
+        if isinstance(self.color, dict):
+            boxes = self.color.get('boxes', self._boxes_c)
+            whiskers = self.color.get('whiskers', self._whiskers_c)
+            medians = self.color.get('medians', self._medians_c)
+            caps = self.color.get('caps', self._caps_c)
+        else:
+            boxes = self.color or self._boxes_c
+            whiskers = self.color or self._whiskers_c
+            medians = self.color or self._medians_c
+            caps = self.color or self._caps_c
+        color_tup = (boxes, whiskers, medians, caps)
+        maybe_color_bp(bp, color_tup=color_tup, **self.kwds)
+
+    def _make_plot(self, fig: Figure) -> None:
+        if self.subplots:
+            self._return_obj = pd.Series(dtype=object)
+            data = create_iter_data_given_by(self.data, self._kind) if self.by is not None else self.data
+            for (i, (label, y)) in enumerate(self._iter_data(data=data)):
+                ax = self._get_ax(i)
+                kwds = self.kwds.copy()
+                if self.by is not None:
+                    y = y.T
+                    ax.set_title(pprint_thing(label))
+                    levels = self.data.columns.levels
+                    ticklabels = [pprint_thing(col) for col in levels[0]]
+                else:
+                    ticklabels = [pprint_thing(label)]
+                (ret, bp) = self._plot(ax, y, column_num=i, return_type=self.return_type, **kwds)
+                self.maybe_color_bp(bp)
+                self._return_obj[label] = ret
+                _set_ticklabels(ax=ax, labels=ticklabels, is_vertical=self.orientation == 'vertical')
+        else:
+            y = self.data.values.T
+            ax = self._get_ax(0)
+            kwds = self.kwds.copy()
+            (ret, bp) = self._plot(ax, y, column_num=0, return_type=self.return_type, **kwds)
+            self.maybe_color_bp(bp)
+            self._return_obj = ret
+            labels = [pprint_thing(left) for left in self.data.columns]
+            if not self.use_index:
+                labels = [pprint_thing(key) for key in range(len(labels))]
+            _set_ticklabels(ax=ax, labels=labels, is_vertical=self.orientation == 'vertical')
+
+    def _make_legend(self) -> None:
+        pass
+
+    def _post_plot_logic(self, ax: Axes, data) -> None:
+        if self.xlabel:
+            ax.set_xlabel(pprint_thing(self.xlabel))
+        if self.ylabel:
+            ax.set_ylabel(pprint_thing(self.ylabel))
+
+    @property
+    def orientation(self) -> Literal['horizontal', 'vertical']:
+        if self.kwds.get('vert', True):
+            return 'vertical'
+        else:
+            return 'horizontal'
+
+    @property
+    def result(self):
+        if self.return_type is None:
+            return super().result
+        else:
+            return self._return_obj
+
+def maybe_color_bp(bp, color_tup, **kwds) -> None:
+    if not kwds.get('boxprops'):
+        mpl.artist.setp(bp['boxes'], color=color_tup[0], alpha=1)
+    if not kwds.get('whiskerprops'):
+        mpl.artist.setp(bp['whiskers'], color=color_tup[1], alpha=1)
+    if not kwds.get('medianprops'):
+        mpl.artist.setp(bp['medians'], color=color_tup[2], alpha=1)
+    if not kwds.get('capprops'):
+        mpl.artist.setp(bp['caps'], color=color_tup[3], alpha=1)
+
+def _grouped_plot_by_column(plotf, data, columns=None, by=None, numeric_only: bool=True, grid: bool=False, figsize: tuple[float, float] | None=None, ax=None, layout=None, return_type=None, **kwargs):
+    grouped = data.groupby(by, observed=False)
+    if columns is None:
+        if not isinstance(by, (list, tuple)):
+            by = [by]
+        columns = data._get_numeric_data().columns.difference(by)
+    naxes = len(columns)
+    (fig, axes) = create_subplots(naxes=naxes, sharex=kwargs.pop('sharex', True), sharey=kwargs.pop('sharey', True), figsize=figsize, ax=ax, layout=layout)
+    (xlabel, ylabel) = (kwargs.pop('xlabel', None), kwargs.pop('ylabel', None))
+    if kwargs.get('vert', True):
+        xlabel = xlabel or by
+    else:
+        ylabel = ylabel or by
+    ax_values = []
+    for (ax, col) in zip(flatten_axes(axes), columns):
+        gp_col = grouped[col]
+        (keys, values) = zip(*gp_col)
+        re_plotf = plotf(keys, values, ax, xlabel=xlabel, ylabel=ylabel, **kwargs)
+        ax.set_title(col)
+        ax_values.append(re_plotf)
+        ax.grid(grid)
+    result = pd.Series(ax_values, index=columns, copy=False)
+    if return_type is None:
+        result = axes
+    byline = by[0] if len(by) == 1 else by
+    fig.suptitle(f'Boxplot grouped by {byline}')
+    maybe_adjust_figure(fig, bottom=0.15, top=0.9, left=0.1, right=0.9, wspace=0.2)
+    return result
+
+def boxplot(data, column=None, by=None, ax=None, fontsize: int | None=None, rot: int=0, grid: bool=True, figsize: tuple[float, float] | None=None, layout=None, return_type=None, **kwds):
+    import matplotlib.pyplot as plt
+    if return_type not in BoxPlot._valid_return_types:
+        raise ValueError("return_type must be {'axes', 'dict', 'both'}")
+    if isinstance(data, ABCSeries):
+        data = data.to_frame('x')
+        column = 'x'
+
+    def _get_colors():
+        result_list = get_standard_colors(num_colors=3)
+        result = np.take(result_list, [0, 0, 2])
+        result = np.append(result, 'k')
+        colors = kwds.pop('color', None)
+        if colors:
+            if is_dict_like(colors):
+                valid_keys = ['boxes', 'whiskers', 'medians', 'caps']
+                key_to_index = dict(zip(valid_keys, range(4)))
+                for (key, value) in colors.items():
+                    if key in valid_keys:
+                        result[key_to_index[key]] = value
+                    else:
+                        raise ValueError(f"color dict contains invalid key '{key}'. The key must be either {valid_keys}")
+            else:
+                result.fill(colors)
+        return result
+
+    def plot_group(keys, values, ax: Axes, **kwds):
+        (xlabel, ylabel) = (kwds.pop('xlabel', None), kwds.pop('ylabel', None))
+        if xlabel:
+            ax.set_xlabel(pprint_thing(xlabel))
+        if ylabel:
+            ax.set_ylabel(pprint_thing(ylabel))
+        keys = [pprint_thing(x) for x in keys]
+        values = [np.asarray(remove_na_arraylike(v), dtype=object) for v in values]
+        bp = ax.boxplot(values, **kwds)
+        if fontsize is not None:
+            ax.tick_params(axis='both', labelsize=fontsize)
+        _set_ticklabels(ax=ax, labels=keys, is_vertical=kwds.get('vert', True), rotation=rot)
+        maybe_color_bp(bp, color_tup=colors, **kwds)
+        if return_type == 'dict':
+            return bp
+        elif return_type == 'both':
+            return BoxPlot.BP(ax=ax, lines=bp)
+        else:
+            return ax
+    colors = _get_colors()
+    if column is None:
+        columns = None
+    elif isinstance(column, (list, tuple)):
+        columns = column
+    else:
+        columns = [column]
+    if by is not None:
+        result = _grouped_plot_by_column(plot_group, data, columns=columns, by=by, grid=grid, figsize=figsize, ax=ax, layout=layout, return_type=return_type, **kwds)
+    else:
+        if return_type is None:
+            return_type = 'axes'
+        if layout is not None:
+            raise ValueError("The 'layout' keyword is not supported when 'by' is None")
+        if ax is None:
+            rc = {'figure.figsize': figsize} if figsize is not None else {}
+            with mpl.rc_context(rc):
+                ax = plt.gca()
+        data = data._get_numeric_data()
+        naxes = len(data.columns)
+        if naxes == 0:
+            raise ValueError('boxplot method requires numerical columns, nothing to plot.')
+        if columns is None:
+            columns = data.columns
+        else:
+            data = data[columns]
+        result = plot_group(columns, data.values.T, ax, **kwds)
+        ax.grid(grid)
+    return result
+
+def boxplot_frame(self, column=None, by=None, ax=None, fontsize: int | None=None, rot: int=0, grid: bool=True, figsize: tuple[float, float] | None=None, layout=None, return_type=None, **kwds):
+    import matplotlib.pyplot as plt
+    ax = boxplot(self, column=column, by=by, ax=ax, fontsize=fontsize, grid=grid, rot=rot, figsize=figsize, layout=layout, return_type=return_type, **kwds)
+    plt.draw_if_interactive()
+    return ax
+
+def boxplot_frame_groupby(grouped, subplots: bool=True, column=None, fontsize: int | None=None, rot: int=0, grid: bool=True, ax=None, figsize: tuple[float, float] | None=None, layout=None, sharex: bool=False, sharey: bool=True, **kwds):
+    if subplots is True:
+        naxes = len(grouped)
+        (fig, axes) = create_subplots(naxes=naxes, squeeze=False, ax=ax, sharex=sharex, sharey=sharey, figsize=figsize, layout=layout)
+        data = {}
+        for ((key, group), ax) in zip(grouped, flatten_axes(axes)):
+            d = group.boxplot(ax=ax, column=column, fontsize=fontsize, rot=rot, grid=grid, **kwds)
+            ax.set_title(pprint_thing(key))
+            data[key] = d
+        ret = pd.Series(data)
+        maybe_adjust_figure(fig, bottom=0.15, top=0.9, left=0.1, right=0.9, wspace=0.2)
+    else:
+        (keys, frames) = zip(*grouped)
+        df = pd.concat(frames, keys=keys, axis=1)
+        if column is not None:
+            column = com.convert_to_list_like(column)
+            multi_key = pd.MultiIndex.from_product([keys, column])
+            column = list(multi_key.values)
+        ret = df.boxplot(column=column, fontsize=fontsize, rot=rot, grid=grid, ax=ax, figsize=figsize, layout=layout, **kwds)
+    return ret
+
+# File: pandas-main/pandas/plotting/_matplotlib/converter.py
+from __future__ import annotations
+import contextlib
+import datetime as pydt
+from datetime import datetime, tzinfo
+import functools
+from typing import TYPE_CHECKING, Any, cast
+import warnings
+import matplotlib as mpl
+import matplotlib.dates as mdates
+import matplotlib.units as munits
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.tslibs import Timestamp, to_offset
+from pandas._libs.tslibs.dtypes import FreqGroup, periods_per_day
+from pandas._typing import F, npt
+from pandas.core.dtypes.common import is_float, is_float_dtype, is_integer, is_integer_dtype, is_nested_list_like
+from pandas import Index, Series, get_option
+import pandas.core.common as com
+from pandas.core.indexes.datetimes import date_range
+from pandas.core.indexes.period import Period, PeriodIndex, period_range
+import pandas.core.tools.datetimes as tools
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from matplotlib.axis import Axis
+    from pandas._libs.tslibs.offsets import BaseOffset
+_mpl_units = {}
+
+def get_pairs():
+    pairs = [(Timestamp, DatetimeConverter), (Period, PeriodConverter), (pydt.datetime, DatetimeConverter), (pydt.date, DatetimeConverter), (pydt.time, TimeConverter), (np.datetime64, DatetimeConverter)]
+    return pairs
+
+def register_pandas_matplotlib_converters(func: F) -> F:
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        with pandas_converters():
+            return func(*args, **kwargs)
+    return cast(F, wrapper)
+
+@contextlib.contextmanager
+def pandas_converters() -> Generator[None, None, None]:
+    value = get_option('plotting.matplotlib.register_converters')
+    if value:
+        register()
+    try:
+        yield
+    finally:
+        if value == 'auto':
+            deregister()
+
+def register() -> None:
+    pairs = get_pairs()
+    for (type_, cls) in pairs:
+        if type_ in munits.registry and (not isinstance(munits.registry[type_], cls)):
+            previous = munits.registry[type_]
+            _mpl_units[type_] = previous
+        munits.registry[type_] = cls()
+
+def deregister() -> None:
+    for (type_, cls) in get_pairs():
+        if type(munits.registry.get(type_)) is cls:
+            munits.registry.pop(type_)
+    for (unit, formatter) in _mpl_units.items():
+        if type(formatter) not in {DatetimeConverter, PeriodConverter, TimeConverter}:
+            munits.registry[unit] = formatter
+
+def _to_ordinalf(tm: pydt.time) -> float:
+    tot_sec = tm.hour * 3600 + tm.minute * 60 + tm.second + tm.microsecond / 10 ** 6
+    return tot_sec
+
+def time2num(d):
+    if isinstance(d, str):
+        parsed = Timestamp(d)
+        return _to_ordinalf(parsed.time())
+    if isinstance(d, pydt.time):
+        return _to_ordinalf(d)
+    return d
+
+class TimeConverter(munits.ConversionInterface):
+
+    @staticmethod
+    def convert(value, unit, axis):
+        valid_types = (str, pydt.time)
+        if isinstance(value, valid_types) or is_integer(value) or is_float(value):
+            return time2num(value)
+        if isinstance(value, Index):
+            return value.map(time2num)
+        if isinstance(value, (list, tuple, np.ndarray, Index)):
+            return [time2num(x) for x in value]
+        return value
+
+    @staticmethod
+    def axisinfo(unit, axis) -> munits.AxisInfo | None:
+        if unit != 'time':
+            return None
+        majloc = mpl.ticker.AutoLocator()
+        majfmt = TimeFormatter(majloc)
+        return munits.AxisInfo(majloc=majloc, majfmt=majfmt, label='time')
+
+    @staticmethod
+    def default_units(x, axis) -> str:
+        return 'time'
+
+class TimeFormatter(mpl.ticker.Formatter):
+
+    def __init__(self, locs) -> None:
+        self.locs = locs
+
+    def __call__(self, x, pos: int | None=0) -> str:
+        fmt = '%H:%M:%S.%f'
+        s = int(x)
+        msus = round((x - s) * 10 ** 6)
+        ms = msus // 1000
+        us = msus % 1000
+        (m, s) = divmod(s, 60)
+        (h, m) = divmod(m, 60)
+        (_, h) = divmod(h, 24)
+        if us != 0:
+            return pydt.time(h, m, s, msus).strftime(fmt)
+        elif ms != 0:
+            return pydt.time(h, m, s, msus).strftime(fmt)[:-3]
+        elif s != 0:
+            return pydt.time(h, m, s).strftime('%H:%M:%S')
+        return pydt.time(h, m).strftime('%H:%M')
+
+class PeriodConverter(mdates.DateConverter):
+
+    @staticmethod
+    def convert(values, units, axis):
+        if is_nested_list_like(values):
+            values = [PeriodConverter._convert_1d(v, units, axis) for v in values]
+        else:
+            values = PeriodConverter._convert_1d(values, units, axis)
+        return values
+
+    @staticmethod
+    def _convert_1d(values, units, axis):
+        if not hasattr(axis, 'freq'):
+            raise TypeError('Axis must have `freq` set to convert to Periods')
+        valid_types = (str, datetime, Period, pydt.date, pydt.time, np.datetime64)
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', 'Period with BDay freq is deprecated', category=FutureWarning)
+            warnings.filterwarnings('ignore', 'PeriodDtype\\[B\\] is deprecated', category=FutureWarning)
+            if isinstance(values, valid_types) or is_integer(values) or is_float(values):
+                return get_datevalue(values, axis.freq)
+            elif isinstance(values, PeriodIndex):
+                return values.asfreq(axis.freq).asi8
+            elif isinstance(values, Index):
+                return values.map(lambda x: get_datevalue(x, axis.freq))
+            elif lib.infer_dtype(values, skipna=False) == 'period':
+                return PeriodIndex(values, freq=axis.freq).asi8
+            elif isinstance(values, (list, tuple, np.ndarray, Index)):
+                return [get_datevalue(x, axis.freq) for x in values]
+        return values
+
+def get_datevalue(date, freq):
+    if isinstance(date, Period):
+        return date.asfreq(freq).ordinal
+    elif isinstance(date, (str, datetime, pydt.date, pydt.time, np.datetime64)):
+        return Period(date, freq).ordinal
+    elif is_integer(date) or is_float(date) or (isinstance(date, (np.ndarray, Index)) and date.size == 1):
+        return date
+    elif date is None:
+        return None
+    raise ValueError(f"Unrecognizable date '{date}'")
+
+class DatetimeConverter(mdates.DateConverter):
+
+    @staticmethod
+    def convert(values, unit, axis):
+        if is_nested_list_like(values):
+            values = [DatetimeConverter._convert_1d(v, unit, axis) for v in values]
+        else:
+            values = DatetimeConverter._convert_1d(values, unit, axis)
+        return values
+
+    @staticmethod
+    def _convert_1d(values, unit, axis):
+
+        def try_parse(values):
+            try:
+                return mdates.date2num(tools.to_datetime(values))
+            except Exception:
+                return values
+        if isinstance(values, (datetime, pydt.date, np.datetime64, pydt.time)):
+            return mdates.date2num(values)
+        elif is_integer(values) or is_float(values):
+            return values
+        elif isinstance(values, str):
+            return try_parse(values)
+        elif isinstance(values, (list, tuple, np.ndarray, Index, Series)):
+            if isinstance(values, Series):
+                values = Index(values)
+            if isinstance(values, Index):
+                values = values.values
+            if not isinstance(values, np.ndarray):
+                values = com.asarray_tuplesafe(values)
+            if is_integer_dtype(values) or is_float_dtype(values):
+                return values
+            try:
+                values = tools.to_datetime(values)
+            except Exception:
+                pass
+            values = mdates.date2num(values)
+        return values
+
+    @staticmethod
+    def axisinfo(unit: tzinfo | None, axis) -> munits.AxisInfo:
+        tz = unit
+        majloc = PandasAutoDateLocator(tz=tz)
+        majfmt = PandasAutoDateFormatter(majloc, tz=tz)
+        datemin = pydt.date(2000, 1, 1)
+        datemax = pydt.date(2010, 1, 1)
+        return munits.AxisInfo(majloc=majloc, majfmt=majfmt, label='', default_limits=(datemin, datemax))
+
+class PandasAutoDateFormatter(mdates.AutoDateFormatter):
+
+    def __init__(self, locator, tz=None, defaultfmt: str='%Y-%m-%d') -> None:
+        mdates.AutoDateFormatter.__init__(self, locator, tz, defaultfmt)
+
+class PandasAutoDateLocator(mdates.AutoDateLocator):
+
+    def get_locator(self, dmin, dmax):
+        tot_sec = (dmax - dmin).total_seconds()
+        if abs(tot_sec) < self.minticks:
+            self._freq = -1
+            locator = MilliSecondLocator(self.tz)
+            locator.set_axis(self.axis)
+            locator.axis.set_view_interval(*self.axis.get_view_interval())
+            locator.axis.set_data_interval(*self.axis.get_data_interval())
+            return locator
+        return mdates.AutoDateLocator.get_locator(self, dmin, dmax)
+
+    def _get_unit(self):
+        return MilliSecondLocator.get_unit_generic(self._freq)
+
+class MilliSecondLocator(mdates.DateLocator):
+    UNIT = 1.0 / (24 * 3600 * 1000)
+
+    def __init__(self, tz) -> None:
+        mdates.DateLocator.__init__(self, tz)
+        self._interval = 1.0
+
+    def _get_unit(self):
+        return self.get_unit_generic(-1)
+
+    @staticmethod
+    def get_unit_generic(freq):
+        unit = mdates.RRuleLocator.get_unit_generic(freq)
+        if unit < 0:
+            return MilliSecondLocator.UNIT
+        return unit
+
+    def __call__(self):
+        try:
+            (dmin, dmax) = self.viewlim_to_dt()
+        except ValueError:
+            return []
+        (nmax, nmin) = mdates.date2num((dmax, dmin))
+        num = (nmax - nmin) * 86400 * 1000
+        max_millis_ticks = 6
+        for interval in [1, 10, 50, 100, 200, 500]:
+            if num <= interval * (max_millis_ticks - 1):
+                self._interval = interval
+                break
+            self._interval = 1000.0
+        estimate = (nmax - nmin) / (self._get_unit() * self._get_interval())
+        if estimate > self.MAXTICKS * 2:
+            raise RuntimeError(f'MillisecondLocator estimated to generate {estimate:d} ticks from {dmin} to {dmax}: exceeds Locator.MAXTICKS* 2 ({self.MAXTICKS * 2:d}) ')
+        interval = self._get_interval()
+        freq = f'{interval}ms'
+        tz = self.tz.tzname(None)
+        st = dmin.replace(tzinfo=None)
+        ed = dmax.replace(tzinfo=None)
+        all_dates = date_range(start=st, end=ed, freq=freq, tz=tz).astype(object)
+        try:
+            if len(all_dates) > 0:
+                locs = self.raise_if_exceeds(mdates.date2num(all_dates))
+                return locs
+        except Exception:
+            pass
+        lims = mdates.date2num([dmin, dmax])
+        return lims
+
+    def _get_interval(self):
+        return self._interval
+
+    def autoscale(self):
+        (dmin, dmax) = self.datalim_to_dt()
+        vmin = mdates.date2num(dmin)
+        vmax = mdates.date2num(dmax)
+        return self.nonsingular(vmin, vmax)
+
+def _get_default_annual_spacing(nyears) -> tuple[int, int]:
+    if nyears < 11:
+        (min_spacing, maj_spacing) = (1, 1)
+    elif nyears < 20:
+        (min_spacing, maj_spacing) = (1, 2)
+    elif nyears < 50:
+        (min_spacing, maj_spacing) = (1, 5)
+    elif nyears < 100:
+        (min_spacing, maj_spacing) = (5, 10)
+    elif nyears < 200:
+        (min_spacing, maj_spacing) = (5, 25)
+    elif nyears < 600:
+        (min_spacing, maj_spacing) = (10, 50)
+    else:
+        factor = nyears // 1000 + 1
+        (min_spacing, maj_spacing) = (factor * 20, factor * 100)
+    return (min_spacing, maj_spacing)
+
+def _period_break(dates: PeriodIndex, period: str) -> npt.NDArray[np.intp]:
+    mask = _period_break_mask(dates, period)
+    return np.nonzero(mask)[0]
+
+def _period_break_mask(dates: PeriodIndex, period: str) -> npt.NDArray[np.bool_]:
+    current = getattr(dates, period)
+    previous = getattr(dates - 1 * dates.freq, period)
+    return current != previous
+
+def has_level_label(label_flags: npt.NDArray[np.intp], vmin: float) -> bool:
+    if label_flags.size == 0 or (label_flags.size == 1 and label_flags[0] == 0 and (vmin % 1 > 0.0)):
+        return False
+    else:
+        return True
+
+def _get_periods_per_ymd(freq: BaseOffset) -> tuple[int, int, int]:
+    dtype_code = freq._period_dtype_code
+    freq_group = FreqGroup.from_period_dtype_code(dtype_code)
+    ppd = -1
+    if dtype_code >= FreqGroup.FR_HR.value:
+        ppd = periods_per_day(freq._creso)
+        ppm = 28 * ppd
+        ppy = 365 * ppd
+    elif freq_group == FreqGroup.FR_BUS:
+        ppm = 19
+        ppy = 261
+    elif freq_group == FreqGroup.FR_DAY:
+        ppm = 28
+        ppy = 365
+    elif freq_group == FreqGroup.FR_WK:
+        ppm = 3
+        ppy = 52
+    elif freq_group == FreqGroup.FR_MTH:
+        ppm = 1
+        ppy = 12
+    elif freq_group == FreqGroup.FR_QTR:
+        ppm = -1
+        ppy = 4
+    elif freq_group == FreqGroup.FR_ANN:
+        ppm = -1
+        ppy = 1
+    else:
+        raise NotImplementedError(f'Unsupported frequency: {dtype_code}')
+    return (ppd, ppm, ppy)
+
+@functools.cache
+def _daily_finder(vmin: float, vmax: float, freq: BaseOffset) -> np.ndarray:
+    dtype_code = freq._period_dtype_code
+    (periodsperday, periodspermonth, periodsperyear) = _get_periods_per_ymd(freq)
+    vmin_orig = vmin
+    (vmin, vmax) = (int(vmin), int(vmax))
+    span = vmax - vmin + 1
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', 'Period with BDay freq is deprecated', category=FutureWarning)
+        warnings.filterwarnings('ignore', 'PeriodDtype\\[B\\] is deprecated', category=FutureWarning)
+        dates_ = period_range(start=Period(ordinal=vmin, freq=freq), end=Period(ordinal=vmax, freq=freq), freq=freq)
+    info = np.zeros(span, dtype=[('val', np.int64), ('maj', bool), ('min', bool), ('fmt', '|S20')])
+    info['val'][:] = dates_.asi8
+    info['fmt'][:] = ''
+    info['maj'][[0, -1]] = True
+    info_maj = info['maj']
+    info_min = info['min']
+    info_fmt = info['fmt']
+
+    def first_label(label_flags):
+        if label_flags[0] == 0 and label_flags.size > 1 and (vmin_orig % 1 > 0.0):
+            return label_flags[1]
+        else:
+            return label_flags[0]
+    if span <= periodspermonth:
+        day_start = _period_break(dates_, 'day')
+        month_start = _period_break(dates_, 'month')
+        year_start = _period_break(dates_, 'year')
+
+        def _hour_finder(label_interval: int, force_year_start: bool) -> None:
+            target = dates_.hour
+            mask = _period_break_mask(dates_, 'hour')
+            info_maj[day_start] = True
+            info_min[mask & (target % label_interval == 0)] = True
+            info_fmt[mask & (target % label_interval == 0)] = '%H:%M'
+            info_fmt[day_start] = '%H:%M\n%d-%b'
+            info_fmt[year_start] = '%H:%M\n%d-%b\n%Y'
+            if force_year_start and (not has_level_label(year_start, vmin_orig)):
+                info_fmt[first_label(day_start)] = '%H:%M\n%d-%b\n%Y'
+
+        def _minute_finder(label_interval: int) -> None:
+            target = dates_.minute
+            hour_start = _period_break(dates_, 'hour')
+            mask = _period_break_mask(dates_, 'minute')
+            info_maj[hour_start] = True
+            info_min[mask & (target % label_interval == 0)] = True
+            info_fmt[mask & (target % label_interval == 0)] = '%H:%M'
+            info_fmt[day_start] = '%H:%M\n%d-%b'
+            info_fmt[year_start] = '%H:%M\n%d-%b\n%Y'
+
+        def _second_finder(label_interval: int) -> None:
+            target = dates_.second
+            minute_start = _period_break(dates_, 'minute')
+            mask = _period_break_mask(dates_, 'second')
+            info_maj[minute_start] = True
+            info_min[mask & (target % label_interval == 0)] = True
+            info_fmt[mask & (target % label_interval == 0)] = '%H:%M:%S'
+            info_fmt[day_start] = '%H:%M:%S\n%d-%b'
+            info_fmt[year_start] = '%H:%M:%S\n%d-%b\n%Y'
+        if span < periodsperday / 12000:
+            _second_finder(1)
+        elif span < periodsperday / 6000:
+            _second_finder(2)
+        elif span < periodsperday / 2400:
+            _second_finder(5)
+        elif span < periodsperday / 1200:
+            _second_finder(10)
+        elif span < periodsperday / 800:
+            _second_finder(15)
+        elif span < periodsperday / 400:
+            _second_finder(30)
+        elif span < periodsperday / 150:
+            _minute_finder(1)
+        elif span < periodsperday / 70:
+            _minute_finder(2)
+        elif span < periodsperday / 24:
+            _minute_finder(5)
+        elif span < periodsperday / 12:
+            _minute_finder(15)
+        elif span < periodsperday / 6:
+            _minute_finder(30)
+        elif span < periodsperday / 2.5:
+            _hour_finder(1, False)
+        elif span < periodsperday / 1.5:
+            _hour_finder(2, False)
+        elif span < periodsperday * 1.25:
+            _hour_finder(3, False)
+        elif span < periodsperday * 2.5:
+            _hour_finder(6, True)
+        elif span < periodsperday * 4:
+            _hour_finder(12, True)
+        else:
+            info_maj[month_start] = True
+            info_min[day_start] = True
+            info_fmt[day_start] = '%d'
+            info_fmt[month_start] = '%d\n%b'
+            info_fmt[year_start] = '%d\n%b\n%Y'
+            if not has_level_label(year_start, vmin_orig):
+                if not has_level_label(month_start, vmin_orig):
+                    info_fmt[first_label(day_start)] = '%d\n%b\n%Y'
+                else:
+                    info_fmt[first_label(month_start)] = '%d\n%b\n%Y'
+    elif span <= periodsperyear // 4:
+        month_start = _period_break(dates_, 'month')
+        info_maj[month_start] = True
+        if dtype_code < FreqGroup.FR_HR.value:
+            info['min'] = True
+        else:
+            day_start = _period_break(dates_, 'day')
+            info['min'][day_start] = True
+        week_start = _period_break(dates_, 'week')
+        year_start = _period_break(dates_, 'year')
+        info_fmt[week_start] = '%d'
+        info_fmt[month_start] = '\n\n%b'
+        info_fmt[year_start] = '\n\n%b\n%Y'
+        if not has_level_label(year_start, vmin_orig):
+            if not has_level_label(month_start, vmin_orig):
+                info_fmt[first_label(week_start)] = '\n\n%b\n%Y'
+            else:
+                info_fmt[first_label(month_start)] = '\n\n%b\n%Y'
+    elif span <= 1.15 * periodsperyear:
+        year_start = _period_break(dates_, 'year')
+        month_start = _period_break(dates_, 'month')
+        week_start = _period_break(dates_, 'week')
+        info_maj[month_start] = True
+        info_min[week_start] = True
+        info_min[year_start] = False
+        info_min[month_start] = False
+        info_fmt[month_start] = '%b'
+        info_fmt[year_start] = '%b\n%Y'
+        if not has_level_label(year_start, vmin_orig):
+            info_fmt[first_label(month_start)] = '%b\n%Y'
+    elif span <= 2.5 * periodsperyear:
+        year_start = _period_break(dates_, 'year')
+        quarter_start = _period_break(dates_, 'quarter')
+        month_start = _period_break(dates_, 'month')
+        info_maj[quarter_start] = True
+        info_min[month_start] = True
+        info_fmt[quarter_start] = '%b'
+        info_fmt[year_start] = '%b\n%Y'
+    elif span <= 4 * periodsperyear:
+        year_start = _period_break(dates_, 'year')
+        month_start = _period_break(dates_, 'month')
+        info_maj[year_start] = True
+        info_min[month_start] = True
+        info_min[year_start] = False
+        month_break = dates_[month_start].month
+        jan_or_jul = month_start[(month_break == 1) | (month_break == 7)]
+        info_fmt[jan_or_jul] = '%b'
+        info_fmt[year_start] = '%b\n%Y'
+    elif span <= 11 * periodsperyear:
+        year_start = _period_break(dates_, 'year')
+        quarter_start = _period_break(dates_, 'quarter')
+        info_maj[year_start] = True
+        info_min[quarter_start] = True
+        info_min[year_start] = False
+        info_fmt[year_start] = '%Y'
+    else:
+        year_start = _period_break(dates_, 'year')
+        year_break = dates_[year_start].year
+        nyears = span / periodsperyear
+        (min_anndef, maj_anndef) = _get_default_annual_spacing(nyears)
+        major_idx = year_start[year_break % maj_anndef == 0]
+        info_maj[major_idx] = True
+        minor_idx = year_start[year_break % min_anndef == 0]
+        info_min[minor_idx] = True
+        info_fmt[major_idx] = '%Y'
+    return info
+
+@functools.cache
+def _monthly_finder(vmin: float, vmax: float, freq: BaseOffset) -> np.ndarray:
+    (_, _, periodsperyear) = _get_periods_per_ymd(freq)
+    vmin_orig = vmin
+    (vmin, vmax) = (int(vmin), int(vmax))
+    span = vmax - vmin + 1
+    info = np.zeros(span, dtype=[('val', int), ('maj', bool), ('min', bool), ('fmt', '|S8')])
+    info['val'] = np.arange(vmin, vmax + 1)
+    dates_ = info['val']
+    info['fmt'] = ''
+    year_start = (dates_ % 12 == 0).nonzero()[0]
+    info_maj = info['maj']
+    info_fmt = info['fmt']
+    if span <= 1.15 * periodsperyear:
+        info_maj[year_start] = True
+        info['min'] = True
+        info_fmt[:] = '%b'
+        info_fmt[year_start] = '%b\n%Y'
+        if not has_level_label(year_start, vmin_orig):
+            if dates_.size > 1:
+                idx = 1
+            else:
+                idx = 0
+            info_fmt[idx] = '%b\n%Y'
+    elif span <= 2.5 * periodsperyear:
+        quarter_start = (dates_ % 3 == 0).nonzero()
+        info_maj[year_start] = True
+        info['fmt'][quarter_start] = True
+        info['min'] = True
+        info_fmt[quarter_start] = '%b'
+        info_fmt[year_start] = '%b\n%Y'
+    elif span <= 4 * periodsperyear:
+        info_maj[year_start] = True
+        info['min'] = True
+        jan_or_jul = (dates_ % 12 == 0) | (dates_ % 12 == 6)
+        info_fmt[jan_or_jul] = '%b'
+        info_fmt[year_start] = '%b\n%Y'
+    elif span <= 11 * periodsperyear:
+        quarter_start = (dates_ % 3 == 0).nonzero()
+        info_maj[year_start] = True
+        info['min'][quarter_start] = True
+        info_fmt[year_start] = '%Y'
+    else:
+        nyears = span / periodsperyear
+        (min_anndef, maj_anndef) = _get_default_annual_spacing(nyears)
+        years = dates_[year_start] // 12 + 1
+        major_idx = year_start[years % maj_anndef == 0]
+        info_maj[major_idx] = True
+        info['min'][year_start[years % min_anndef == 0]] = True
+        info_fmt[major_idx] = '%Y'
+    return info
+
+@functools.cache
+def _quarterly_finder(vmin: float, vmax: float, freq: BaseOffset) -> np.ndarray:
+    (_, _, periodsperyear) = _get_periods_per_ymd(freq)
+    vmin_orig = vmin
+    (vmin, vmax) = (int(vmin), int(vmax))
+    span = vmax - vmin + 1
+    info = np.zeros(span, dtype=[('val', int), ('maj', bool), ('min', bool), ('fmt', '|S8')])
+    info['val'] = np.arange(vmin, vmax + 1)
+    info['fmt'] = ''
+    dates_ = info['val']
+    info_maj = info['maj']
+    info_fmt = info['fmt']
+    year_start = (dates_ % 4 == 0).nonzero()[0]
+    if span <= 3.5 * periodsperyear:
+        info_maj[year_start] = True
+        info['min'] = True
+        info_fmt[:] = 'Q%q'
+        info_fmt[year_start] = 'Q%q\n%F'
+        if not has_level_label(year_start, vmin_orig):
+            if dates_.size > 1:
+                idx = 1
+            else:
+                idx = 0
+            info_fmt[idx] = 'Q%q\n%F'
+    elif span <= 11 * periodsperyear:
+        info_maj[year_start] = True
+        info['min'] = True
+        info_fmt[year_start] = '%F'
+    else:
+        years = dates_[year_start] // 4 + 1970
+        nyears = span / periodsperyear
+        (min_anndef, maj_anndef) = _get_default_annual_spacing(nyears)
+        major_idx = year_start[years % maj_anndef == 0]
+        info_maj[major_idx] = True
+        info['min'][year_start[years % min_anndef == 0]] = True
+        info_fmt[major_idx] = '%F'
+    return info
+
+@functools.cache
+def _annual_finder(vmin: float, vmax: float, freq: BaseOffset) -> np.ndarray:
+    (vmin, vmax) = (int(vmin), int(vmax + 1))
+    span = vmax - vmin + 1
+    info = np.zeros(span, dtype=[('val', int), ('maj', bool), ('min', bool), ('fmt', '|S8')])
+    info['val'] = np.arange(vmin, vmax + 1)
+    info['fmt'] = ''
+    dates_ = info['val']
+    (min_anndef, maj_anndef) = _get_default_annual_spacing(span)
+    major_idx = dates_ % maj_anndef == 0
+    minor_idx = dates_ % min_anndef == 0
+    info['maj'][major_idx] = True
+    info['min'][minor_idx] = True
+    info['fmt'][major_idx] = '%Y'
+    return info
+
+def get_finder(freq: BaseOffset):
+    dtype_code = freq._period_dtype_code
+    fgroup = FreqGroup.from_period_dtype_code(dtype_code)
+    if fgroup == FreqGroup.FR_ANN:
+        return _annual_finder
+    elif fgroup == FreqGroup.FR_QTR:
+        return _quarterly_finder
+    elif fgroup == FreqGroup.FR_MTH:
+        return _monthly_finder
+    elif dtype_code >= FreqGroup.FR_BUS.value or fgroup == FreqGroup.FR_WK:
+        return _daily_finder
+    else:
+        raise NotImplementedError(f'Unsupported frequency: {dtype_code}')
+
+class TimeSeries_DateLocator(mpl.ticker.Locator):
+    axis: Axis
+
+    def __init__(self, freq: BaseOffset, minor_locator: bool=False, dynamic_mode: bool=True, base: int=1, quarter: int=1, month: int=1, day: int=1, plot_obj=None) -> None:
+        freq = to_offset(freq, is_period=True)
+        self.freq = freq
+        self.base = base
+        (self.quarter, self.month, self.day) = (quarter, month, day)
+        self.isminor = minor_locator
+        self.isdynamic = dynamic_mode
+        self.offset = 0
+        self.plot_obj = plot_obj
+        self.finder = get_finder(freq)
+
+    def _get_default_locs(self, vmin, vmax):
+        locator = self.finder(vmin, vmax, self.freq)
+        if self.isminor:
+            return np.compress(locator['min'], locator['val'])
+        return np.compress(locator['maj'], locator['val'])
+
+    def __call__(self):
+        vi = tuple(self.axis.get_view_interval())
+        (vmin, vmax) = vi
+        if vmax < vmin:
+            (vmin, vmax) = (vmax, vmin)
+        if self.isdynamic:
+            locs = self._get_default_locs(vmin, vmax)
+        else:
+            base = self.base
+            (d, m) = divmod(vmin, base)
+            vmin = (d + 1) * base
+            locs = list(range(vmin, vmax + 1, base))
+        return locs
+
+    def autoscale(self):
+        (vmin, vmax) = self.axis.get_data_interval()
+        locs = self._get_default_locs(vmin, vmax)
+        (vmin, vmax) = locs[[0, -1]]
+        if vmin == vmax:
+            vmin -= 1
+            vmax += 1
+        return mpl.transforms.nonsingular(vmin, vmax)
+
+class TimeSeries_DateFormatter(mpl.ticker.Formatter):
+    axis: Axis
+
+    def __init__(self, freq: BaseOffset, minor_locator: bool=False, dynamic_mode: bool=True, plot_obj=None) -> None:
+        freq = to_offset(freq, is_period=True)
+        self.format = None
+        self.freq = freq
+        self.locs: list[Any] = []
+        self.formatdict: dict[Any, Any] | None = None
+        self.isminor = minor_locator
+        self.isdynamic = dynamic_mode
+        self.offset = 0
+        self.plot_obj = plot_obj
+        self.finder = get_finder(freq)
+
+    def _set_default_format(self, vmin, vmax):
+        info = self.finder(vmin, vmax, self.freq)
+        if self.isminor:
+            format = np.compress(info['min'] & np.logical_not(info['maj']), info)
+        else:
+            format = np.compress(info['maj'], info)
+        self.formatdict = {x: f for (x, _, _, f) in format}
+        return self.formatdict
+
+    def set_locs(self, locs) -> None:
+        self.locs = locs
+        (vmin, vmax) = tuple(self.axis.get_view_interval())
+        if vmax < vmin:
+            (vmin, vmax) = (vmax, vmin)
+        self._set_default_format(vmin, vmax)
+
+    def __call__(self, x, pos: int | None=0) -> str:
+        if self.formatdict is None:
+            return ''
+        else:
+            fmt = self.formatdict.pop(x, '')
+            if isinstance(fmt, np.bytes_):
+                fmt = fmt.decode('utf-8')
+            with warnings.catch_warnings():
+                warnings.filterwarnings('ignore', 'Period with BDay freq is deprecated', category=FutureWarning)
+                period = Period(ordinal=int(x), freq=self.freq)
+            assert isinstance(period, Period)
+            return period.strftime(fmt)
+
+class TimeSeries_TimedeltaFormatter(mpl.ticker.Formatter):
+    axis: Axis
+
+    @staticmethod
+    def format_timedelta_ticks(x, pos, n_decimals: int) -> str:
+        (s, ns) = divmod(x, 10 ** 9)
+        (m, s) = divmod(s, 60)
+        (h, m) = divmod(m, 60)
+        (d, h) = divmod(h, 24)
+        decimals = int(ns * 10 ** (n_decimals - 9))
+        s = f'{int(h):02d}:{int(m):02d}:{int(s):02d}'
+        if n_decimals > 0:
+            s += f'.{decimals:0{n_decimals}d}'
+        if d != 0:
+            s = f'{int(d):d} days {s}'
+        return s
+
+    def __call__(self, x, pos: int | None=0) -> str:
+        (vmin, vmax) = tuple(self.axis.get_view_interval())
+        n_decimals = min(int(np.ceil(np.log10(100 * 10 ** 9 / abs(vmax - vmin)))), 9)
+        return self.format_timedelta_ticks(x, pos, n_decimals)
+
+# File: pandas-main/pandas/plotting/_matplotlib/core.py
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from collections.abc import Hashable, Iterable, Iterator, Sequence
+from typing import TYPE_CHECKING, Any, Literal, cast, final
+import warnings
+import matplotlib as mpl
+import numpy as np
+from pandas._libs import lib
+from pandas.errors import AbstractMethodError
+from pandas.util._decorators import cache_readonly
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import is_any_real_numeric_dtype, is_bool, is_float, is_float_dtype, is_hashable, is_integer, is_integer_dtype, is_iterator, is_list_like, is_number, is_numeric_dtype
+from pandas.core.dtypes.dtypes import CategoricalDtype, ExtensionDtype
+from pandas.core.dtypes.generic import ABCDataFrame, ABCDatetimeIndex, ABCIndex, ABCMultiIndex, ABCPeriodIndex, ABCSeries
+from pandas.core.dtypes.missing import isna
+import pandas.core.common as com
+from pandas.util.version import Version
+from pandas.io.formats.printing import pprint_thing
+from pandas.plotting._matplotlib import tools
+from pandas.plotting._matplotlib.converter import register_pandas_matplotlib_converters
+from pandas.plotting._matplotlib.groupby import reconstruct_data_with_by
+from pandas.plotting._matplotlib.misc import unpack_single_str_list
+from pandas.plotting._matplotlib.style import get_standard_colors
+from pandas.plotting._matplotlib.timeseries import decorate_axes, format_dateaxis, maybe_convert_index, maybe_resample, use_dynamic_x
+from pandas.plotting._matplotlib.tools import create_subplots, flatten_axes, format_date_labels, get_all_lines, get_xlim, handle_shared_axes
+if TYPE_CHECKING:
+    from matplotlib.artist import Artist
+    from matplotlib.axes import Axes
+    from matplotlib.axis import Axis
+    from matplotlib.figure import Figure
+    from pandas._typing import IndexLabel, NDFrameT, PlottingOrientation, npt
+    from pandas import DataFrame, Index, Series
+
+def holds_integer(column: Index) -> bool:
+    return column.inferred_type in {'integer', 'mixed-integer'}
+
+def _color_in_style(style: str) -> bool:
+    return not set(mpl.colors.BASE_COLORS).isdisjoint(style)
+
+class MPLPlot(ABC):
+
+    @property
+    @abstractmethod
+    def _kind(self) -> str:
+        raise NotImplementedError
+    _layout_type = 'vertical'
+    _default_rot = 0
+
+    @property
+    def orientation(self) -> str | None:
+        return None
+    data: DataFrame
+
+    def __init__(self, data, kind=None, by: IndexLabel | None=None, subplots: bool | Sequence[Sequence[str]]=False, sharex: bool | None=None, sharey: bool=False, use_index: bool=True, figsize: tuple[float, float] | None=None, grid=None, legend: bool | str=True, rot=None, ax=None, fig=None, title=None, xlim=None, ylim=None, xticks=None, yticks=None, xlabel: Hashable | None=None, ylabel: Hashable | None=None, fontsize: int | None=None, secondary_y: bool | tuple | list | np.ndarray=False, colormap=None, table: bool=False, layout=None, include_bool: bool=False, column: IndexLabel | None=None, *, logx: bool | None | Literal['sym']=False, logy: bool | None | Literal['sym']=False, loglog: bool | None | Literal['sym']=False, mark_right: bool=True, stacked: bool=False, label: Hashable | None=None, style=None, **kwds) -> None:
+        if by in ([], ()):
+            raise ValueError('No group keys passed!')
+        self.by = com.maybe_make_list(by)
+        if isinstance(data, ABCDataFrame):
+            if column:
+                self.columns = com.maybe_make_list(column)
+            elif self.by is None:
+                self.columns = [col for col in data.columns if is_numeric_dtype(data[col])]
+            else:
+                self.columns = [col for col in data.columns if col not in self.by and is_numeric_dtype(data[col])]
+        if self.by is not None and self._kind == 'hist':
+            self._grouped = data.groupby(unpack_single_str_list(self.by))
+        self.kind = kind
+        self.subplots = type(self)._validate_subplots_kwarg(subplots, data, kind=self._kind)
+        self.sharex = type(self)._validate_sharex(sharex, ax, by)
+        self.sharey = sharey
+        self.figsize = figsize
+        self.layout = layout
+        self.xticks = xticks
+        self.yticks = yticks
+        self.xlim = xlim
+        self.ylim = ylim
+        self.title = title
+        self.use_index = use_index
+        self.xlabel = xlabel
+        self.ylabel = ylabel
+        self.fontsize = fontsize
+        if rot is not None:
+            self.rot = rot
+            self._rot_set = True
+        else:
+            self._rot_set = False
+            self.rot = self._default_rot
+        if grid is None:
+            grid = False if secondary_y else mpl.rcParams['axes.grid']
+        self.grid = grid
+        self.legend = legend
+        self.legend_handles: list[Artist] = []
+        self.legend_labels: list[Hashable] = []
+        self.logx = type(self)._validate_log_kwd('logx', logx)
+        self.logy = type(self)._validate_log_kwd('logy', logy)
+        self.loglog = type(self)._validate_log_kwd('loglog', loglog)
+        self.label = label
+        self.style = style
+        self.mark_right = mark_right
+        self.stacked = stacked
+        self.ax = ax
+        xerr = kwds.pop('xerr', None)
+        yerr = kwds.pop('yerr', None)
+        nseries = self._get_nseries(data)
+        (xerr, data) = type(self)._parse_errorbars('xerr', xerr, data, nseries)
+        (yerr, data) = type(self)._parse_errorbars('yerr', yerr, data, nseries)
+        self.errors = {'xerr': xerr, 'yerr': yerr}
+        self.data = data
+        if not isinstance(secondary_y, (bool, tuple, list, np.ndarray, ABCIndex)):
+            secondary_y = [secondary_y]
+        self.secondary_y = secondary_y
+        if 'cmap' in kwds and colormap:
+            raise TypeError('Only specify one of `cmap` and `colormap`.')
+        if 'cmap' in kwds:
+            self.colormap = kwds.pop('cmap')
+        else:
+            self.colormap = colormap
+        self.table = table
+        self.include_bool = include_bool
+        self.kwds = kwds
+        color = kwds.pop('color', lib.no_default)
+        self.color = self._validate_color_args(color, self.colormap)
+        assert 'color' not in self.kwds
+        self.data = self._ensure_frame(self.data)
+
+    @final
+    @staticmethod
+    def _validate_sharex(sharex: bool | None, ax, by) -> bool:
+        if sharex is None:
+            if ax is None and by is None:
+                sharex = True
+            else:
+                sharex = False
+        elif not is_bool(sharex):
+            raise TypeError('sharex must be a bool or None')
+        return bool(sharex)
+
+    @classmethod
+    def _validate_log_kwd(cls, kwd: str, value: bool | None | Literal['sym']) -> bool | None | Literal['sym']:
+        if value is None or isinstance(value, bool) or (isinstance(value, str) and value == 'sym'):
+            return value
+        raise ValueError(f"keyword '{kwd}' should be bool, None, or 'sym', not '{value}'")
+
+    @final
+    @staticmethod
+    def _validate_subplots_kwarg(subplots: bool | Sequence[Sequence[str]], data: Series | DataFrame, kind: str) -> bool | list[tuple[int, ...]]:
+        if isinstance(subplots, bool):
+            return subplots
+        elif not isinstance(subplots, Iterable):
+            raise ValueError('subplots should be a bool or an iterable')
+        supported_kinds = ('line', 'bar', 'barh', 'hist', 'kde', 'density', 'area', 'pie')
+        if kind not in supported_kinds:
+            raise ValueError(f"When subplots is an iterable, kind must be one of {', '.join(supported_kinds)}. Got {kind}.")
+        if isinstance(data, ABCSeries):
+            raise NotImplementedError('An iterable subplots for a Series is not supported.')
+        columns = data.columns
+        if isinstance(columns, ABCMultiIndex):
+            raise NotImplementedError('An iterable subplots for a DataFrame with a MultiIndex column is not supported.')
+        if columns.nunique() != len(columns):
+            raise NotImplementedError('An iterable subplots for a DataFrame with non-unique column labels is not supported.')
+        out = []
+        seen_columns: set[Hashable] = set()
+        for group in subplots:
+            if not is_list_like(group):
+                raise ValueError('When subplots is an iterable, each entry should be a list/tuple of column names.')
+            idx_locs = columns.get_indexer_for(group)
+            if (idx_locs == -1).any():
+                bad_labels = np.extract(idx_locs == -1, group)
+                raise ValueError(f'Column label(s) {list(bad_labels)} not found in the DataFrame.')
+            unique_columns = set(group)
+            duplicates = seen_columns.intersection(unique_columns)
+            if duplicates:
+                raise ValueError(f'Each column should be in only one subplot. Columns {duplicates} were found in multiple subplots.')
+            seen_columns = seen_columns.union(unique_columns)
+            out.append(tuple(idx_locs))
+        unseen_columns = columns.difference(seen_columns)
+        for column in unseen_columns:
+            idx_loc = columns.get_loc(column)
+            out.append((idx_loc,))
+        return out
+
+    def _validate_color_args(self, color, colormap):
+        if color is lib.no_default:
+            if 'colors' in self.kwds and colormap is not None:
+                warnings.warn("'color' and 'colormap' cannot be used simultaneously. Using 'color'", stacklevel=find_stack_level())
+            return None
+        if self.nseries == 1 and color is not None and (not is_list_like(color)):
+            color = [color]
+        if isinstance(color, tuple) and self.nseries == 1 and (len(color) in (3, 4)):
+            color = [color]
+        if colormap is not None:
+            warnings.warn("'color' and 'colormap' cannot be used simultaneously. Using 'color'", stacklevel=find_stack_level())
+        if self.style is not None:
+            if isinstance(self.style, dict):
+                styles = [self.style[col] for col in self.columns if col in self.style]
+            elif is_list_like(self.style):
+                styles = self.style
+            else:
+                styles = [self.style]
+            for s in styles:
+                if _color_in_style(s):
+                    raise ValueError("Cannot pass 'style' string with a color symbol and 'color' keyword argument. Please use one or the other or pass 'style' without a color symbol")
+        return color
+
+    @final
+    @staticmethod
+    def _iter_data(data: DataFrame | dict[Hashable, Series | DataFrame]) -> Iterator[tuple[Hashable, np.ndarray]]:
+        for (col, values) in data.items():
+            yield (col, np.asarray(values.values))
+
+    def _get_nseries(self, data: Series | DataFrame) -> int:
+        if data.ndim == 1:
+            return 1
+        elif self.by is not None and self._kind == 'hist':
+            return len(self._grouped)
+        elif self.by is not None and self._kind == 'box':
+            return len(self.columns)
+        else:
+            return data.shape[1]
+
+    @final
+    @property
+    def nseries(self) -> int:
+        return self._get_nseries(self.data)
+
+    @final
+    def generate(self) -> None:
+        self._compute_plot_data()
+        fig = self.fig
+        self._make_plot(fig)
+        self._add_table()
+        self._make_legend()
+        self._adorn_subplots(fig)
+        for ax in self.axes:
+            self._post_plot_logic_common(ax)
+            self._post_plot_logic(ax, self.data)
+
+    @final
+    @staticmethod
+    def _has_plotted_object(ax: Axes) -> bool:
+        return len(ax.lines) != 0 or len(ax.artists) != 0 or len(ax.containers) != 0
+
+    @final
+    def _maybe_right_yaxis(self, ax: Axes, axes_num: int) -> Axes:
+        if not self.on_right(axes_num):
+            return self._get_ax_layer(ax)
+        if hasattr(ax, 'right_ax'):
+            return ax.right_ax
+        elif hasattr(ax, 'left_ax'):
+            return ax
+        else:
+            (orig_ax, new_ax) = (ax, ax.twinx())
+            new_ax._get_lines = orig_ax._get_lines
+            new_ax._get_patches_for_fill = orig_ax._get_patches_for_fill
+            (orig_ax.right_ax, new_ax.left_ax) = (new_ax, orig_ax)
+            if not self._has_plotted_object(orig_ax):
+                orig_ax.get_yaxis().set_visible(False)
+            if self.logy is True or self.loglog is True:
+                new_ax.set_yscale('log')
+            elif self.logy == 'sym' or self.loglog == 'sym':
+                new_ax.set_yscale('symlog')
+            return new_ax
+
+    @final
+    @cache_readonly
+    def fig(self) -> Figure:
+        return self._axes_and_fig[1]
+
+    @final
+    @cache_readonly
+    def axes(self) -> Sequence[Axes]:
+        return self._axes_and_fig[0]
+
+    @final
+    @cache_readonly
+    def _axes_and_fig(self) -> tuple[Sequence[Axes], Figure]:
+        import matplotlib.pyplot as plt
+        if self.subplots:
+            naxes = self.nseries if isinstance(self.subplots, bool) else len(self.subplots)
+            (fig, axes) = create_subplots(naxes=naxes, sharex=self.sharex, sharey=self.sharey, figsize=self.figsize, ax=self.ax, layout=self.layout, layout_type=self._layout_type)
+        elif self.ax is None:
+            fig = plt.figure(figsize=self.figsize)
+            axes = fig.add_subplot(111)
+        else:
+            fig = self.ax.get_figure()
+            if self.figsize is not None:
+                fig.set_size_inches(self.figsize)
+            axes = self.ax
+        axes = np.fromiter(flatten_axes(axes), dtype=object)
+        if self.logx is True or self.loglog is True:
+            [a.set_xscale('log') for a in axes]
+        elif self.logx == 'sym' or self.loglog == 'sym':
+            [a.set_xscale('symlog') for a in axes]
+        if self.logy is True or self.loglog is True:
+            [a.set_yscale('log') for a in axes]
+        elif self.logy == 'sym' or self.loglog == 'sym':
+            [a.set_yscale('symlog') for a in axes]
+        axes_seq = cast(Sequence['Axes'], axes)
+        return (axes_seq, fig)
+
+    @property
+    def result(self):
+        if self.subplots:
+            if self.layout is not None and (not is_list_like(self.ax)):
+                return self.axes.reshape(*self.layout)
+            else:
+                return self.axes
+        else:
+            sec_true = isinstance(self.secondary_y, bool) and self.secondary_y
+            all_sec = is_list_like(self.secondary_y) and len(self.secondary_y) == self.nseries
+            if sec_true or all_sec:
+                return self._get_ax_layer(self.axes[0], primary=False)
+            else:
+                return self.axes[0]
+
+    @final
+    @staticmethod
+    def _convert_to_ndarray(data):
+        if isinstance(data.dtype, CategoricalDtype):
+            return data
+        if (is_integer_dtype(data.dtype) or is_float_dtype(data.dtype)) and isinstance(data.dtype, ExtensionDtype):
+            return data.to_numpy(dtype='float', na_value=np.nan)
+        if len(data) > 0:
+            return np.asarray(data)
+        return data
+
+    @final
+    def _ensure_frame(self, data) -> DataFrame:
+        if isinstance(data, ABCSeries):
+            label = self.label
+            if label is None and data.name is None:
+                label = ''
+            if label is None:
+                data = data.to_frame()
+            else:
+                data = data.to_frame(name=label)
+        elif self._kind in ('hist', 'box'):
+            cols = self.columns if self.by is None else self.columns + self.by
+            data = data.loc[:, cols]
+        return data
+
+    @final
+    def _compute_plot_data(self) -> None:
+        data = self.data
+        if self.by is not None:
+            self.subplots = True
+            data = reconstruct_data_with_by(self.data, by=self.by, cols=self.columns)
+        data = data.infer_objects()
+        include_type = [np.number, 'datetime', 'datetimetz', 'timedelta']
+        if self.include_bool is True:
+            include_type.append(np.bool_)
+        exclude_type = None
+        if self._kind == 'box':
+            include_type = [np.number]
+            exclude_type = ['timedelta']
+        if self._kind == 'scatter':
+            include_type.extend(['object', 'category', 'string'])
+        numeric_data = data.select_dtypes(include=include_type, exclude=exclude_type)
+        is_empty = numeric_data.shape[-1] == 0
+        if is_empty:
+            raise TypeError('no numeric data to plot')
+        self.data = numeric_data.apply(type(self)._convert_to_ndarray)
+
+    def _make_plot(self, fig: Figure) -> None:
+        raise AbstractMethodError(self)
+
+    @final
+    def _add_table(self) -> None:
+        if self.table is False:
+            return
+        elif self.table is True:
+            data = self.data.transpose()
+        else:
+            data = self.table
+        ax = self._get_ax(0)
+        tools.table(ax, data)
+
+    @final
+    def _post_plot_logic_common(self, ax: Axes) -> None:
+        if self.orientation == 'vertical' or self.orientation is None:
+            type(self)._apply_axis_properties(ax.xaxis, rot=self.rot, fontsize=self.fontsize)
+            type(self)._apply_axis_properties(ax.yaxis, fontsize=self.fontsize)
+            if hasattr(ax, 'right_ax'):
+                type(self)._apply_axis_properties(ax.right_ax.yaxis, fontsize=self.fontsize)
+        elif self.orientation == 'horizontal':
+            type(self)._apply_axis_properties(ax.yaxis, rot=self.rot, fontsize=self.fontsize)
+            type(self)._apply_axis_properties(ax.xaxis, fontsize=self.fontsize)
+            if hasattr(ax, 'right_ax'):
+                type(self)._apply_axis_properties(ax.right_ax.yaxis, fontsize=self.fontsize)
+        else:
+            raise ValueError
+
+    @abstractmethod
+    def _post_plot_logic(self, ax: Axes, data) -> None:
+
+    @final
+    def _adorn_subplots(self, fig: Figure) -> None:
+        if len(self.axes) > 0:
+            all_axes = self._get_subplots(fig)
+            (nrows, ncols) = self._get_axes_layout(fig)
+            handle_shared_axes(axarr=all_axes, nplots=len(all_axes), naxes=nrows * ncols, nrows=nrows, ncols=ncols, sharex=self.sharex, sharey=self.sharey)
+        for ax in self.axes:
+            ax = getattr(ax, 'right_ax', ax)
+            if self.yticks is not None:
+                ax.set_yticks(self.yticks)
+            if self.xticks is not None:
+                ax.set_xticks(self.xticks)
+            if self.ylim is not None:
+                ax.set_ylim(self.ylim)
+            if self.xlim is not None:
+                ax.set_xlim(self.xlim)
+            if self.ylabel is not None:
+                ax.set_ylabel(pprint_thing(self.ylabel))
+            ax.grid(self.grid)
+        if self.title:
+            if self.subplots:
+                if is_list_like(self.title):
+                    if len(self.title) != self.nseries:
+                        raise ValueError(f'The length of `title` must equal the number of columns if using `title` of type `list` and `subplots=True`.\nlength of title = {len(self.title)}\nnumber of columns = {self.nseries}')
+                    for (ax, title) in zip(self.axes, self.title):
+                        ax.set_title(title)
+                else:
+                    fig.suptitle(self.title)
+            else:
+                if is_list_like(self.title):
+                    msg = 'Using `title` of type `list` is not supported unless `subplots=True` is passed'
+                    raise ValueError(msg)
+                self.axes[0].set_title(self.title)
+
+    @final
+    @staticmethod
+    def _apply_axis_properties(axis: Axis, rot=None, fontsize: int | None=None) -> None:
+        if rot is not None or fontsize is not None:
+            labels = axis.get_majorticklabels() + axis.get_minorticklabels()
+            for label in labels:
+                if rot is not None:
+                    label.set_rotation(rot)
+                if fontsize is not None:
+                    label.set_fontsize(fontsize)
+
+    @final
+    @property
+    def legend_title(self) -> str | None:
+        if not isinstance(self.data.columns, ABCMultiIndex):
+            name = self.data.columns.name
+            if name is not None:
+                name = pprint_thing(name)
+            return name
+        else:
+            stringified = map(pprint_thing, self.data.columns.names)
+            return ','.join(stringified)
+
+    @final
+    def _mark_right_label(self, label: str, index: int) -> str:
+        if not self.subplots and self.mark_right and self.on_right(index):
+            label += ' (right)'
+        return label
+
+    @final
+    def _append_legend_handles_labels(self, handle: Artist, label: str) -> None:
+        self.legend_handles.append(handle)
+        self.legend_labels.append(label)
+
+    def _make_legend(self) -> None:
+        (ax, leg) = self._get_ax_legend(self.axes[0])
+        handles = []
+        labels = []
+        title = ''
+        if not self.subplots:
+            if leg is not None:
+                title = leg.get_title().get_text()
+                if Version(mpl.__version__) < Version('3.7'):
+                    handles = leg.legendHandles
+                else:
+                    handles = leg.legend_handles
+                labels = [x.get_text() for x in leg.get_texts()]
+            if self.legend:
+                if self.legend == 'reverse':
+                    handles += reversed(self.legend_handles)
+                    labels += reversed(self.legend_labels)
+                else:
+                    handles += self.legend_handles
+                    labels += self.legend_labels
+                if self.legend_title is not None:
+                    title = self.legend_title
+            if len(handles) > 0:
+                ax.legend(handles, labels, loc='best', title=title)
+        elif self.subplots and self.legend:
+            for ax in self.axes:
+                if ax.get_visible():
+                    with warnings.catch_warnings():
+                        warnings.filterwarnings('ignore', 'No artists with labels found to put in legend.', UserWarning)
+                        ax.legend(loc='best')
+
+    @final
+    @staticmethod
+    def _get_ax_legend(ax: Axes):
+        leg = ax.get_legend()
+        other_ax = getattr(ax, 'left_ax', None) or getattr(ax, 'right_ax', None)
+        other_leg = None
+        if other_ax is not None:
+            other_leg = other_ax.get_legend()
+        if leg is None and other_leg is not None:
+            leg = other_leg
+            ax = other_ax
+        return (ax, leg)
+    _need_to_set_index = False
+
+    @final
+    def _get_xticks(self):
+        index = self.data.index
+        is_datetype = index.inferred_type in ('datetime', 'date', 'datetime64', 'time')
+        x: list[int] | np.ndarray
+        if self.use_index:
+            if isinstance(index, ABCPeriodIndex):
+                x = index.to_timestamp()._mpl_repr()
+            elif is_any_real_numeric_dtype(index.dtype):
+                x = index._mpl_repr()
+            elif isinstance(index, ABCDatetimeIndex) or is_datetype:
+                x = index._mpl_repr()
+            else:
+                self._need_to_set_index = True
+                x = list(range(len(index)))
+        else:
+            x = list(range(len(index)))
+        return x
+
+    @classmethod
+    @register_pandas_matplotlib_converters
+    def _plot(cls, ax: Axes, x, y: np.ndarray, style=None, is_errorbar: bool=False, **kwds):
+        mask = isna(y)
+        if mask.any():
+            y = np.ma.array(y)
+            y = np.ma.masked_where(mask, y)
+        if isinstance(x, ABCIndex):
+            x = x._mpl_repr()
+        if is_errorbar:
+            if 'xerr' in kwds:
+                kwds['xerr'] = np.array(kwds.get('xerr'))
+            if 'yerr' in kwds:
+                kwds['yerr'] = np.array(kwds.get('yerr'))
+            return ax.errorbar(x, y, **kwds)
+        else:
+            args = (x, y, style) if style is not None else (x, y)
+            return ax.plot(*args, **kwds)
+
+    def _get_custom_index_name(self):
+        return self.xlabel
+
+    @final
+    def _get_index_name(self) -> str | None:
+        if isinstance(self.data.index, ABCMultiIndex):
+            name = self.data.index.names
+            if com.any_not_none(*name):
+                name = ','.join([pprint_thing(x) for x in name])
+            else:
+                name = None
+        else:
+            name = self.data.index.name
+            if name is not None:
+                name = pprint_thing(name)
+        index_name = self._get_custom_index_name()
+        if index_name is not None:
+            name = pprint_thing(index_name)
+        return name
+
+    @final
+    @classmethod
+    def _get_ax_layer(cls, ax, primary: bool=True):
+        if primary:
+            return getattr(ax, 'left_ax', ax)
+        else:
+            return getattr(ax, 'right_ax', ax)
+
+    @final
+    def _col_idx_to_axis_idx(self, col_idx: int) -> int:
+        if isinstance(self.subplots, list):
+            return next((group_idx for (group_idx, group) in enumerate(self.subplots) if col_idx in group))
+        else:
+            return col_idx
+
+    @final
+    def _get_ax(self, i: int) -> Axes:
+        if self.subplots:
+            i = self._col_idx_to_axis_idx(i)
+            ax = self.axes[i]
+            ax = self._maybe_right_yaxis(ax, i)
+            self.axes[i] = ax
+        else:
+            ax = self.axes[0]
+            ax = self._maybe_right_yaxis(ax, i)
+        ax.get_yaxis().set_visible(True)
+        return ax
+
+    @final
+    def on_right(self, i: int) -> bool:
+        if isinstance(self.secondary_y, bool):
+            return self.secondary_y
+        if isinstance(self.secondary_y, (tuple, list, np.ndarray, ABCIndex)):
+            return self.data.columns[i] in self.secondary_y
+
+    @final
+    def _apply_style_colors(self, colors, kwds: dict[str, Any], col_num: int, label: str):
+        style = None
+        if self.style is not None:
+            if isinstance(self.style, list):
+                try:
+                    style = self.style[col_num]
+                except IndexError:
+                    pass
+            elif isinstance(self.style, dict):
+                style = self.style.get(label, style)
+            else:
+                style = self.style
+        has_color = 'color' in kwds or self.colormap is not None
+        nocolor_style = style is None or not _color_in_style(style)
+        if (has_color or self.subplots) and nocolor_style:
+            if isinstance(colors, dict):
+                kwds['color'] = colors[label]
+            else:
+                kwds['color'] = colors[col_num % len(colors)]
+        return (style, kwds)
+
+    def _get_colors(self, num_colors: int | None=None, color_kwds: str='color'):
+        if num_colors is None:
+            num_colors = self.nseries
+        if color_kwds == 'color':
+            color = self.color
+        else:
+            color = self.kwds.get(color_kwds)
+        return get_standard_colors(num_colors=num_colors, colormap=self.colormap, color=color)
+
+    @final
+    @staticmethod
+    def _parse_errorbars(label: str, err, data: NDFrameT, nseries: int) -> tuple[Any, NDFrameT]:
+        if err is None:
+            return (None, data)
+
+        def match_labels(data, e):
+            e = e.reindex(data.index)
+            return e
+        if isinstance(err, ABCDataFrame):
+            err = match_labels(data, err)
+        elif isinstance(err, dict):
+            pass
+        elif isinstance(err, ABCSeries):
+            err = match_labels(data, err)
+            err = np.atleast_2d(err)
+            err = np.tile(err, (nseries, 1))
+        elif isinstance(err, str):
+            evalues = data[err].values
+            data = data[data.columns.drop(err)]
+            err = np.atleast_2d(evalues)
+            err = np.tile(err, (nseries, 1))
+        elif is_list_like(err):
+            if is_iterator(err):
+                err = np.atleast_2d(list(err))
+            else:
+                err = np.atleast_2d(err)
+            err_shape = err.shape
+            if isinstance(data, ABCSeries) and err_shape[0] == 2:
+                err = np.expand_dims(err, 0)
+                err_shape = err.shape
+                if err_shape[2] != len(data):
+                    raise ValueError(f'Asymmetrical error bars should be provided with the shape (2, {len(data)})')
+            elif isinstance(data, ABCDataFrame) and err.ndim == 3:
+                if err_shape[0] != nseries or err_shape[1] != 2 or err_shape[2] != len(data):
+                    raise ValueError(f'Asymmetrical error bars should be provided with the shape ({nseries}, 2, {len(data)})')
+            if len(err) == 1:
+                err = np.tile(err, (nseries, 1))
+        elif is_number(err):
+            err = np.tile([err], (nseries, len(data)))
+        else:
+            msg = f'No valid {label} detected'
+            raise ValueError(msg)
+        return (err, data)
+
+    @final
+    def _get_errorbars(self, label=None, index=None, xerr: bool=True, yerr: bool=True) -> dict[str, Any]:
+        errors = {}
+        for (kw, flag) in zip(['xerr', 'yerr'], [xerr, yerr]):
+            if flag:
+                err = self.errors[kw]
+                if isinstance(err, (ABCDataFrame, dict)):
+                    if label is not None and label in err.keys():
+                        err = err[label]
+                    else:
+                        err = None
+                elif index is not None and err is not None:
+                    err = err[index]
+                if err is not None:
+                    errors[kw] = err
+        return errors
+
+    @final
+    def _get_subplots(self, fig: Figure) -> list[Axes]:
+        if Version(mpl.__version__) < Version('3.8'):
+            Klass = mpl.axes.Subplot
+        else:
+            Klass = mpl.axes.Axes
+        return [ax for ax in fig.get_axes() if isinstance(ax, Klass) and ax.get_subplotspec() is not None]
+
+    @final
+    def _get_axes_layout(self, fig: Figure) -> tuple[int, int]:
+        axes = self._get_subplots(fig)
+        x_set = set()
+        y_set = set()
+        for ax in axes:
+            points = ax.get_position().get_points()
+            x_set.add(points[0][0])
+            y_set.add(points[0][1])
+        return (len(y_set), len(x_set))
+
+class PlanePlot(MPLPlot, ABC):
+    _layout_type = 'single'
+
+    def __init__(self, data, x, y, **kwargs) -> None:
+        MPLPlot.__init__(self, data, **kwargs)
+        if x is None or y is None:
+            raise ValueError(self._kind + ' requires an x and y column')
+        if is_integer(x) and (not holds_integer(self.data.columns)):
+            x = self.data.columns[x]
+        if is_integer(y) and (not holds_integer(self.data.columns)):
+            y = self.data.columns[y]
+        self.x = x
+        self.y = y
+
+    @final
+    def _get_nseries(self, data: Series | DataFrame) -> int:
+        return 1
+
+    @final
+    def _post_plot_logic(self, ax: Axes, data) -> None:
+        (x, y) = (self.x, self.y)
+        xlabel = self.xlabel if self.xlabel is not None else pprint_thing(x)
+        ylabel = self.ylabel if self.ylabel is not None else pprint_thing(y)
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+
+    @final
+    def _plot_colorbar(self, ax: Axes, *, fig: Figure, **kwds):
+        img = ax.collections[-1]
+        return fig.colorbar(img, ax=ax, **kwds)
+
+class ScatterPlot(PlanePlot):
+
+    @property
+    def _kind(self) -> Literal['scatter']:
+        return 'scatter'
+
+    def __init__(self, data, x, y, s=None, c=None, *, colorbar: bool | lib.NoDefault=lib.no_default, norm=None, **kwargs) -> None:
+        if s is None:
+            s = 20
+        elif is_hashable(s) and s in data.columns:
+            s = data[s]
+        self.s = s
+        self.colorbar = colorbar
+        self.norm = norm
+        super().__init__(data, x, y, **kwargs)
+        if is_integer(c) and (not holds_integer(self.data.columns)):
+            c = self.data.columns[c]
+        self.c = c
+
+    def _make_plot(self, fig: Figure) -> None:
+        (x, y, c, data) = (self.x, self.y, self.c, self.data)
+        ax = self.axes[0]
+        c_is_column = is_hashable(c) and c in self.data.columns
+        color_by_categorical = c_is_column and isinstance(self.data[c].dtype, CategoricalDtype)
+        color = self.color
+        c_values = self._get_c_values(color, color_by_categorical, c_is_column)
+        (norm, cmap) = self._get_norm_and_cmap(c_values, color_by_categorical)
+        cb = self._get_colorbar(c_values, c_is_column)
+        if self.legend:
+            label = self.label
+        else:
+            label = None
+        create_colors = not self._are_valid_colors(c_values)
+        if create_colors:
+            color_mapping = self._get_color_mapping(c_values)
+            c_values = [color_mapping[s] for s in c_values]
+            ax.legend(handles=[mpl.patches.Circle((0, 0), facecolor=c, label=s) for (s, c) in color_mapping.items()])
+        scatter = ax.scatter(data[x].values, data[y].values, c=c_values, label=label, cmap=cmap, norm=norm, s=self.s, **self.kwds)
+        if cb:
+            cbar_label = c if c_is_column else ''
+            cbar = self._plot_colorbar(ax, fig=fig, label=cbar_label)
+            if color_by_categorical:
+                n_cats = len(self.data[c].cat.categories)
+                cbar.set_ticks(np.linspace(0.5, n_cats - 0.5, n_cats))
+                cbar.ax.set_yticklabels(self.data[c].cat.categories)
+        if label is not None:
+            self._append_legend_handles_labels(scatter, label)
+        errors_x = self._get_errorbars(label=x, index=0, yerr=False)
+        errors_y = self._get_errorbars(label=y, index=0, xerr=False)
+        if len(errors_x) > 0 or len(errors_y) > 0:
+            err_kwds = dict(errors_x, **errors_y)
+            err_kwds['ecolor'] = scatter.get_facecolor()[0]
+            ax.errorbar(data[x].values, data[y].values, linestyle='none', **err_kwds)
+
+    def _get_c_values(self, color, color_by_categorical: bool, c_is_column: bool):
+        c = self.c
+        if c is not None and color is not None:
+            raise TypeError('Specify exactly one of `c` and `color`')
+        if c is None and color is None:
+            c_values = mpl.rcParams['patch.facecolor']
+        elif color is not None:
+            c_values = color
+        elif color_by_categorical:
+            c_values = self.data[c].cat.codes
+        elif c_is_column:
+            c_values = self.data[c].values
+        else:
+            c_values = c
+        return c_values
+
+    def _are_valid_colors(self, c_values: Series) -> bool:
+        unique = np.unique(c_values)
+        try:
+            if len(c_values) and all((isinstance(c, str) for c in unique)):
+                mpl.colors.to_rgba_array(unique)
+            return True
+        except (TypeError, ValueError) as _:
+            return False
+
+    def _get_color_mapping(self, c_values: Series) -> dict[str, np.ndarray]:
+        unique = np.unique(c_values)
+        n_colors = len(unique)
+        cmap = mpl.colormaps.get_cmap(self.colormap)
+        colors = cmap(np.linspace(0, 1, n_colors))
+        return dict(zip(unique, colors))
+
+    def _get_norm_and_cmap(self, c_values, color_by_categorical: bool):
+        c = self.c
+        if self.colormap is not None:
+            cmap = mpl.colormaps.get_cmap(self.colormap)
+        elif not isinstance(c_values, str) and is_integer_dtype(c_values):
+            cmap = mpl.colormaps['Greys']
+        else:
+            cmap = None
+        if color_by_categorical and cmap is not None:
+            n_cats = len(self.data[c].cat.categories)
+            cmap = mpl.colors.ListedColormap([cmap(i) for i in range(cmap.N)])
+            bounds = np.linspace(0, n_cats, n_cats + 1)
+            norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
+        else:
+            norm = self.norm
+        return (norm, cmap)
+
+    def _get_colorbar(self, c_values, c_is_column: bool) -> bool:
+        plot_colorbar = self.colormap or c_is_column
+        cb = self.colorbar
+        if cb is lib.no_default:
+            return is_numeric_dtype(c_values) and plot_colorbar
+        return cb
+
+class HexBinPlot(PlanePlot):
+
+    @property
+    def _kind(self) -> Literal['hexbin']:
+        return 'hexbin'
+
+    def __init__(self, data, x, y, C=None, *, colorbar: bool=True, **kwargs) -> None:
+        super().__init__(data, x, y, **kwargs)
+        if is_integer(C) and (not holds_integer(self.data.columns)):
+            C = self.data.columns[C]
+        self.C = C
+        self.colorbar = colorbar
+        if len(self.data[self.x]._get_numeric_data()) == 0:
+            raise ValueError(self._kind + ' requires x column to be numeric')
+        if len(self.data[self.y]._get_numeric_data()) == 0:
+            raise ValueError(self._kind + ' requires y column to be numeric')
+
+    def _make_plot(self, fig: Figure) -> None:
+        (x, y, data, C) = (self.x, self.y, self.data, self.C)
+        ax = self.axes[0]
+        cmap = self.colormap or 'BuGn'
+        cmap = mpl.colormaps.get_cmap(cmap)
+        cb = self.colorbar
+        if C is None:
+            c_values = None
+        else:
+            c_values = data[C].values
+        ax.hexbin(data[x].values, data[y].values, C=c_values, cmap=cmap, **self.kwds)
+        if cb:
+            self._plot_colorbar(ax, fig=fig)
+
+    def _make_legend(self) -> None:
+        pass
+
+class LinePlot(MPLPlot):
+    _default_rot = 0
+
+    @property
+    def orientation(self) -> PlottingOrientation:
+        return 'vertical'
+
+    @property
+    def _kind(self) -> Literal['line', 'area', 'hist', 'kde', 'box']:
+        return 'line'
+
+    def __init__(self, data, **kwargs) -> None:
+        from pandas.plotting import plot_params
+        MPLPlot.__init__(self, data, **kwargs)
+        if self.stacked:
+            self.data = self.data.fillna(value=0)
+        self.x_compat = plot_params['x_compat']
+        if 'x_compat' in self.kwds:
+            self.x_compat = bool(self.kwds.pop('x_compat'))
+
+    @final
+    def _is_ts_plot(self) -> bool:
+        return not self.x_compat and self.use_index and self._use_dynamic_x()
+
+    @final
+    def _use_dynamic_x(self) -> bool:
+        return use_dynamic_x(self._get_ax(0), self.data)
+
+    def _make_plot(self, fig: Figure) -> None:
+        if self._is_ts_plot():
+            data = maybe_convert_index(self._get_ax(0), self.data)
+            x = data.index
+            plotf = self._ts_plot
+            it = data.items()
+        else:
+            x = self._get_xticks()
+            plotf = self._plot
+            it = self._iter_data(data=self.data)
+        stacking_id = self._get_stacking_id()
+        is_errorbar = com.any_not_none(*self.errors.values())
+        colors = self._get_colors()
+        for (i, (label, y)) in enumerate(it):
+            ax = self._get_ax(i)
+            kwds = self.kwds.copy()
+            if self.color is not None:
+                kwds['color'] = self.color
+            (style, kwds) = self._apply_style_colors(colors, kwds, i, label)
+            errors = self._get_errorbars(label=label, index=i)
+            kwds = dict(kwds, **errors)
+            label = pprint_thing(label)
+            label = self._mark_right_label(label, index=i)
+            kwds['label'] = label
+            newlines = plotf(ax, x, y, style=style, column_num=i, stacking_id=stacking_id, is_errorbar=is_errorbar, **kwds)
+            self._append_legend_handles_labels(newlines[0], label)
+            if self._is_ts_plot():
+                lines = get_all_lines(ax)
+                (left, right) = get_xlim(lines)
+                ax.set_xlim(left, right)
+
+    @classmethod
+    def _plot(cls, ax: Axes, x, y: np.ndarray, style=None, column_num=None, stacking_id=None, **kwds):
+        if column_num == 0:
+            cls._initialize_stacker(ax, stacking_id, len(y))
+        y_values = cls._get_stacked_values(ax, stacking_id, y, kwds['label'])
+        lines = MPLPlot._plot(ax, x, y_values, style=style, **kwds)
+        cls._update_stacker(ax, stacking_id, y)
+        return lines
+
+    @final
+    def _ts_plot(self, ax: Axes, x, data: Series, style=None, **kwds):
+        (freq, data) = maybe_resample(data, ax, kwds)
+        decorate_axes(ax, freq)
+        if hasattr(ax, 'left_ax'):
+            decorate_axes(ax.left_ax, freq)
+        if hasattr(ax, 'right_ax'):
+            decorate_axes(ax.right_ax, freq)
+        ax._plot_data.append((data, self._kind, kwds))
+        lines = self._plot(ax, data.index, np.asarray(data.values), style=style, **kwds)
+        format_dateaxis(ax, ax.freq, data.index)
+        return lines
+
+    @final
+    def _get_stacking_id(self) -> int | None:
+        if self.stacked:
+            return id(self.data)
+        else:
+            return None
+
+    @final
+    @classmethod
+    def _initialize_stacker(cls, ax: Axes, stacking_id, n: int) -> None:
+        if stacking_id is None:
+            return
+        if not hasattr(ax, '_stacker_pos_prior'):
+            ax._stacker_pos_prior = {}
+        if not hasattr(ax, '_stacker_neg_prior'):
+            ax._stacker_neg_prior = {}
+        ax._stacker_pos_prior[stacking_id] = np.zeros(n)
+        ax._stacker_neg_prior[stacking_id] = np.zeros(n)
+
+    @final
+    @classmethod
+    def _get_stacked_values(cls, ax: Axes, stacking_id: int | None, values: np.ndarray, label) -> np.ndarray:
+        if stacking_id is None:
+            return values
+        if not hasattr(ax, '_stacker_pos_prior'):
+            cls._initialize_stacker(ax, stacking_id, len(values))
+        if (values >= 0).all():
+            return ax._stacker_pos_prior[stacking_id] + values
+        elif (values <= 0).all():
+            return ax._stacker_neg_prior[stacking_id] + values
+        raise ValueError(f"When stacked is True, each column must be either all positive or all negative. Column '{label}' contains both positive and negative values")
+
+    @final
+    @classmethod
+    def _update_stacker(cls, ax: Axes, stacking_id: int | None, values) -> None:
+        if stacking_id is None:
+            return
+        if (values >= 0).all():
+            ax._stacker_pos_prior[stacking_id] += values
+        elif (values <= 0).all():
+            ax._stacker_neg_prior[stacking_id] += values
+
+    def _post_plot_logic(self, ax: Axes, data) -> None:
+
+        def get_label(i):
+            if is_float(i) and i.is_integer():
+                i = int(i)
+            try:
+                return pprint_thing(data.index[i])
+            except Exception:
+                return ''
+        if self._need_to_set_index:
+            xticks = ax.get_xticks()
+            xticklabels = [get_label(x) for x in xticks]
+            ax.xaxis.set_major_locator(mpl.ticker.FixedLocator(xticks))
+            ax.set_xticklabels(xticklabels)
+        condition = not self._use_dynamic_x() and (data.index._is_all_dates and self.use_index) and (not self.subplots or (self.subplots and self.sharex))
+        index_name = self._get_index_name()
+        if condition:
+            if not self._rot_set:
+                self.rot = 30
+            format_date_labels(ax, rot=self.rot)
+        if index_name is not None and self.use_index:
+            ax.set_xlabel(index_name)
+
+class AreaPlot(LinePlot):
+
+    @property
+    def _kind(self) -> Literal['area']:
+        return 'area'
+
+    def __init__(self, data, **kwargs) -> None:
+        kwargs.setdefault('stacked', True)
+        data = data.fillna(value=0)
+        LinePlot.__init__(self, data, **kwargs)
+        if not self.stacked:
+            self.kwds.setdefault('alpha', 0.5)
+        if self.logy or self.loglog:
+            raise ValueError('Log-y scales are not supported in area plot')
+
+    @classmethod
+    def _plot(cls, ax: Axes, x, y: np.ndarray, style=None, column_num=None, stacking_id=None, is_errorbar: bool=False, **kwds):
+        if column_num == 0:
+            cls._initialize_stacker(ax, stacking_id, len(y))
+        y_values = cls._get_stacked_values(ax, stacking_id, y, kwds['label'])
+        line_kwds = kwds.copy()
+        line_kwds.pop('label')
+        lines = MPLPlot._plot(ax, x, y_values, style=style, **line_kwds)
+        (xdata, y_values) = lines[0].get_data(orig=False)
+        if stacking_id is None:
+            start = np.zeros(len(y))
+        elif (y >= 0).all():
+            start = ax._stacker_pos_prior[stacking_id]
+        elif (y <= 0).all():
+            start = ax._stacker_neg_prior[stacking_id]
+        else:
+            start = np.zeros(len(y))
+        if 'color' not in kwds:
+            kwds['color'] = lines[0].get_color()
+        rect = ax.fill_between(xdata, start, y_values, **kwds)
+        cls._update_stacker(ax, stacking_id, y)
+        res = [rect]
+        return res
+
+    def _post_plot_logic(self, ax: Axes, data) -> None:
+        LinePlot._post_plot_logic(self, ax, data)
+        is_shared_y = len(list(ax.get_shared_y_axes())) > 0
+        if self.ylim is None and (not is_shared_y):
+            if (data >= 0).all().all():
+                ax.set_ylim(0, None)
+            elif (data <= 0).all().all():
+                ax.set_ylim(None, 0)
+
+class BarPlot(MPLPlot):
+
+    @property
+    def _kind(self) -> Literal['bar', 'barh']:
+        return 'bar'
+    _default_rot = 90
+
+    @property
+    def orientation(self) -> PlottingOrientation:
+        return 'vertical'
+
+    def __init__(self, data, *, align='center', bottom=0, left=0, width=0.5, position=0.5, log=False, **kwargs) -> None:
+        self._is_series = isinstance(data, ABCSeries)
+        self.bar_width = width
+        self._align = align
+        self._position = position
+        self.tick_pos = np.arange(len(data))
+        if is_list_like(bottom):
+            bottom = np.array(bottom)
+        if is_list_like(left):
+            left = np.array(left)
+        self.bottom = bottom
+        self.left = left
+        self.log = log
+        MPLPlot.__init__(self, data, **kwargs)
+
+    @cache_readonly
+    def ax_pos(self) -> np.ndarray:
+        return self.tick_pos - self.tickoffset
+
+    @cache_readonly
+    def tickoffset(self):
+        if self.stacked or self.subplots:
+            return self.bar_width * self._position
+        elif self._align == 'edge':
+            w = self.bar_width / self.nseries
+            return self.bar_width * (self._position - 0.5) + w * 0.5
+        else:
+            return self.bar_width * self._position
+
+    @cache_readonly
+    def lim_offset(self):
+        if self.stacked or self.subplots:
+            if self._align == 'edge':
+                return self.bar_width / 2
+            else:
+                return 0
+        elif self._align == 'edge':
+            w = self.bar_width / self.nseries
+            return w * 0.5
+        else:
+            return 0
+
+    @classmethod
+    def _plot(cls, ax: Axes, x, y: np.ndarray, w, start: int | npt.NDArray[np.intp]=0, log: bool=False, **kwds):
+        return ax.bar(x, y, w, bottom=start, log=log, **kwds)
+
+    @property
+    def _start_base(self):
+        return self.bottom
+
+    def _make_plot(self, fig: Figure) -> None:
+        colors = self._get_colors()
+        ncolors = len(colors)
+        pos_prior = neg_prior = np.zeros(len(self.data))
+        K = self.nseries
+        data = self.data.fillna(0)
+        for (i, (label, y)) in enumerate(self._iter_data(data=data)):
+            ax = self._get_ax(i)
+            kwds = self.kwds.copy()
+            if self._is_series:
+                kwds['color'] = colors
+            elif isinstance(colors, dict):
+                kwds['color'] = colors[label]
+            else:
+                kwds['color'] = colors[i % ncolors]
+            errors = self._get_errorbars(label=label, index=i)
+            kwds = dict(kwds, **errors)
+            label = pprint_thing(label)
+            label = self._mark_right_label(label, index=i)
+            if ('yerr' in kwds or 'xerr' in kwds) and kwds.get('ecolor') is None:
+                kwds['ecolor'] = mpl.rcParams['xtick.color']
+            start = 0
+            if self.log and (y >= 1).all():
+                start = 1
+            start = start + self._start_base
+            kwds['align'] = self._align
+            if self.subplots:
+                w = self.bar_width / 2
+                rect = self._plot(ax, self.ax_pos + w, y, self.bar_width, start=start, label=label, log=self.log, **kwds)
+                ax.set_title(label)
+            elif self.stacked:
+                mask = y > 0
+                start = np.where(mask, pos_prior, neg_prior) + self._start_base
+                w = self.bar_width / 2
+                rect = self._plot(ax, self.ax_pos + w, y, self.bar_width, start=start, label=label, log=self.log, **kwds)
+                pos_prior = pos_prior + np.where(mask, y, 0)
+                neg_prior = neg_prior + np.where(mask, 0, y)
+            else:
+                w = self.bar_width / K
+                rect = self._plot(ax, self.ax_pos + (i + 0.5) * w, y, w, start=start, label=label, log=self.log, **kwds)
+            self._append_legend_handles_labels(rect, label)
+
+    def _post_plot_logic(self, ax: Axes, data) -> None:
+        if self.use_index:
+            str_index = [pprint_thing(key) for key in data.index]
+        else:
+            str_index = [pprint_thing(key) for key in range(data.shape[0])]
+        s_edge = self.ax_pos[0] - 0.25 + self.lim_offset
+        e_edge = self.ax_pos[-1] + 0.25 + self.bar_width + self.lim_offset
+        self._decorate_ticks(ax, self._get_index_name(), str_index, s_edge, e_edge)
+
+    def _decorate_ticks(self, ax: Axes, name: str | None, ticklabels: list[str], start_edge: float, end_edge: float) -> None:
+        ax.set_xlim((start_edge, end_edge))
+        if self.xticks is not None:
+            ax.set_xticks(np.array(self.xticks))
+        else:
+            ax.set_xticks(self.tick_pos)
+            ax.set_xticklabels(ticklabels)
+        if name is not None and self.use_index:
+            ax.set_xlabel(name)
+
+class BarhPlot(BarPlot):
+
+    @property
+    def _kind(self) -> Literal['barh']:
+        return 'barh'
+    _default_rot = 0
+
+    @property
+    def orientation(self) -> Literal['horizontal']:
+        return 'horizontal'
+
+    @property
+    def _start_base(self):
+        return self.left
+
+    @classmethod
+    def _plot(cls, ax: Axes, x, y: np.ndarray, w, start: int | npt.NDArray[np.intp]=0, log: bool=False, **kwds):
+        return ax.barh(x, y, w, left=start, log=log, **kwds)
+
+    def _get_custom_index_name(self):
+        return self.ylabel
+
+    def _decorate_ticks(self, ax: Axes, name: str | None, ticklabels: list[str], start_edge: float, end_edge: float) -> None:
+        ax.set_ylim((start_edge, end_edge))
+        ax.set_yticks(self.tick_pos)
+        ax.set_yticklabels(ticklabels)
+        if name is not None and self.use_index:
+            ax.set_ylabel(name)
+        ax.set_xlabel(self.xlabel)
+
+class PiePlot(MPLPlot):
+
+    @property
+    def _kind(self) -> Literal['pie']:
+        return 'pie'
+    _layout_type = 'horizontal'
+
+    def __init__(self, data: Series | DataFrame, kind=None, **kwargs) -> None:
+        data = data.fillna(value=0)
+        lt_zero = data < 0
+        if isinstance(data, ABCDataFrame) and lt_zero.any().any():
+            raise ValueError(f"{self._kind} plot doesn't allow negative values")
+        elif isinstance(data, ABCSeries) and lt_zero.any():
+            raise ValueError(f"{self._kind} plot doesn't allow negative values")
+        MPLPlot.__init__(self, data, kind=kind, **kwargs)
+
+    @classmethod
+    def _validate_log_kwd(cls, kwd: str, value: bool | None | Literal['sym']) -> bool | None | Literal['sym']:
+        super()._validate_log_kwd(kwd=kwd, value=value)
+        if value is not False:
+            warnings.warn(f"PiePlot ignores the '{kwd}' keyword", UserWarning, stacklevel=find_stack_level())
+        return False
+
+    def _validate_color_args(self, color, colormap) -> None:
+        return None
+
+    def _make_plot(self, fig: Figure) -> None:
+        colors = self._get_colors(num_colors=len(self.data), color_kwds='colors')
+        self.kwds.setdefault('colors', colors)
+        for (i, (label, y)) in enumerate(self._iter_data(data=self.data)):
+            ax = self._get_ax(i)
+            kwds = self.kwds.copy()
+
+            def blank_labeler(label, value):
+                if value == 0:
+                    return ''
+                else:
+                    return label
+            idx = [pprint_thing(v) for v in self.data.index]
+            labels = kwds.pop('labels', idx)
+            if labels is not None:
+                blabels = [blank_labeler(left, value) for (left, value) in zip(labels, y)]
+            else:
+                blabels = None
+            results = ax.pie(y, labels=blabels, **kwds)
+            if kwds.get('autopct', None) is not None:
+                (patches, texts, autotexts) = results
+            else:
+                (patches, texts) = results
+                autotexts = []
+            if self.fontsize is not None:
+                for t in texts + autotexts:
+                    t.set_fontsize(self.fontsize)
+            leglabels = labels if labels is not None else idx
+            for (_patch, _leglabel) in zip(patches, leglabels):
+                self._append_legend_handles_labels(_patch, _leglabel)
+
+    def _post_plot_logic(self, ax: Axes, data) -> None:
+        pass
+
+# File: pandas-main/pandas/plotting/_matplotlib/groupby.py
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas.core.dtypes.missing import remove_na_arraylike
+from pandas import MultiIndex, concat
+from pandas.plotting._matplotlib.misc import unpack_single_str_list
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+    from pandas._typing import IndexLabel
+    from pandas import DataFrame, Series
+
+def create_iter_data_given_by(data: DataFrame, kind: str='hist') -> dict[Hashable, DataFrame | Series]:
+    if kind == 'hist':
+        level = 0
+    else:
+        level = 1
+    assert isinstance(data.columns, MultiIndex)
+    return {col: data.loc[:, data.columns.get_level_values(level) == col] for col in data.columns.levels[level]}
+
+def reconstruct_data_with_by(data: DataFrame, by: IndexLabel, cols: IndexLabel) -> DataFrame:
+    by_modified = unpack_single_str_list(by)
+    grouped = data.groupby(by_modified)
+    data_list = []
+    for (key, group) in grouped:
+        columns = MultiIndex.from_product([[key], cols])
+        sub_group = group[cols]
+        sub_group.columns = columns
+        data_list.append(sub_group)
+    data = concat(data_list, axis=1)
+    return data
+
+def reformat_hist_y_given_by(y: np.ndarray, by: IndexLabel | None) -> np.ndarray:
+    if by is not None and len(y.shape) > 1:
+        return np.array([remove_na_arraylike(col) for col in y.T]).T
+    return remove_na_arraylike(y)
+
+# File: pandas-main/pandas/plotting/_matplotlib/hist.py
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Literal, final
+import numpy as np
+from pandas.core.dtypes.common import is_integer, is_list_like
+from pandas.core.dtypes.generic import ABCDataFrame, ABCIndex
+from pandas.core.dtypes.missing import isna, remove_na_arraylike
+from pandas.io.formats.printing import pprint_thing
+from pandas.plotting._matplotlib.core import LinePlot, MPLPlot
+from pandas.plotting._matplotlib.groupby import create_iter_data_given_by, reformat_hist_y_given_by
+from pandas.plotting._matplotlib.misc import unpack_single_str_list
+from pandas.plotting._matplotlib.tools import create_subplots, flatten_axes, maybe_adjust_figure, set_ticks_props
+if TYPE_CHECKING:
+    from matplotlib.axes import Axes
+    from matplotlib.container import BarContainer
+    from matplotlib.figure import Figure
+    from matplotlib.patches import Polygon
+    from pandas._typing import PlottingOrientation
+    from pandas import DataFrame, Series
+
+class HistPlot(LinePlot):
+
+    @property
+    def _kind(self) -> Literal['hist', 'kde']:
+        return 'hist'
+
+    def __init__(self, data, bins: int | np.ndarray | list[np.ndarray]=10, bottom: int | np.ndarray=0, *, range=None, weights=None, **kwargs) -> None:
+        if is_list_like(bottom):
+            bottom = np.array(bottom)
+        self.bottom = bottom
+        self._bin_range = range
+        self.weights = weights
+        self.xlabel = kwargs.get('xlabel')
+        self.ylabel = kwargs.get('ylabel')
+        MPLPlot.__init__(self, data, **kwargs)
+        self.bins = self._adjust_bins(bins)
+
+    def _adjust_bins(self, bins: int | np.ndarray | list[np.ndarray]):
+        if is_integer(bins):
+            if self.by is not None:
+                by_modified = unpack_single_str_list(self.by)
+                grouped = self.data.groupby(by_modified)[self.columns]
+                bins = [self._calculate_bins(group, bins) for (key, group) in grouped]
+            else:
+                bins = self._calculate_bins(self.data, bins)
+        return bins
+
+    def _calculate_bins(self, data: Series | DataFrame, bins) -> np.ndarray:
+        nd_values = data.infer_objects()._get_numeric_data()
+        values = nd_values.values
+        if nd_values.ndim == 2:
+            values = values.reshape(-1)
+        values = values[~isna(values)]
+        return np.histogram_bin_edges(values, bins=bins, range=self._bin_range)
+
+    @classmethod
+    def _plot(cls, ax: Axes, y: np.ndarray, style=None, bottom: int | np.ndarray=0, column_num: int=0, stacking_id=None, *, bins, **kwds) -> BarContainer | Polygon | list[BarContainer | Polygon]:
+        if column_num == 0:
+            cls._initialize_stacker(ax, stacking_id, len(bins) - 1)
+        base = np.zeros(len(bins) - 1)
+        bottom = bottom + cls._get_stacked_values(ax, stacking_id, base, kwds['label'])
+        (n, bins, patches) = ax.hist(y, bins=bins, bottom=bottom, **kwds)
+        cls._update_stacker(ax, stacking_id, n)
+        return patches
+
+    def _make_plot(self, fig: Figure) -> None:
+        colors = self._get_colors()
+        stacking_id = self._get_stacking_id()
+        data = create_iter_data_given_by(self.data, self._kind) if self.by is not None else self.data
+        for (i, (label, y)) in enumerate(self._iter_data(data=data)):
+            ax = self._get_ax(i)
+            kwds = self.kwds.copy()
+            if self.color is not None:
+                kwds['color'] = self.color
+            label = pprint_thing(label)
+            label = self._mark_right_label(label, index=i)
+            kwds['label'] = label
+            (style, kwds) = self._apply_style_colors(colors, kwds, i, label)
+            if style is not None:
+                kwds['style'] = style
+            self._make_plot_keywords(kwds, y)
+            if self.by is not None:
+                kwds['bins'] = kwds['bins'][i]
+                kwds['label'] = self.columns
+                kwds.pop('color')
+            if self.weights is not None:
+                kwds['weights'] = type(self)._get_column_weights(self.weights, i, y)
+            y = reformat_hist_y_given_by(y, self.by)
+            artists = self._plot(ax, y, column_num=i, stacking_id=stacking_id, **kwds)
+            if self.by is not None:
+                ax.set_title(pprint_thing(label))
+            self._append_legend_handles_labels(artists[0], label)
+
+    def _make_plot_keywords(self, kwds: dict[str, Any], y: np.ndarray) -> None:
+        kwds['bottom'] = self.bottom
+        kwds['bins'] = self.bins
+
+    @final
+    @staticmethod
+    def _get_column_weights(weights, i: int, y):
+        if weights is not None:
+            if np.ndim(weights) != 1 and np.shape(weights)[-1] != 1:
+                try:
+                    weights = weights[:, i]
+                except IndexError as err:
+                    raise ValueError('weights must have the same shape as data, or be a single column') from err
+            weights = weights[~isna(y)]
+        return weights
+
+    def _post_plot_logic(self, ax: Axes, data) -> None:
+        if self.orientation == 'horizontal':
+            ax.set_xlabel('Frequency' if self.xlabel is None else self.xlabel)
+            ax.set_ylabel(self.ylabel)
+        else:
+            ax.set_xlabel(self.xlabel)
+            ax.set_ylabel('Frequency' if self.ylabel is None else self.ylabel)
+
+    @property
+    def orientation(self) -> PlottingOrientation:
+        if self.kwds.get('orientation', None) == 'horizontal':
+            return 'horizontal'
+        else:
+            return 'vertical'
+
+class KdePlot(HistPlot):
+
+    @property
+    def _kind(self) -> Literal['kde']:
+        return 'kde'
+
+    @property
+    def orientation(self) -> Literal['vertical']:
+        return 'vertical'
+
+    def __init__(self, data, bw_method=None, ind=None, *, weights=None, **kwargs) -> None:
+        MPLPlot.__init__(self, data, **kwargs)
+        self.bw_method = bw_method
+        self.ind = ind
+        self.weights = weights
+
+    @staticmethod
+    def _get_ind(y: np.ndarray, ind):
+        if ind is None:
+            sample_range = np.nanmax(y) - np.nanmin(y)
+            ind = np.linspace(np.nanmin(y) - 0.5 * sample_range, np.nanmax(y) + 0.5 * sample_range, 1000)
+        elif is_integer(ind):
+            sample_range = np.nanmax(y) - np.nanmin(y)
+            ind = np.linspace(np.nanmin(y) - 0.5 * sample_range, np.nanmax(y) + 0.5 * sample_range, ind)
+        return ind
+
+    @classmethod
+    def _plot(cls, ax: Axes, y: np.ndarray, style=None, bw_method=None, weights=None, ind=None, column_num=None, stacking_id: int | None=None, **kwds):
+        from scipy.stats import gaussian_kde
+        y = remove_na_arraylike(y)
+        gkde = gaussian_kde(y, bw_method=bw_method, weights=weights)
+        y = gkde.evaluate(ind)
+        lines = MPLPlot._plot(ax, ind, y, style=style, **kwds)
+        return lines
+
+    def _make_plot_keywords(self, kwds: dict[str, Any], y: np.ndarray) -> None:
+        kwds['bw_method'] = self.bw_method
+        kwds['ind'] = type(self)._get_ind(y, ind=self.ind)
+
+    def _post_plot_logic(self, ax: Axes, data) -> None:
+        ax.set_ylabel('Density')
+
+def _grouped_plot(plotf, data: Series | DataFrame, column=None, by=None, numeric_only: bool=True, figsize: tuple[float, float] | None=None, sharex: bool=True, sharey: bool=True, layout=None, rot: float=0, ax=None, **kwargs):
+    if figsize == 'default':
+        raise ValueError("figsize='default' is no longer supported. Specify figure size by tuple instead")
+    grouped = data.groupby(by)
+    if column is not None:
+        grouped = grouped[column]
+    naxes = len(grouped)
+    (fig, axes) = create_subplots(naxes=naxes, figsize=figsize, sharex=sharex, sharey=sharey, ax=ax, layout=layout)
+    for (ax, (key, group)) in zip(flatten_axes(axes), grouped):
+        if numeric_only and isinstance(group, ABCDataFrame):
+            group = group._get_numeric_data()
+        plotf(group, ax, **kwargs)
+        ax.set_title(pprint_thing(key))
+    return (fig, axes)
+
+def _grouped_hist(data: Series | DataFrame, column=None, by=None, ax=None, bins: int=50, figsize: tuple[float, float] | None=None, layout=None, sharex: bool=False, sharey: bool=False, rot: float=90, grid: bool=True, xlabelsize: int | None=None, xrot=None, ylabelsize: int | None=None, yrot=None, legend: bool=False, **kwargs):
+    if legend:
+        assert 'label' not in kwargs
+        if data.ndim == 1:
+            kwargs['label'] = data.name
+        elif column is None:
+            kwargs['label'] = data.columns
+        else:
+            kwargs['label'] = column
+
+    def plot_group(group, ax) -> None:
+        ax.hist(group.dropna().values, bins=bins, **kwargs)
+        if legend:
+            ax.legend()
+    if xrot is None:
+        xrot = rot
+    (fig, axes) = _grouped_plot(plot_group, data, column=column, by=by, sharex=sharex, sharey=sharey, ax=ax, figsize=figsize, layout=layout, rot=rot)
+    set_ticks_props(axes, xlabelsize=xlabelsize, xrot=xrot, ylabelsize=ylabelsize, yrot=yrot)
+    maybe_adjust_figure(fig, bottom=0.15, top=0.9, left=0.1, right=0.9, hspace=0.5, wspace=0.3)
+    return axes
+
+def hist_series(self: Series, by=None, ax=None, grid: bool=True, xlabelsize: int | None=None, xrot=None, ylabelsize: int | None=None, yrot=None, figsize: tuple[float, float] | None=None, bins: int=10, legend: bool=False, **kwds):
+    import matplotlib.pyplot as plt
+    if legend and 'label' in kwds:
+        raise ValueError('Cannot use both legend and label')
+    if by is None:
+        if kwds.get('layout', None) is not None:
+            raise ValueError("The 'layout' keyword is not supported when 'by' is None")
+        fig = kwds.pop('figure', plt.gcf() if plt.get_fignums() else plt.figure(figsize=figsize))
+        if figsize is not None and tuple(figsize) != tuple(fig.get_size_inches()):
+            fig.set_size_inches(*figsize, forward=True)
+        if ax is None:
+            ax = fig.gca()
+        elif ax.get_figure() != fig:
+            raise AssertionError('passed axis not bound to passed figure')
+        values = self.dropna().values
+        if legend:
+            kwds['label'] = self.name
+        ax.hist(values, bins=bins, **kwds)
+        if legend:
+            ax.legend()
+        ax.grid(grid)
+        axes = np.array([ax])
+        set_ticks_props(axes, xlabelsize=xlabelsize, xrot=xrot, ylabelsize=ylabelsize, yrot=yrot)
+    else:
+        if 'figure' in kwds:
+            raise ValueError("Cannot pass 'figure' when using the 'by' argument, since a new 'Figure' instance will be created")
+        axes = _grouped_hist(self, by=by, ax=ax, grid=grid, figsize=figsize, bins=bins, xlabelsize=xlabelsize, xrot=xrot, ylabelsize=ylabelsize, yrot=yrot, legend=legend, **kwds)
+    if hasattr(axes, 'ndim'):
+        if axes.ndim == 1 and len(axes) == 1:
+            return axes[0]
+    return axes
+
+def hist_frame(data: DataFrame, column=None, by=None, grid: bool=True, xlabelsize: int | None=None, xrot=None, ylabelsize: int | None=None, yrot=None, ax=None, sharex: bool=False, sharey: bool=False, figsize: tuple[float, float] | None=None, layout=None, bins: int=10, legend: bool=False, **kwds):
+    if legend and 'label' in kwds:
+        raise ValueError('Cannot use both legend and label')
+    if by is not None:
+        axes = _grouped_hist(data, column=column, by=by, ax=ax, grid=grid, figsize=figsize, sharex=sharex, sharey=sharey, layout=layout, bins=bins, xlabelsize=xlabelsize, xrot=xrot, ylabelsize=ylabelsize, yrot=yrot, legend=legend, **kwds)
+        return axes
+    if column is not None:
+        if not isinstance(column, (list, np.ndarray, ABCIndex)):
+            column = [column]
+        data = data[column]
+    data = data.select_dtypes(include=(np.number, 'datetime64', 'datetimetz'), exclude='timedelta')
+    naxes = len(data.columns)
+    if naxes == 0:
+        raise ValueError('hist method requires numerical or datetime columns, nothing to plot.')
+    (fig, axes) = create_subplots(naxes=naxes, ax=ax, squeeze=False, sharex=sharex, sharey=sharey, figsize=figsize, layout=layout)
+    can_set_label = 'label' not in kwds
+    for (ax, col) in zip(flatten_axes(axes), data.columns):
+        if legend and can_set_label:
+            kwds['label'] = col
+        ax.hist(data[col].dropna().values, bins=bins, **kwds)
+        ax.set_title(col)
+        ax.grid(grid)
+        if legend:
+            ax.legend()
+    set_ticks_props(axes, xlabelsize=xlabelsize, xrot=xrot, ylabelsize=ylabelsize, yrot=yrot)
+    maybe_adjust_figure(fig, wspace=0.3, hspace=0.3)
+    return axes
+
+# File: pandas-main/pandas/plotting/_matplotlib/misc.py
+from __future__ import annotations
+import random
+from typing import TYPE_CHECKING
+import matplotlib as mpl
+import numpy as np
+from pandas.core.dtypes.missing import notna
+from pandas.io.formats.printing import pprint_thing
+from pandas.plotting._matplotlib.style import get_standard_colors
+from pandas.plotting._matplotlib.tools import create_subplots, do_adjust_figure, maybe_adjust_figure, set_ticks_props
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+    from matplotlib.axes import Axes
+    from matplotlib.figure import Figure
+    from pandas import DataFrame, Index, Series
+
+def scatter_matrix(frame: DataFrame, alpha: float=0.5, figsize: tuple[float, float] | None=None, ax=None, grid: bool=False, diagonal: str='hist', marker: str='.', density_kwds=None, hist_kwds=None, range_padding: float=0.05, **kwds):
+    df = frame._get_numeric_data()
+    n = df.columns.size
+    naxes = n * n
+    (fig, axes) = create_subplots(naxes=naxes, figsize=figsize, ax=ax, squeeze=False)
+    maybe_adjust_figure(fig, wspace=0, hspace=0)
+    mask = notna(df)
+    marker = _get_marker_compat(marker)
+    hist_kwds = hist_kwds or {}
+    density_kwds = density_kwds or {}
+    kwds.setdefault('edgecolors', 'none')
+    boundaries_list = []
+    for a in df.columns:
+        values = df[a].values[mask[a].values]
+        (rmin_, rmax_) = (np.min(values), np.max(values))
+        rdelta_ext = (rmax_ - rmin_) * range_padding / 2
+        boundaries_list.append((rmin_ - rdelta_ext, rmax_ + rdelta_ext))
+    for (i, a) in enumerate(df.columns):
+        for (j, b) in enumerate(df.columns):
+            ax = axes[i, j]
+            if i == j:
+                values = df[a].values[mask[a].values]
+                if diagonal == 'hist':
+                    ax.hist(values, **hist_kwds)
+                elif diagonal in ('kde', 'density'):
+                    from scipy.stats import gaussian_kde
+                    y = values
+                    gkde = gaussian_kde(y)
+                    ind = np.linspace(y.min(), y.max(), 1000)
+                    ax.plot(ind, gkde.evaluate(ind), **density_kwds)
+                ax.set_xlim(boundaries_list[i])
+            else:
+                common = (mask[a] & mask[b]).values
+                ax.scatter(df[b][common], df[a][common], marker=marker, alpha=alpha, **kwds)
+                ax.set_xlim(boundaries_list[j])
+                ax.set_ylim(boundaries_list[i])
+            ax.set_xlabel(b)
+            ax.set_ylabel(a)
+            if j != 0:
+                ax.yaxis.set_visible(False)
+            if i != n - 1:
+                ax.xaxis.set_visible(False)
+    if len(df.columns) > 1:
+        lim1 = boundaries_list[0]
+        locs = axes[0][1].yaxis.get_majorticklocs()
+        locs = locs[(lim1[0] <= locs) & (locs <= lim1[1])]
+        adj = (locs - lim1[0]) / (lim1[1] - lim1[0])
+        lim0 = axes[0][0].get_ylim()
+        adj = adj * (lim0[1] - lim0[0]) + lim0[0]
+        axes[0][0].yaxis.set_ticks(adj)
+        if np.all(locs == locs.astype(int)):
+            locs = locs.astype(int)
+        axes[0][0].yaxis.set_ticklabels(locs)
+    set_ticks_props(axes, xlabelsize=8, xrot=90, ylabelsize=8, yrot=0)
+    return axes
+
+def _get_marker_compat(marker):
+    if marker not in mpl.lines.lineMarkers:
+        return 'o'
+    return marker
+
+def radviz(frame: DataFrame, class_column, ax: Axes | None=None, color=None, colormap=None, **kwds) -> Axes:
+    import matplotlib.pyplot as plt
+
+    def normalize(series):
+        a = min(series)
+        b = max(series)
+        return (series - a) / (b - a)
+    n = len(frame)
+    classes = frame[class_column].drop_duplicates()
+    class_col = frame[class_column]
+    df = frame.drop(class_column, axis=1).apply(normalize)
+    if ax is None:
+        ax = plt.gca()
+        ax.set_xlim(-1, 1)
+        ax.set_ylim(-1, 1)
+    to_plot: dict[Hashable, list[list]] = {}
+    colors = get_standard_colors(num_colors=len(classes), colormap=colormap, color_type='random', color=color)
+    for kls in classes:
+        to_plot[kls] = [[], []]
+    m = len(frame.columns) - 1
+    s = np.array([(np.cos(t), np.sin(t)) for t in [2 * np.pi * (i / m) for i in range(m)]])
+    for i in range(n):
+        row = df.iloc[i].values
+        row_ = np.repeat(np.expand_dims(row, axis=1), 2, axis=1)
+        y = (s * row_).sum(axis=0) / row.sum()
+        kls = class_col.iat[i]
+        to_plot[kls][0].append(y[0])
+        to_plot[kls][1].append(y[1])
+    for (i, kls) in enumerate(classes):
+        ax.scatter(to_plot[kls][0], to_plot[kls][1], color=colors[i], label=pprint_thing(kls), **kwds)
+    ax.legend()
+    ax.add_patch(mpl.patches.Circle((0.0, 0.0), radius=1.0, facecolor='none'))
+    for (xy, name) in zip(s, df.columns):
+        ax.add_patch(mpl.patches.Circle(xy, radius=0.025, facecolor='gray'))
+        if xy[0] < 0.0 and xy[1] < 0.0:
+            ax.text(xy[0] - 0.025, xy[1] - 0.025, name, ha='right', va='top', size='small')
+        elif xy[0] < 0.0 <= xy[1]:
+            ax.text(xy[0] - 0.025, xy[1] + 0.025, name, ha='right', va='bottom', size='small')
+        elif xy[1] < 0.0 <= xy[0]:
+            ax.text(xy[0] + 0.025, xy[1] - 0.025, name, ha='left', va='top', size='small')
+        elif xy[0] >= 0.0 and xy[1] >= 0.0:
+            ax.text(xy[0] + 0.025, xy[1] + 0.025, name, ha='left', va='bottom', size='small')
+    ax.axis('equal')
+    return ax
+
+def andrews_curves(frame: DataFrame, class_column, ax: Axes | None=None, samples: int=200, color=None, colormap=None, **kwds) -> Axes:
+    import matplotlib.pyplot as plt
+
+    def function(amplitudes):
+
+        def f(t):
+            x1 = amplitudes[0]
+            result = x1 / np.sqrt(2.0)
+            coeffs = np.delete(np.copy(amplitudes), 0)
+            coeffs = np.resize(coeffs, (int((coeffs.size + 1) / 2), 2))
+            harmonics = np.arange(0, coeffs.shape[0]) + 1
+            trig_args = np.outer(harmonics, t)
+            result += np.sum(coeffs[:, 0, np.newaxis] * np.sin(trig_args) + coeffs[:, 1, np.newaxis] * np.cos(trig_args), axis=0)
+            return result
+        return f
+    n = len(frame)
+    class_col = frame[class_column]
+    classes = frame[class_column].drop_duplicates()
+    df = frame.drop(class_column, axis=1)
+    t = np.linspace(-np.pi, np.pi, samples)
+    used_legends: set[str] = set()
+    color_values = get_standard_colors(num_colors=len(classes), colormap=colormap, color_type='random', color=color)
+    colors = dict(zip(classes, color_values))
+    if ax is None:
+        ax = plt.gca()
+        ax.set_xlim(-np.pi, np.pi)
+    for i in range(n):
+        row = df.iloc[i].values
+        f = function(row)
+        y = f(t)
+        kls = class_col.iat[i]
+        label = pprint_thing(kls)
+        if label not in used_legends:
+            used_legends.add(label)
+            ax.plot(t, y, color=colors[kls], label=label, **kwds)
+        else:
+            ax.plot(t, y, color=colors[kls], **kwds)
+    ax.legend(loc='upper right')
+    ax.grid()
+    return ax
+
+def bootstrap_plot(series: Series, fig: Figure | None=None, size: int=50, samples: int=500, **kwds) -> Figure:
+    import matplotlib.pyplot as plt
+    data = list(series.values)
+    samplings = [random.sample(data, size) for _ in range(samples)]
+    means = np.array([np.mean(sampling) for sampling in samplings])
+    medians = np.array([np.median(sampling) for sampling in samplings])
+    midranges = np.array([(min(sampling) + max(sampling)) * 0.5 for sampling in samplings])
+    if fig is None:
+        fig = plt.figure()
+    x = list(range(samples))
+    axes = []
+    ax1 = fig.add_subplot(2, 3, 1)
+    ax1.set_xlabel('Sample')
+    axes.append(ax1)
+    ax1.plot(x, means, **kwds)
+    ax2 = fig.add_subplot(2, 3, 2)
+    ax2.set_xlabel('Sample')
+    axes.append(ax2)
+    ax2.plot(x, medians, **kwds)
+    ax3 = fig.add_subplot(2, 3, 3)
+    ax3.set_xlabel('Sample')
+    axes.append(ax3)
+    ax3.plot(x, midranges, **kwds)
+    ax4 = fig.add_subplot(2, 3, 4)
+    ax4.set_xlabel('Mean')
+    axes.append(ax4)
+    ax4.hist(means, **kwds)
+    ax5 = fig.add_subplot(2, 3, 5)
+    ax5.set_xlabel('Median')
+    axes.append(ax5)
+    ax5.hist(medians, **kwds)
+    ax6 = fig.add_subplot(2, 3, 6)
+    ax6.set_xlabel('Midrange')
+    axes.append(ax6)
+    ax6.hist(midranges, **kwds)
+    for axis in axes:
+        plt.setp(axis.get_xticklabels(), fontsize=8)
+        plt.setp(axis.get_yticklabels(), fontsize=8)
+    if do_adjust_figure(fig):
+        plt.tight_layout()
+    return fig
+
+def parallel_coordinates(frame: DataFrame, class_column, cols=None, ax: Axes | None=None, color=None, use_columns: bool=False, xticks=None, colormap=None, axvlines: bool=True, axvlines_kwds=None, sort_labels: bool=False, **kwds) -> Axes:
+    import matplotlib.pyplot as plt
+    if axvlines_kwds is None:
+        axvlines_kwds = {'linewidth': 1, 'color': 'black'}
+    n = len(frame)
+    classes = frame[class_column].drop_duplicates()
+    class_col = frame[class_column]
+    if cols is None:
+        df = frame.drop(class_column, axis=1)
+    else:
+        df = frame[cols]
+    used_legends: set[str] = set()
+    ncols = len(df.columns)
+    x: list[int] | Index
+    if use_columns is True:
+        if not np.all(np.isreal(list(df.columns))):
+            raise ValueError('Columns must be numeric to be used as xticks')
+        x = df.columns
+    elif xticks is not None:
+        if not np.all(np.isreal(xticks)):
+            raise ValueError('xticks specified must be numeric')
+        if len(xticks) != ncols:
+            raise ValueError('Length of xticks must match number of columns')
+        x = xticks
+    else:
+        x = list(range(ncols))
+    if ax is None:
+        ax = plt.gca()
+    color_values = get_standard_colors(num_colors=len(classes), colormap=colormap, color_type='random', color=color)
+    if sort_labels:
+        classes = sorted(classes)
+        color_values = sorted(color_values)
+    colors = dict(zip(classes, color_values))
+    for i in range(n):
+        y = df.iloc[i].values
+        kls = class_col.iat[i]
+        label = pprint_thing(kls)
+        if label not in used_legends:
+            used_legends.add(label)
+            ax.plot(x, y, color=colors[kls], label=label, **kwds)
+        else:
+            ax.plot(x, y, color=colors[kls], **kwds)
+    if axvlines:
+        for i in x:
+            ax.axvline(i, **axvlines_kwds)
+    ax.set_xticks(x)
+    ax.set_xticklabels(df.columns)
+    ax.set_xlim(x[0], x[-1])
+    ax.legend(loc='upper right')
+    ax.grid()
+    return ax
+
+def lag_plot(series: Series, lag: int=1, ax: Axes | None=None, **kwds) -> Axes:
+    import matplotlib.pyplot as plt
+    kwds.setdefault('c', plt.rcParams['patch.facecolor'])
+    data = series.values
+    y1 = data[:-lag]
+    y2 = data[lag:]
+    if ax is None:
+        ax = plt.gca()
+    ax.set_xlabel('y(t)')
+    ax.set_ylabel(f'y(t + {lag})')
+    ax.scatter(y1, y2, **kwds)
+    return ax
+
+def autocorrelation_plot(series: Series, ax: Axes | None=None, **kwds) -> Axes:
+    import matplotlib.pyplot as plt
+    n = len(series)
+    data = np.asarray(series)
+    if ax is None:
+        ax = plt.gca()
+        ax.set_xlim(1, n)
+        ax.set_ylim(-1.0, 1.0)
+    mean = np.mean(data)
+    c0 = np.sum((data - mean) ** 2) / n
+
+    def r(h):
+        return ((data[:n - h] - mean) * (data[h:] - mean)).sum() / n / c0
+    x = np.arange(n) + 1
+    y = [r(loc) for loc in x]
+    z95 = 1.959963984540054
+    z99 = 2.5758293035489004
+    ax.axhline(y=z99 / np.sqrt(n), linestyle='--', color='grey')
+    ax.axhline(y=z95 / np.sqrt(n), color='grey')
+    ax.axhline(y=0.0, color='black')
+    ax.axhline(y=-z95 / np.sqrt(n), color='grey')
+    ax.axhline(y=-z99 / np.sqrt(n), linestyle='--', color='grey')
+    ax.set_xlabel('Lag')
+    ax.set_ylabel('Autocorrelation')
+    ax.plot(x, y, **kwds)
+    if 'label' in kwds:
+        ax.legend()
+    ax.grid()
+    return ax
+
+def unpack_single_str_list(keys):
+    if isinstance(keys, list) and len(keys) == 1:
+        keys = keys[0]
+    return keys
+
+# File: pandas-main/pandas/plotting/_matplotlib/style.py
+from __future__ import annotations
+from collections.abc import Collection, Iterator, Sequence
+import itertools
+from typing import TYPE_CHECKING, cast, overload
+import warnings
+import matplotlib as mpl
+import matplotlib.colors
+import numpy as np
+from pandas._typing import MatplotlibColor as Color
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import is_list_like
+import pandas.core.common as com
+if TYPE_CHECKING:
+    from matplotlib.colors import Colormap
+
+@overload
+def get_standard_colors(num_colors: int, colormap: Colormap | None=..., color_type: str=..., *, color: dict[str, Color]) -> dict[str, Color]:
+    ...
+
+@overload
+def get_standard_colors(num_colors: int, colormap: Colormap | None=..., color_type: str=..., *, color: Color | Sequence[Color] | None=...) -> list[Color]:
+    ...
+
+@overload
+def get_standard_colors(num_colors: int, colormap: Colormap | None=..., color_type: str=..., *, color: dict[str, Color] | Color | Sequence[Color] | None=...) -> dict[str, Color] | list[Color]:
+    ...
+
+def get_standard_colors(num_colors: int, colormap: Colormap | None=None, color_type: str='default', *, color: dict[str, Color] | Color | Sequence[Color] | None=None) -> dict[str, Color] | list[Color]:
+    if isinstance(color, dict):
+        return color
+    colors = _derive_colors(color=color, colormap=colormap, color_type=color_type, num_colors=num_colors)
+    return list(_cycle_colors(colors, num_colors=num_colors))
+
+def _derive_colors(*, color: Color | Collection[Color] | None, colormap: str | Colormap | None, color_type: str, num_colors: int) -> list[Color]:
+    if color is None and colormap is not None:
+        return _get_colors_from_colormap(colormap, num_colors=num_colors)
+    elif color is not None:
+        if colormap is not None:
+            warnings.warn("'color' and 'colormap' cannot be used simultaneously. Using 'color'", stacklevel=find_stack_level())
+        return _get_colors_from_color(color)
+    else:
+        return _get_colors_from_color_type(color_type, num_colors=num_colors)
+
+def _cycle_colors(colors: list[Color], num_colors: int) -> Iterator[Color]:
+    max_colors = max(num_colors, len(colors))
+    yield from itertools.islice(itertools.cycle(colors), max_colors)
+
+def _get_colors_from_colormap(colormap: str | Colormap, num_colors: int) -> list[Color]:
+    cmap = _get_cmap_instance(colormap)
+    return [cmap(num) for num in np.linspace(0, 1, num=num_colors)]
+
+def _get_cmap_instance(colormap: str | Colormap) -> Colormap:
+    if isinstance(colormap, str):
+        cmap = colormap
+        colormap = mpl.colormaps[colormap]
+        if colormap is None:
+            raise ValueError(f'Colormap {cmap} is not recognized')
+    return colormap
+
+def _get_colors_from_color(color: Color | Collection[Color]) -> list[Color]:
+    if len(color) == 0:
+        raise ValueError(f'Invalid color argument: {color}')
+    if _is_single_color(color):
+        color = cast(Color, color)
+        return [color]
+    color = cast(Collection[Color], color)
+    return list(_gen_list_of_colors_from_iterable(color))
+
+def _is_single_color(color: Color | Collection[Color]) -> bool:
+    if isinstance(color, str) and _is_single_string_color(color):
+        return True
+    if _is_floats_color(color):
+        return True
+    return False
+
+def _gen_list_of_colors_from_iterable(color: Collection[Color]) -> Iterator[Color]:
+    for x in color:
+        if _is_single_color(x):
+            yield x
+        else:
+            raise ValueError(f'Invalid color {x}')
+
+def _is_floats_color(color: Color | Collection[Color]) -> bool:
+    return bool(is_list_like(color) and (len(color) == 3 or len(color) == 4) and all((isinstance(x, (int, float)) for x in color)))
+
+def _get_colors_from_color_type(color_type: str, num_colors: int) -> list[Color]:
+    if color_type == 'default':
+        return _get_default_colors(num_colors)
+    elif color_type == 'random':
+        return _get_random_colors(num_colors)
+    else:
+        raise ValueError("color_type must be either 'default' or 'random'")
+
+def _get_default_colors(num_colors: int) -> list[Color]:
+    colors = [c['color'] for c in mpl.rcParams['axes.prop_cycle']]
+    return colors[0:num_colors]
+
+def _get_random_colors(num_colors: int) -> list[Color]:
+    return [_random_color(num) for num in range(num_colors)]
+
+def _random_color(column: int) -> list[float]:
+    rs = com.random_state(column)
+    return rs.rand(3).tolist()
+
+def _is_single_string_color(color: Color) -> bool:
+    conv = matplotlib.colors.ColorConverter()
+    try:
+        conv.to_rgba(color)
+    except ValueError:
+        return False
+    else:
+        return True
+
+# File: pandas-main/pandas/plotting/_matplotlib/timeseries.py
+from __future__ import annotations
+import functools
+from typing import TYPE_CHECKING, Any, cast
+import warnings
+import numpy as np
+from pandas._libs.tslibs import BaseOffset, Period, to_offset
+from pandas._libs.tslibs.dtypes import OFFSET_TO_PERIOD_FREQSTR, FreqGroup
+from pandas.core.dtypes.generic import ABCDatetimeIndex, ABCPeriodIndex, ABCTimedeltaIndex
+from pandas.io.formats.printing import pprint_thing
+from pandas.plotting._matplotlib.converter import TimeSeries_DateFormatter, TimeSeries_DateLocator, TimeSeries_TimedeltaFormatter
+from pandas.tseries.frequencies import get_period_alias, is_subperiod, is_superperiod
+if TYPE_CHECKING:
+    from datetime import timedelta
+    from matplotlib.axes import Axes
+    from pandas._typing import NDFrameT
+    from pandas import DataFrame, DatetimeIndex, Index, PeriodIndex, Series
+
+def maybe_resample(series: Series, ax: Axes, kwargs: dict[str, Any]):
+    if 'how' in kwargs:
+        raise ValueError("'how' is not a valid keyword for plotting functions. If plotting multiple objects on shared axes, resample manually first.")
+    (freq, ax_freq) = _get_freq(ax, series)
+    if freq is None:
+        raise ValueError('Cannot use dynamic axis without frequency info')
+    if isinstance(series.index, ABCDatetimeIndex):
+        series = series.to_period(freq=freq)
+    if ax_freq is not None and freq != ax_freq:
+        if is_superperiod(freq, ax_freq):
+            series = series.copy()
+            series.index = series.index.asfreq(ax_freq, how='s')
+            freq = ax_freq
+        elif _is_sup(freq, ax_freq):
+            ser_ts = series.to_timestamp()
+            ser_d = ser_ts.resample('D').last().dropna()
+            ser_freq = ser_d.resample(ax_freq).last().dropna()
+            series = ser_freq.to_period(ax_freq)
+            freq = ax_freq
+        elif is_subperiod(freq, ax_freq) or _is_sub(freq, ax_freq):
+            _upsample_others(ax, freq, kwargs)
+        else:
+            raise ValueError('Incompatible frequency conversion')
+    return (freq, series)
+
+def _is_sub(f1: str, f2: str) -> bool:
+    return f1.startswith('W') and is_subperiod('D', f2) or (f2.startswith('W') and is_subperiod(f1, 'D'))
+
+def _is_sup(f1: str, f2: str) -> bool:
+    return f1.startswith('W') and is_superperiod('D', f2) or (f2.startswith('W') and is_superperiod(f1, 'D'))
+
+def _upsample_others(ax: Axes, freq: BaseOffset, kwargs: dict[str, Any]) -> None:
+    legend = ax.get_legend()
+    (lines, labels) = _replot_ax(ax, freq)
+    _replot_ax(ax, freq)
+    other_ax = None
+    if hasattr(ax, 'left_ax'):
+        other_ax = ax.left_ax
+    if hasattr(ax, 'right_ax'):
+        other_ax = ax.right_ax
+    if other_ax is not None:
+        (rlines, rlabels) = _replot_ax(other_ax, freq)
+        lines.extend(rlines)
+        labels.extend(rlabels)
+    if legend is not None and kwargs.get('legend', True) and (len(lines) > 0):
+        title: str | None = legend.get_title().get_text()
+        if title == 'None':
+            title = None
+        ax.legend(lines, labels, loc='best', title=title)
+
+def _replot_ax(ax: Axes, freq: BaseOffset):
+    data = getattr(ax, '_plot_data', None)
+    ax._plot_data = []
+    ax.clear()
+    decorate_axes(ax, freq)
+    lines = []
+    labels = []
+    if data is not None:
+        for (series, plotf, kwds) in data:
+            series = series.copy()
+            idx = series.index.asfreq(freq, how='S')
+            series.index = idx
+            ax._plot_data.append((series, plotf, kwds))
+            if isinstance(plotf, str):
+                from pandas.plotting._matplotlib import PLOT_CLASSES
+                plotf = PLOT_CLASSES[plotf]._plot
+            lines.append(plotf(ax, series.index._mpl_repr(), series.values, **kwds)[0])
+            labels.append(pprint_thing(series.name))
+    return (lines, labels)
+
+def decorate_axes(ax: Axes, freq: BaseOffset) -> None:
+    if not hasattr(ax, '_plot_data'):
+        ax._plot_data = []
+    ax.freq = freq
+    xaxis = ax.get_xaxis()
+    xaxis.freq = freq
+
+def _get_ax_freq(ax: Axes):
+    ax_freq = getattr(ax, 'freq', None)
+    if ax_freq is None:
+        if hasattr(ax, 'left_ax'):
+            ax_freq = getattr(ax.left_ax, 'freq', None)
+        elif hasattr(ax, 'right_ax'):
+            ax_freq = getattr(ax.right_ax, 'freq', None)
+    if ax_freq is None:
+        shared_axes = ax.get_shared_x_axes().get_siblings(ax)
+        if len(shared_axes) > 1:
+            for shared_ax in shared_axes:
+                ax_freq = getattr(shared_ax, 'freq', None)
+                if ax_freq is not None:
+                    break
+    return ax_freq
+
+def _get_period_alias(freq: timedelta | BaseOffset | str) -> str | None:
+    if isinstance(freq, BaseOffset):
+        freqstr = freq.name
+    else:
+        freqstr = to_offset(freq, is_period=True).rule_code
+    return get_period_alias(freqstr)
+
+def _get_freq(ax: Axes, series: Series):
+    freq = getattr(series.index, 'freq', None)
+    if freq is None:
+        freq = getattr(series.index, 'inferred_freq', None)
+        freq = to_offset(freq, is_period=True)
+    ax_freq = _get_ax_freq(ax)
+    if freq is None:
+        freq = ax_freq
+    freq = _get_period_alias(freq)
+    return (freq, ax_freq)
+
+def use_dynamic_x(ax: Axes, data: DataFrame | Series) -> bool:
+    freq = _get_index_freq(data.index)
+    ax_freq = _get_ax_freq(ax)
+    if freq is None:
+        freq = ax_freq
+    elif ax_freq is None and len(ax.get_lines()) > 0:
+        return False
+    if freq is None:
+        return False
+    freq_str = _get_period_alias(freq)
+    if freq_str is None:
+        return False
+    if isinstance(data.index, ABCDatetimeIndex):
+        freq_str = OFFSET_TO_PERIOD_FREQSTR.get(freq_str, freq_str)
+        base = to_offset(freq_str, is_period=True)._period_dtype_code
+        x = data.index
+        if base <= FreqGroup.FR_DAY.value:
+            return x[:1].is_normalized
+        period = Period(x[0], freq_str)
+        assert isinstance(period, Period)
+        return period.to_timestamp().tz_localize(x.tz) == x[0]
+    return True
+
+def _get_index_freq(index: Index) -> BaseOffset | None:
+    freq = getattr(index, 'freq', None)
+    if freq is None:
+        freq = getattr(index, 'inferred_freq', None)
+        if freq == 'B':
+            weekdays = np.unique(index.dayofweek)
+            if 5 in weekdays or 6 in weekdays:
+                freq = None
+    freq = to_offset(freq)
+    return freq
+
+def maybe_convert_index(ax: Axes, data: NDFrameT) -> NDFrameT:
+    if isinstance(data.index, (ABCDatetimeIndex, ABCPeriodIndex)):
+        freq: str | BaseOffset | None = data.index.freq
+        if freq is None:
+            data.index = cast('DatetimeIndex', data.index)
+            freq = data.index.inferred_freq
+            freq = to_offset(freq)
+        if freq is None:
+            freq = _get_ax_freq(ax)
+        if freq is None:
+            raise ValueError('Could not get frequency alias for plotting')
+        freq_str = _get_period_alias(freq)
+        with warnings.catch_warnings():
+            warnings.filterwarnings('ignore', 'PeriodDtype\\[B\\] is deprecated', category=FutureWarning)
+            if isinstance(data.index, ABCDatetimeIndex):
+                data = data.tz_localize(None).to_period(freq=freq_str)
+            elif isinstance(data.index, ABCPeriodIndex):
+                data.index = data.index.asfreq(freq=freq_str, how='start')
+    return data
+
+def _format_coord(freq, t, y) -> str:
+    time_period = Period(ordinal=int(t), freq=freq)
+    return f't = {time_period}  y = {y:8f}'
+
+def format_dateaxis(subplot, freq: BaseOffset, index: DatetimeIndex | PeriodIndex) -> None:
+    import matplotlib.pyplot as plt
+    if isinstance(index, ABCPeriodIndex):
+        majlocator = TimeSeries_DateLocator(freq, dynamic_mode=True, minor_locator=False, plot_obj=subplot)
+        minlocator = TimeSeries_DateLocator(freq, dynamic_mode=True, minor_locator=True, plot_obj=subplot)
+        subplot.xaxis.set_major_locator(majlocator)
+        subplot.xaxis.set_minor_locator(minlocator)
+        majformatter = TimeSeries_DateFormatter(freq, dynamic_mode=True, minor_locator=False, plot_obj=subplot)
+        minformatter = TimeSeries_DateFormatter(freq, dynamic_mode=True, minor_locator=True, plot_obj=subplot)
+        subplot.xaxis.set_major_formatter(majformatter)
+        subplot.xaxis.set_minor_formatter(minformatter)
+        subplot.format_coord = functools.partial(_format_coord, freq)
+    elif isinstance(index, ABCTimedeltaIndex):
+        subplot.xaxis.set_major_formatter(TimeSeries_TimedeltaFormatter())
+    else:
+        raise TypeError('index type not supported')
+    plt.draw_if_interactive()
+
+# File: pandas-main/pandas/plotting/_matplotlib/tools.py
+from __future__ import annotations
+from math import ceil
+from typing import TYPE_CHECKING
+import warnings
+import matplotlib as mpl
+import numpy as np
+from pandas.util._exceptions import find_stack_level
+from pandas.core.dtypes.common import is_list_like
+from pandas.core.dtypes.generic import ABCDataFrame, ABCIndex, ABCSeries
+if TYPE_CHECKING:
+    from collections.abc import Generator, Iterable
+    from matplotlib.axes import Axes
+    from matplotlib.axis import Axis
+    from matplotlib.figure import Figure
+    from matplotlib.lines import Line2D
+    from matplotlib.table import Table
+    from pandas import DataFrame, Series
+
+def do_adjust_figure(fig: Figure) -> bool:
+    if not hasattr(fig, 'get_constrained_layout'):
+        return False
+    return not fig.get_constrained_layout()
+
+def maybe_adjust_figure(fig: Figure, *args, **kwargs) -> None:
+    if do_adjust_figure(fig):
+        fig.subplots_adjust(*args, **kwargs)
+
+def format_date_labels(ax: Axes, rot) -> None:
+    for label in ax.get_xticklabels():
+        label.set_horizontalalignment('right')
+        label.set_rotation(rot)
+    fig = ax.get_figure()
+    if fig is not None:
+        maybe_adjust_figure(fig, bottom=0.2)
+
+def table(ax, data: DataFrame | Series, rowLabels=None, colLabels=None, **kwargs) -> Table:
+    if isinstance(data, ABCSeries):
+        data = data.to_frame()
+    elif isinstance(data, ABCDataFrame):
+        pass
+    else:
+        raise ValueError('Input data must be DataFrame or Series')
+    if rowLabels is None:
+        rowLabels = data.index
+    if colLabels is None:
+        colLabels = data.columns
+    cellText = data.values
+    return mpl.table.table(ax, cellText=cellText, rowLabels=rowLabels, colLabels=colLabels, **kwargs)
+
+def _get_layout(nplots: int, layout: tuple[int, int] | None=None, layout_type: str='box') -> tuple[int, int]:
+    if layout is not None:
+        if not isinstance(layout, (tuple, list)) or len(layout) != 2:
+            raise ValueError('Layout must be a tuple of (rows, columns)')
+        (nrows, ncols) = layout
+        if nrows == -1 and ncols > 0:
+            layout = (ceil(nplots / ncols), ncols)
+        elif ncols == -1 and nrows > 0:
+            layout = (nrows, ceil(nplots / nrows))
+        elif ncols <= 0 and nrows <= 0:
+            msg = 'At least one dimension of layout must be positive'
+            raise ValueError(msg)
+        (nrows, ncols) = layout
+        if nrows * ncols < nplots:
+            raise ValueError(f'Layout of {nrows}x{ncols} must be larger than required size {nplots}')
+        return layout
+    if layout_type == 'single':
+        return (1, 1)
+    elif layout_type == 'horizontal':
+        return (1, nplots)
+    elif layout_type == 'vertical':
+        return (nplots, 1)
+    layouts = {1: (1, 1), 2: (1, 2), 3: (2, 2), 4: (2, 2)}
+    try:
+        return layouts[nplots]
+    except KeyError:
+        k = 1
+        while k ** 2 < nplots:
+            k += 1
+        if (k - 1) * k >= nplots:
+            return (k, k - 1)
+        else:
+            return (k, k)
+
+def create_subplots(naxes: int, sharex: bool=False, sharey: bool=False, squeeze: bool=True, subplot_kw=None, ax=None, layout=None, layout_type: str='box', **fig_kw):
+    import matplotlib.pyplot as plt
+    if subplot_kw is None:
+        subplot_kw = {}
+    if ax is None:
+        fig = plt.figure(**fig_kw)
+    else:
+        if is_list_like(ax):
+            if squeeze:
+                ax = np.fromiter(flatten_axes(ax), dtype=object)
+            if layout is not None:
+                warnings.warn('When passing multiple axes, layout keyword is ignored.', UserWarning, stacklevel=find_stack_level())
+            if sharex or sharey:
+                warnings.warn('When passing multiple axes, sharex and sharey are ignored. These settings must be specified when creating axes.', UserWarning, stacklevel=find_stack_level())
+            if ax.size == naxes:
+                fig = ax.flat[0].get_figure()
+                return (fig, ax)
+            else:
+                raise ValueError(f'The number of passed axes must be {naxes}, the same as the output plot')
+        fig = ax.get_figure()
+        if naxes == 1:
+            if squeeze:
+                return (fig, ax)
+            else:
+                return (fig, np.fromiter(flatten_axes(ax), dtype=object))
+        else:
+            warnings.warn('To output multiple subplots, the figure containing the passed axes is being cleared.', UserWarning, stacklevel=find_stack_level())
+            fig.clear()
+    (nrows, ncols) = _get_layout(naxes, layout=layout, layout_type=layout_type)
+    nplots = nrows * ncols
+    axarr = np.empty(nplots, dtype=object)
+    ax0 = fig.add_subplot(nrows, ncols, 1, **subplot_kw)
+    if sharex:
+        subplot_kw['sharex'] = ax0
+    if sharey:
+        subplot_kw['sharey'] = ax0
+    axarr[0] = ax0
+    for i in range(1, nplots):
+        kwds = subplot_kw.copy()
+        if i >= naxes:
+            kwds['sharex'] = None
+            kwds['sharey'] = None
+        ax = fig.add_subplot(nrows, ncols, i + 1, **kwds)
+        axarr[i] = ax
+    if naxes != nplots:
+        for ax in axarr[naxes:]:
+            ax.set_visible(False)
+    handle_shared_axes(axarr, nplots, naxes, nrows, ncols, sharex, sharey)
+    if squeeze:
+        if nplots == 1:
+            axes = axarr[0]
+        else:
+            axes = axarr.reshape(nrows, ncols).squeeze()
+    else:
+        axes = axarr.reshape(nrows, ncols)
+    return (fig, axes)
+
+def _remove_labels_from_axis(axis: Axis) -> None:
+    for t in axis.get_majorticklabels():
+        t.set_visible(False)
+    if isinstance(axis.get_minor_locator(), mpl.ticker.NullLocator):
+        axis.set_minor_locator(mpl.ticker.AutoLocator())
+    if isinstance(axis.get_minor_formatter(), mpl.ticker.NullFormatter):
+        axis.set_minor_formatter(mpl.ticker.FormatStrFormatter(''))
+    for t in axis.get_minorticklabels():
+        t.set_visible(False)
+    axis.get_label().set_visible(False)
+
+def _has_externally_shared_axis(ax1: Axes, compare_axis: str) -> bool:
+    if compare_axis == 'x':
+        axes = ax1.get_shared_x_axes()
+    elif compare_axis == 'y':
+        axes = ax1.get_shared_y_axes()
+    else:
+        raise ValueError("_has_externally_shared_axis() needs 'x' or 'y' as a second parameter")
+    axes_siblings = axes.get_siblings(ax1)
+    ax1_points = ax1.get_position().get_points()
+    for ax2 in axes_siblings:
+        if not np.array_equal(ax1_points, ax2.get_position().get_points()):
+            return True
+    return False
+
+def handle_shared_axes(axarr: Iterable[Axes], nplots: int, naxes: int, nrows: int, ncols: int, sharex: bool, sharey: bool) -> None:
+    if nplots > 1:
+        row_num = lambda x: x.get_subplotspec().rowspan.start
+        col_num = lambda x: x.get_subplotspec().colspan.start
+        is_first_col = lambda x: x.get_subplotspec().is_first_col()
+        if nrows > 1:
+            try:
+                layout = np.zeros((nrows + 1, ncols + 1), dtype=np.bool_)
+                for ax in axarr:
+                    layout[row_num(ax), col_num(ax)] = ax.get_visible()
+                for ax in axarr:
+                    if not layout[row_num(ax) + 1, col_num(ax)]:
+                        continue
+                    if sharex or _has_externally_shared_axis(ax, 'x'):
+                        _remove_labels_from_axis(ax.xaxis)
+            except IndexError:
+                is_last_row = lambda x: x.get_subplotspec().is_last_row()
+                for ax in axarr:
+                    if is_last_row(ax):
+                        continue
+                    if sharex or _has_externally_shared_axis(ax, 'x'):
+                        _remove_labels_from_axis(ax.xaxis)
+        if ncols > 1:
+            for ax in axarr:
+                if is_first_col(ax):
+                    continue
+                if sharey or _has_externally_shared_axis(ax, 'y'):
+                    _remove_labels_from_axis(ax.yaxis)
+
+def flatten_axes(axes: Axes | Iterable[Axes]) -> Generator[Axes, None, None]:
+    if not is_list_like(axes):
+        yield axes
+    elif isinstance(axes, (np.ndarray, ABCIndex)):
+        yield from np.asarray(axes).reshape(-1)
+    else:
+        yield from axes
+
+def set_ticks_props(axes: Axes | Iterable[Axes], xlabelsize: int | None=None, xrot=None, ylabelsize: int | None=None, yrot=None):
+    for ax in flatten_axes(axes):
+        if xlabelsize is not None:
+            mpl.artist.setp(ax.get_xticklabels(), fontsize=xlabelsize)
+        if xrot is not None:
+            mpl.artist.setp(ax.get_xticklabels(), rotation=xrot)
+        if ylabelsize is not None:
+            mpl.artist.setp(ax.get_yticklabels(), fontsize=ylabelsize)
+        if yrot is not None:
+            mpl.artist.setp(ax.get_yticklabels(), rotation=yrot)
+    return axes
+
+def get_all_lines(ax: Axes) -> list[Line2D]:
+    lines = ax.get_lines()
+    if hasattr(ax, 'right_ax'):
+        lines += ax.right_ax.get_lines()
+    if hasattr(ax, 'left_ax'):
+        lines += ax.left_ax.get_lines()
+    return lines
+
+def get_xlim(lines: Iterable[Line2D]) -> tuple[float, float]:
+    (left, right) = (np.inf, -np.inf)
+    for line in lines:
+        x = line.get_xdata(orig=False)
+        left = min(np.nanmin(x), left)
+        right = max(np.nanmax(x), right)
+    return (left, right)
+
+# File: pandas-main/pandas/plotting/_misc.py
+from __future__ import annotations
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Any
+from pandas.plotting._core import _get_plot_backend
+if TYPE_CHECKING:
+    from collections.abc import Generator, Mapping
+    from matplotlib.axes import Axes
+    from matplotlib.colors import Colormap
+    from matplotlib.figure import Figure
+    from matplotlib.table import Table
+    import numpy as np
+    from pandas import DataFrame, Series
+
+def table(ax: Axes, data: DataFrame | Series, **kwargs) -> Table:
+    plot_backend = _get_plot_backend('matplotlib')
+    return plot_backend.table(ax=ax, data=data, rowLabels=None, colLabels=None, **kwargs)
+
+def register() -> None:
+    plot_backend = _get_plot_backend('matplotlib')
+    plot_backend.register()
+
+def deregister() -> None:
+    plot_backend = _get_plot_backend('matplotlib')
+    plot_backend.deregister()
+
+def scatter_matrix(frame: DataFrame, alpha: float=0.5, figsize: tuple[float, float] | None=None, ax: Axes | None=None, grid: bool=False, diagonal: str='hist', marker: str='.', density_kwds: Mapping[str, Any] | None=None, hist_kwds: Mapping[str, Any] | None=None, range_padding: float=0.05, **kwargs) -> np.ndarray:
+    plot_backend = _get_plot_backend('matplotlib')
+    return plot_backend.scatter_matrix(frame=frame, alpha=alpha, figsize=figsize, ax=ax, grid=grid, diagonal=diagonal, marker=marker, density_kwds=density_kwds, hist_kwds=hist_kwds, range_padding=range_padding, **kwargs)
+
+def radviz(frame: DataFrame, class_column: str, ax: Axes | None=None, color: list[str] | tuple[str, ...] | None=None, colormap: Colormap | str | None=None, **kwds) -> Axes:
+    plot_backend = _get_plot_backend('matplotlib')
+    return plot_backend.radviz(frame=frame, class_column=class_column, ax=ax, color=color, colormap=colormap, **kwds)
+
+def andrews_curves(frame: DataFrame, class_column: str, ax: Axes | None=None, samples: int=200, color: list[str] | tuple[str, ...] | None=None, colormap: Colormap | str | None=None, **kwargs) -> Axes:
+    plot_backend = _get_plot_backend('matplotlib')
+    return plot_backend.andrews_curves(frame=frame, class_column=class_column, ax=ax, samples=samples, color=color, colormap=colormap, **kwargs)
+
+def bootstrap_plot(series: Series, fig: Figure | None=None, size: int=50, samples: int=500, **kwds) -> Figure:
+    plot_backend = _get_plot_backend('matplotlib')
+    return plot_backend.bootstrap_plot(series=series, fig=fig, size=size, samples=samples, **kwds)
+
+def parallel_coordinates(frame: DataFrame, class_column: str, cols: list[str] | None=None, ax: Axes | None=None, color: list[str] | tuple[str, ...] | None=None, use_columns: bool=False, xticks: list | tuple | None=None, colormap: Colormap | str | None=None, axvlines: bool=True, axvlines_kwds: Mapping[str, Any] | None=None, sort_labels: bool=False, **kwargs) -> Axes:
+    plot_backend = _get_plot_backend('matplotlib')
+    return plot_backend.parallel_coordinates(frame=frame, class_column=class_column, cols=cols, ax=ax, color=color, use_columns=use_columns, xticks=xticks, colormap=colormap, axvlines=axvlines, axvlines_kwds=axvlines_kwds, sort_labels=sort_labels, **kwargs)
+
+def lag_plot(series: Series, lag: int=1, ax: Axes | None=None, **kwds) -> Axes:
+    plot_backend = _get_plot_backend('matplotlib')
+    return plot_backend.lag_plot(series=series, lag=lag, ax=ax, **kwds)
+
+def autocorrelation_plot(series: Series, ax: Axes | None=None, **kwargs) -> Axes:
+    plot_backend = _get_plot_backend('matplotlib')
+    return plot_backend.autocorrelation_plot(series=series, ax=ax, **kwargs)
+
+class _Options(dict):
+    _ALIASES = {'x_compat': 'xaxis.compat'}
+    _DEFAULT_KEYS = ['xaxis.compat']
+
+    def __init__(self) -> None:
+        super().__setitem__('xaxis.compat', False)
+
+    def __getitem__(self, key):
+        key = self._get_canonical_key(key)
+        if key not in self:
+            raise ValueError(f'{key} is not a valid pandas plotting option')
+        return super().__getitem__(key)
+
+    def __setitem__(self, key, value) -> None:
+        key = self._get_canonical_key(key)
+        super().__setitem__(key, value)
+
+    def __delitem__(self, key) -> None:
+        key = self._get_canonical_key(key)
+        if key in self._DEFAULT_KEYS:
+            raise ValueError(f'Cannot remove default parameter {key}')
+        super().__delitem__(key)
+
+    def __contains__(self, key) -> bool:
+        key = self._get_canonical_key(key)
+        return super().__contains__(key)
+
+    def reset(self) -> None:
+        self.__init__()
+
+    def _get_canonical_key(self, key: str) -> str:
+        return self._ALIASES.get(key, key)
+
+    @contextmanager
+    def use(self, key, value) -> Generator[_Options, None, None]:
+        old_value = self[key]
+        try:
+            self[key] = value
+            yield self
+        finally:
+            self[key] = old_value
+plot_params = _Options()
+
+# File: pandas-main/pandas/tseries/frequencies.py
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+from pandas._libs import lib
+from pandas._libs.algos import unique_deltas
+from pandas._libs.tslibs import Timestamp, get_unit_from_dtype, periods_per_day, tz_convert_from_utc
+from pandas._libs.tslibs.ccalendar import DAYS, MONTH_ALIASES, MONTH_NUMBERS, MONTHS, int_to_weekday
+from pandas._libs.tslibs.dtypes import OFFSET_TO_PERIOD_FREQSTR
+from pandas._libs.tslibs.fields import build_field_sarray, month_position_check
+from pandas._libs.tslibs.offsets import DateOffset, Day, to_offset
+from pandas._libs.tslibs.parsing import get_rule_month
+from pandas.util._decorators import cache_readonly
+from pandas.core.dtypes.common import is_numeric_dtype
+from pandas.core.dtypes.dtypes import DatetimeTZDtype, PeriodDtype
+from pandas.core.dtypes.generic import ABCIndex, ABCSeries
+from pandas.core.algorithms import unique
+if TYPE_CHECKING:
+    from pandas._typing import npt
+    from pandas import DatetimeIndex, Series, TimedeltaIndex
+    from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
+_need_suffix = ['QS', 'BQE', 'BQS', 'YS', 'BYE', 'BYS']
+for _prefix in _need_suffix:
+    for _m in MONTHS:
+        key = f'{_prefix}-{_m}'
+        OFFSET_TO_PERIOD_FREQSTR[key] = OFFSET_TO_PERIOD_FREQSTR[_prefix]
+for _prefix in ['Y', 'Q']:
+    for _m in MONTHS:
+        _alias = f'{_prefix}-{_m}'
+        OFFSET_TO_PERIOD_FREQSTR[_alias] = _alias
+for _d in DAYS:
+    OFFSET_TO_PERIOD_FREQSTR[f'W-{_d}'] = f'W-{_d}'
+
+def get_period_alias(offset_str: str) -> str | None:
+    return OFFSET_TO_PERIOD_FREQSTR.get(offset_str, None)
+
+def infer_freq(index: DatetimeIndex | TimedeltaIndex | Series | DatetimeLikeArrayMixin) -> str | None:
+    from pandas.core.api import DatetimeIndex
+    if isinstance(index, ABCSeries):
+        values = index._values
+        if not (lib.is_np_dtype(values.dtype, 'mM') or isinstance(values.dtype, DatetimeTZDtype) or values.dtype == object):
+            raise TypeError(f'cannot infer freq from a non-convertible dtype on a Series of {index.dtype}')
+        index = values
+    inferer: _FrequencyInferer
+    if not hasattr(index, 'dtype'):
+        pass
+    elif isinstance(index.dtype, PeriodDtype):
+        raise TypeError('PeriodIndex given. Check the `freq` attribute instead of using infer_freq.')
+    elif lib.is_np_dtype(index.dtype, 'm'):
+        inferer = _TimedeltaFrequencyInferer(index)
+        return inferer.get_freq()
+    elif is_numeric_dtype(index.dtype):
+        raise TypeError(f'cannot infer freq from a non-convertible index of dtype {index.dtype}')
+    if not isinstance(index, DatetimeIndex):
+        index = DatetimeIndex(index)
+    inferer = _FrequencyInferer(index)
+    return inferer.get_freq()
+
+class _FrequencyInferer:
+
+    def __init__(self, index) -> None:
+        self.index = index
+        self.i8values = index.asi8
+        if isinstance(index, ABCIndex):
+            self._creso = get_unit_from_dtype(index._data._ndarray.dtype)
+        else:
+            self._creso = get_unit_from_dtype(index._ndarray.dtype)
+        if hasattr(index, 'tz'):
+            if index.tz is not None:
+                self.i8values = tz_convert_from_utc(self.i8values, index.tz, reso=self._creso)
+        if len(index) < 3:
+            raise ValueError('Need at least 3 dates to infer frequency')
+        self.is_monotonic = self.index._is_monotonic_increasing or self.index._is_monotonic_decreasing
+
+    @cache_readonly
+    def deltas(self) -> npt.NDArray[np.int64]:
+        return unique_deltas(self.i8values)
+
+    @cache_readonly
+    def deltas_asi8(self) -> npt.NDArray[np.int64]:
+        return unique_deltas(self.index.asi8)
+
+    @cache_readonly
+    def is_unique(self) -> bool:
+        return len(self.deltas) == 1
+
+    @cache_readonly
+    def is_unique_asi8(self) -> bool:
+        return len(self.deltas_asi8) == 1
+
+    def get_freq(self) -> str | None:
+        if not self.is_monotonic or not self.index._is_unique:
+            return None
+        delta = self.deltas[0]
+        ppd = periods_per_day(self._creso)
+        if delta and _is_multiple(delta, ppd):
+            return self._infer_daily_rule()
+        if self.hour_deltas in ([1, 17], [1, 65], [1, 17, 65]):
+            return 'bh'
+        if not self.is_unique_asi8:
+            return None
+        delta = self.deltas_asi8[0]
+        pph = ppd // 24
+        ppm = pph // 60
+        pps = ppm // 60
+        if _is_multiple(delta, pph):
+            return _maybe_add_count('h', delta / pph)
+        elif _is_multiple(delta, ppm):
+            return _maybe_add_count('min', delta / ppm)
+        elif _is_multiple(delta, pps):
+            return _maybe_add_count('s', delta / pps)
+        elif _is_multiple(delta, pps // 1000):
+            return _maybe_add_count('ms', delta / (pps // 1000))
+        elif _is_multiple(delta, pps // 1000000):
+            return _maybe_add_count('us', delta / (pps // 1000000))
+        else:
+            return _maybe_add_count('ns', delta)
+
+    @cache_readonly
+    def day_deltas(self) -> list[int]:
+        ppd = periods_per_day(self._creso)
+        return [x / ppd for x in self.deltas]
+
+    @cache_readonly
+    def hour_deltas(self) -> list[int]:
+        pph = periods_per_day(self._creso) // 24
+        return [x / pph for x in self.deltas]
+
+    @cache_readonly
+    def fields(self) -> np.ndarray:
+        return build_field_sarray(self.i8values, reso=self._creso)
+
+    @cache_readonly
+    def rep_stamp(self) -> Timestamp:
+        return Timestamp(self.i8values[0], unit=self.index.unit)
+
+    def month_position_check(self) -> str | None:
+        return month_position_check(self.fields, self.index.dayofweek)
+
+    @cache_readonly
+    def mdiffs(self) -> npt.NDArray[np.int64]:
+        nmonths = self.fields['Y'] * 12 + self.fields['M']
+        return unique_deltas(nmonths.astype('i8'))
+
+    @cache_readonly
+    def ydiffs(self) -> npt.NDArray[np.int64]:
+        return unique_deltas(self.fields['Y'].astype('i8'))
+
+    def _infer_daily_rule(self) -> str | None:
+        annual_rule = self._get_annual_rule()
+        if annual_rule:
+            nyears = self.ydiffs[0]
+            month = MONTH_ALIASES[self.rep_stamp.month]
+            alias = f'{annual_rule}-{month}'
+            return _maybe_add_count(alias, nyears)
+        quarterly_rule = self._get_quarterly_rule()
+        if quarterly_rule:
+            nquarters = self.mdiffs[0] / 3
+            mod_dict = {0: 12, 2: 11, 1: 10}
+            month = MONTH_ALIASES[mod_dict[self.rep_stamp.month % 3]]
+            alias = f'{quarterly_rule}-{month}'
+            return _maybe_add_count(alias, nquarters)
+        monthly_rule = self._get_monthly_rule()
+        if monthly_rule:
+            return _maybe_add_count(monthly_rule, self.mdiffs[0])
+        if self.is_unique:
+            return self._get_daily_rule()
+        if self._is_business_daily():
+            return 'B'
+        wom_rule = self._get_wom_rule()
+        if wom_rule:
+            return wom_rule
+        return None
+
+    def _get_daily_rule(self) -> str | None:
+        ppd = periods_per_day(self._creso)
+        days = self.deltas[0] / ppd
+        if days % 7 == 0:
+            wd = int_to_weekday[self.rep_stamp.weekday()]
+            alias = f'W-{wd}'
+            return _maybe_add_count(alias, days / 7)
+        else:
+            return _maybe_add_count('D', days)
+
+    def _get_annual_rule(self) -> str | None:
+        if len(self.ydiffs) > 1:
+            return None
+        if len(unique(self.fields['M'])) > 1:
+            return None
+        pos_check = self.month_position_check()
+        if pos_check is None:
+            return None
+        else:
+            return {'cs': 'YS', 'bs': 'BYS', 'ce': 'YE', 'be': 'BYE'}.get(pos_check)
+
+    def _get_quarterly_rule(self) -> str | None:
+        if len(self.mdiffs) > 1:
+            return None
+        if not self.mdiffs[0] % 3 == 0:
+            return None
+        pos_check = self.month_position_check()
+        if pos_check is None:
+            return None
+        else:
+            return {'cs': 'QS', 'bs': 'BQS', 'ce': 'QE', 'be': 'BQE'}.get(pos_check)
+
+    def _get_monthly_rule(self) -> str | None:
+        if len(self.mdiffs) > 1:
+            return None
+        pos_check = self.month_position_check()
+        if pos_check is None:
+            return None
+        else:
+            return {'cs': 'MS', 'bs': 'BMS', 'ce': 'ME', 'be': 'BME'}.get(pos_check)
+
+    def _is_business_daily(self) -> bool:
+        if self.day_deltas != [1, 3]:
+            return False
+        first_weekday = self.index[0].weekday()
+        shifts = np.diff(self.i8values)
+        ppd = periods_per_day(self._creso)
+        shifts = np.floor_divide(shifts, ppd)
+        weekdays = np.mod(first_weekday + np.cumsum(shifts), 7)
+        return bool(np.all((weekdays == 0) & (shifts == 3) | (weekdays > 0) & (weekdays <= 4) & (shifts == 1)))
+
+    def _get_wom_rule(self) -> str | None:
+        weekdays = unique(self.index.weekday)
+        if len(weekdays) > 1:
+            return None
+        week_of_months = unique((self.index.day - 1) // 7)
+        week_of_months = week_of_months[week_of_months < 4]
+        if len(week_of_months) == 0 or len(week_of_months) > 1:
+            return None
+        week = week_of_months[0] + 1
+        wd = int_to_weekday[weekdays[0]]
+        return f'WOM-{week}{wd}'
+
+class _TimedeltaFrequencyInferer(_FrequencyInferer):
+
+    def _infer_daily_rule(self):
+        if self.is_unique:
+            return self._get_daily_rule()
+
+def _is_multiple(us, mult: int) -> bool:
+    return us % mult == 0
+
+def _maybe_add_count(base: str, count: float) -> str:
+    if count != 1:
+        assert count == int(count)
+        count = int(count)
+        return f'{count}{base}'
+    else:
+        return base
+
+def is_subperiod(source, target) -> bool:
+    if target is None or source is None:
+        return False
+    source = _maybe_coerce_freq(source)
+    target = _maybe_coerce_freq(target)
+    if _is_annual(target):
+        if _is_quarterly(source):
+            return _quarter_months_conform(get_rule_month(source), get_rule_month(target))
+        return source in {'D', 'C', 'B', 'M', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif _is_quarterly(target):
+        return source in {'D', 'C', 'B', 'M', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif _is_monthly(target):
+        return source in {'D', 'C', 'B', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif _is_weekly(target):
+        return source in {target, 'D', 'C', 'B', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif target == 'B':
+        return source in {'B', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif target == 'C':
+        return source in {'C', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif target == 'D':
+        return source in {'D', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif target == 'h':
+        return source in {'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif target == 'min':
+        return source in {'min', 's', 'ms', 'us', 'ns'}
+    elif target == 's':
+        return source in {'s', 'ms', 'us', 'ns'}
+    elif target == 'ms':
+        return source in {'ms', 'us', 'ns'}
+    elif target == 'us':
+        return source in {'us', 'ns'}
+    elif target == 'ns':
+        return source in {'ns'}
+    else:
+        return False
+
+def is_superperiod(source, target) -> bool:
+    if target is None or source is None:
+        return False
+    source = _maybe_coerce_freq(source)
+    target = _maybe_coerce_freq(target)
+    if _is_annual(source):
+        if _is_annual(target):
+            return get_rule_month(source) == get_rule_month(target)
+        if _is_quarterly(target):
+            smonth = get_rule_month(source)
+            tmonth = get_rule_month(target)
+            return _quarter_months_conform(smonth, tmonth)
+        return target in {'D', 'C', 'B', 'M', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif _is_quarterly(source):
+        return target in {'D', 'C', 'B', 'M', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif _is_monthly(source):
+        return target in {'D', 'C', 'B', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif _is_weekly(source):
+        return target in {source, 'D', 'C', 'B', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif source == 'B':
+        return target in {'D', 'C', 'B', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif source == 'C':
+        return target in {'D', 'C', 'B', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif source == 'D':
+        return target in {'D', 'C', 'B', 'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif source == 'h':
+        return target in {'h', 'min', 's', 'ms', 'us', 'ns'}
+    elif source == 'min':
+        return target in {'min', 's', 'ms', 'us', 'ns'}
+    elif source == 's':
+        return target in {'s', 'ms', 'us', 'ns'}
+    elif source == 'ms':
+        return target in {'ms', 'us', 'ns'}
+    elif source == 'us':
+        return target in {'us', 'ns'}
+    elif source == 'ns':
+        return target in {'ns'}
+    else:
+        return False
+
+def _maybe_coerce_freq(code) -> str:
+    assert code is not None
+    if isinstance(code, DateOffset):
+        code = PeriodDtype(to_offset(code.name))._freqstr
+    if code in {'h', 'min', 's', 'ms', 'us', 'ns'}:
+        return code
+    else:
+        return code.upper()
+
+def _quarter_months_conform(source: str, target: str) -> bool:
+    snum = MONTH_NUMBERS[source]
+    tnum = MONTH_NUMBERS[target]
+    return snum % 3 == tnum % 3
+
+def _is_annual(rule: str) -> bool:
+    rule = rule.upper()
+    return rule == 'Y' or rule.startswith('Y-')
+
+def _is_quarterly(rule: str) -> bool:
+    rule = rule.upper()
+    return rule == 'Q' or rule.startswith(('Q-', 'BQ'))
+
+def _is_monthly(rule: str) -> bool:
+    rule = rule.upper()
+    return rule in ('M', 'BM')
+
+def _is_weekly(rule: str) -> bool:
+    rule = rule.upper()
+    return rule == 'W' or rule.startswith('W-')
+__all__ = ['Day', 'get_period_alias', 'infer_freq', 'is_subperiod', 'is_superperiod', 'to_offset']
+
+# File: pandas-main/pandas/tseries/holiday.py
+from __future__ import annotations
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING
+import warnings
+from dateutil.relativedelta import FR, MO, SA, SU, TH, TU, WE
+import numpy as np
+from pandas._libs.tslibs.offsets import BaseOffset
+from pandas.errors import PerformanceWarning
+from pandas import DateOffset, DatetimeIndex, Series, Timestamp, concat, date_range
+from pandas.tseries.offsets import Day, Easter
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+def next_monday(dt: datetime) -> datetime:
+    if dt.weekday() == 5:
+        return dt + timedelta(2)
+    elif dt.weekday() == 6:
+        return dt + timedelta(1)
+    return dt
+
+def next_monday_or_tuesday(dt: datetime) -> datetime:
+    dow = dt.weekday()
+    if dow in (5, 6):
+        return dt + timedelta(2)
+    if dow == 0:
+        return dt + timedelta(1)
+    return dt
+
+def previous_friday(dt: datetime) -> datetime:
+    if dt.weekday() == 5:
+        return dt - timedelta(1)
+    elif dt.weekday() == 6:
+        return dt - timedelta(2)
+    return dt
+
+def sunday_to_monday(dt: datetime) -> datetime:
+    if dt.weekday() == 6:
+        return dt + timedelta(1)
+    return dt
+
+def weekend_to_monday(dt: datetime) -> datetime:
+    if dt.weekday() == 6:
+        return dt + timedelta(1)
+    elif dt.weekday() == 5:
+        return dt + timedelta(2)
+    return dt
+
+def nearest_workday(dt: datetime) -> datetime:
+    if dt.weekday() == 5:
+        return dt - timedelta(1)
+    elif dt.weekday() == 6:
+        return dt + timedelta(1)
+    return dt
+
+def next_workday(dt: datetime) -> datetime:
+    dt += timedelta(days=1)
+    while dt.weekday() > 4:
+        dt += timedelta(days=1)
+    return dt
+
+def previous_workday(dt: datetime) -> datetime:
+    dt -= timedelta(days=1)
+    while dt.weekday() > 4:
+        dt -= timedelta(days=1)
+    return dt
+
+def before_nearest_workday(dt: datetime) -> datetime:
+    return previous_workday(nearest_workday(dt))
+
+def after_nearest_workday(dt: datetime) -> datetime:
+    return next_workday(nearest_workday(dt))
+
+class Holiday:
+    start_date: Timestamp | None
+    end_date: Timestamp | None
+    days_of_week: tuple[int, ...] | None
+
+    def __init__(self, name: str, year=None, month=None, day=None, offset: BaseOffset | list[BaseOffset] | None=None, observance: Callable | None=None, start_date=None, end_date=None, days_of_week: tuple | None=None) -> None:
+        if offset is not None:
+            if observance is not None:
+                raise NotImplementedError('Cannot use both offset and observance.')
+            if not (isinstance(offset, BaseOffset) or (isinstance(offset, list) and all((isinstance(off, BaseOffset) for off in offset)))):
+                raise ValueError('Only BaseOffsets and flat lists of them are supported for offset.')
+        self.name = name
+        self.year = year
+        self.month = month
+        self.day = day
+        self.offset = offset
+        self.start_date = Timestamp(start_date) if start_date is not None else start_date
+        self.end_date = Timestamp(end_date) if end_date is not None else end_date
+        self.observance = observance
+        assert days_of_week is None or type(days_of_week) == tuple
+        self.days_of_week = days_of_week
+
+    def __repr__(self) -> str:
+        info = ''
+        if self.year is not None:
+            info += f'year={self.year}, '
+        info += f'month={self.month}, day={self.day}, '
+        if self.offset is not None:
+            info += f'offset={self.offset}'
+        if self.observance is not None:
+            info += f'observance={self.observance}'
+        repr = f'Holiday: {self.name} ({info})'
+        return repr
+
+    def dates(self, start_date, end_date, return_name: bool=False) -> Series | DatetimeIndex:
+        start_date = Timestamp(start_date)
+        end_date = Timestamp(end_date)
+        filter_start_date = start_date
+        filter_end_date = end_date
+        if self.year is not None:
+            dt = Timestamp(datetime(self.year, self.month, self.day))
+            dti = DatetimeIndex([dt])
+            if return_name:
+                return Series(self.name, index=dti)
+            else:
+                return dti
+        dates = self._reference_dates(start_date, end_date)
+        holiday_dates = self._apply_rule(dates)
+        if self.days_of_week is not None:
+            holiday_dates = holiday_dates[np.isin(holiday_dates.dayofweek, self.days_of_week).ravel()]
+        if self.start_date is not None:
+            filter_start_date = max(self.start_date.tz_localize(filter_start_date.tz), filter_start_date)
+        if self.end_date is not None:
+            filter_end_date = min(self.end_date.tz_localize(filter_end_date.tz), filter_end_date)
+        holiday_dates = holiday_dates[(holiday_dates >= filter_start_date) & (holiday_dates <= filter_end_date)]
+        if return_name:
+            return Series(self.name, index=holiday_dates)
+        return holiday_dates
+
+    def _reference_dates(self, start_date: Timestamp, end_date: Timestamp) -> DatetimeIndex:
+        if self.start_date is not None:
+            start_date = self.start_date.tz_localize(start_date.tz)
+        if self.end_date is not None:
+            end_date = self.end_date.tz_localize(start_date.tz)
+        year_offset = DateOffset(years=1)
+        reference_start_date = Timestamp(datetime(start_date.year - 1, self.month, self.day))
+        reference_end_date = Timestamp(datetime(end_date.year + 1, self.month, self.day))
+        dates = date_range(start=reference_start_date, end=reference_end_date, freq=year_offset, tz=start_date.tz)
+        return dates
+
+    def _apply_rule(self, dates: DatetimeIndex) -> DatetimeIndex:
+        if dates.empty:
+            return dates.copy()
+        if self.observance is not None:
+            return dates.map(lambda d: self.observance(d))
+        if self.offset is not None:
+            if not isinstance(self.offset, list):
+                offsets = [self.offset]
+            else:
+                offsets = self.offset
+            for offset in offsets:
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', PerformanceWarning)
+                    dates += offset
+        return dates
+holiday_calendars = {}
+
+def register(cls) -> None:
+    try:
+        name = cls.name
+    except AttributeError:
+        name = cls.__name__
+    holiday_calendars[name] = cls
+
+def get_calendar(name: str) -> AbstractHolidayCalendar:
+    return holiday_calendars[name]()
+
+class HolidayCalendarMetaClass(type):
+
+    def __new__(cls, clsname: str, bases, attrs):
+        calendar_class = super().__new__(cls, clsname, bases, attrs)
+        register(calendar_class)
+        return calendar_class
+
+class AbstractHolidayCalendar(metaclass=HolidayCalendarMetaClass):
+    rules: list[Holiday] = []
+    start_date = Timestamp(datetime(1970, 1, 1))
+    end_date = Timestamp(datetime(2200, 12, 31))
+    _cache = None
+
+    def __init__(self, name: str='', rules=None) -> None:
+        super().__init__()
+        if not name:
+            name = type(self).__name__
+        self.name = name
+        if rules is not None:
+            self.rules = rules
+
+    def rule_from_name(self, name: str) -> Holiday | None:
+        for rule in self.rules:
+            if rule.name == name:
+                return rule
+        return None
+
+    def holidays(self, start=None, end=None, return_name: bool=False):
+        if self.rules is None:
+            raise Exception(f'Holiday Calendar {self.name} does not have any rules specified')
+        if start is None:
+            start = AbstractHolidayCalendar.start_date
+        if end is None:
+            end = AbstractHolidayCalendar.end_date
+        start = Timestamp(start)
+        end = Timestamp(end)
+        if self._cache is None or start < self._cache[0] or end > self._cache[1]:
+            pre_holidays = [rule.dates(start, end, return_name=True) for rule in self.rules]
+            if pre_holidays:
+                holidays = concat(pre_holidays)
+            else:
+                holidays = Series(index=DatetimeIndex([]), dtype=object)
+            self._cache = (start, end, holidays.sort_index())
+        holidays = self._cache[2]
+        holidays = holidays[start:end]
+        if return_name:
+            return holidays
+        else:
+            return holidays.index
+
+    @staticmethod
+    def merge_class(base, other):
+        try:
+            other = other.rules
+        except AttributeError:
+            pass
+        if not isinstance(other, list):
+            other = [other]
+        other_holidays = {holiday.name: holiday for holiday in other}
+        try:
+            base = base.rules
+        except AttributeError:
+            pass
+        if not isinstance(base, list):
+            base = [base]
+        base_holidays = {holiday.name: holiday for holiday in base}
+        other_holidays.update(base_holidays)
+        return list(other_holidays.values())
+
+    def merge(self, other, inplace: bool=False):
+        holidays = self.merge_class(self, other)
+        if inplace:
+            self.rules = holidays
+        else:
+            return holidays
+USMemorialDay = Holiday('Memorial Day', month=5, day=31, offset=DateOffset(weekday=MO(-1)))
+USLaborDay = Holiday('Labor Day', month=9, day=1, offset=DateOffset(weekday=MO(1)))
+USColumbusDay = Holiday('Columbus Day', month=10, day=1, offset=DateOffset(weekday=MO(2)))
+USThanksgivingDay = Holiday('Thanksgiving Day', month=11, day=1, offset=DateOffset(weekday=TH(4)))
+USMartinLutherKingJr = Holiday('Birthday of Martin Luther King, Jr.', start_date=datetime(1986, 1, 1), month=1, day=1, offset=DateOffset(weekday=MO(3)))
+USPresidentsDay = Holiday("Washington's Birthday", month=2, day=1, offset=DateOffset(weekday=MO(3)))
+GoodFriday = Holiday('Good Friday', month=1, day=1, offset=[Easter(), Day(-2)])
+EasterMonday = Holiday('Easter Monday', month=1, day=1, offset=[Easter(), Day(1)])
+
+class USFederalHolidayCalendar(AbstractHolidayCalendar):
+    rules = [Holiday("New Year's Day", month=1, day=1, observance=nearest_workday), USMartinLutherKingJr, USPresidentsDay, USMemorialDay, Holiday('Juneteenth National Independence Day', month=6, day=19, start_date='2021-06-18', observance=nearest_workday), Holiday('Independence Day', month=7, day=4, observance=nearest_workday), USLaborDay, USColumbusDay, Holiday('Veterans Day', month=11, day=11, observance=nearest_workday), USThanksgivingDay, Holiday('Christmas Day', month=12, day=25, observance=nearest_workday)]
+
+def HolidayCalendarFactory(name: str, base, other, base_class=AbstractHolidayCalendar):
+    rules = AbstractHolidayCalendar.merge_class(base, other)
+    calendar_class = type(name, (base_class,), {'rules': rules, 'name': name})
+    return calendar_class
+__all__ = ['after_nearest_workday', 'before_nearest_workday', 'FR', 'get_calendar', 'HolidayCalendarFactory', 'MO', 'nearest_workday', 'next_monday', 'next_monday_or_tuesday', 'next_workday', 'previous_friday', 'previous_workday', 'register', 'SA', 'SU', 'sunday_to_monday', 'TH', 'TU', 'WE', 'weekend_to_monday']
+
+# File: pandas-main/pandas/tseries/offsets.py
+from __future__ import annotations
+from pandas._libs.tslibs.offsets import FY5253, BaseOffset, BDay, BMonthBegin, BMonthEnd, BQuarterBegin, BQuarterEnd, BusinessDay, BusinessHour, BusinessMonthBegin, BusinessMonthEnd, BYearBegin, BYearEnd, CBMonthBegin, CBMonthEnd, CDay, CustomBusinessDay, CustomBusinessHour, CustomBusinessMonthBegin, CustomBusinessMonthEnd, DateOffset, Day, Easter, FY5253Quarter, Hour, LastWeekOfMonth, Micro, Milli, Minute, MonthBegin, MonthEnd, Nano, QuarterBegin, QuarterEnd, Second, SemiMonthBegin, SemiMonthEnd, Tick, Week, WeekOfMonth, YearBegin, YearEnd
+__all__ = ['Day', 'BaseOffset', 'BusinessDay', 'BusinessMonthBegin', 'BusinessMonthEnd', 'BDay', 'CustomBusinessDay', 'CustomBusinessMonthBegin', 'CustomBusinessMonthEnd', 'CDay', 'CBMonthEnd', 'CBMonthBegin', 'MonthBegin', 'BMonthBegin', 'MonthEnd', 'BMonthEnd', 'SemiMonthEnd', 'SemiMonthBegin', 'BusinessHour', 'CustomBusinessHour', 'YearBegin', 'BYearBegin', 'YearEnd', 'BYearEnd', 'QuarterBegin', 'BQuarterBegin', 'QuarterEnd', 'BQuarterEnd', 'LastWeekOfMonth', 'FY5253Quarter', 'FY5253', 'Week', 'WeekOfMonth', 'Easter', 'Tick', 'Hour', 'Minute', 'Second', 'Milli', 'Micro', 'Nano', 'DateOffset']
+
+# File: pandas-main/pandas/util/__init__.py
+def __getattr__(key: str):
+    if key == 'hash_array':
+        from pandas.core.util.hashing import hash_array
+        return hash_array
+    if key == 'hash_pandas_object':
+        from pandas.core.util.hashing import hash_pandas_object
+        return hash_pandas_object
+    if key == 'Appender':
+        from pandas.util._decorators import Appender
+        return Appender
+    if key == 'Substitution':
+        from pandas.util._decorators import Substitution
+        return Substitution
+    if key == 'cache_readonly':
+        from pandas.util._decorators import cache_readonly
+        return cache_readonly
+    raise AttributeError(f"module 'pandas.util' has no attribute '{key}'")
+
+def __dir__() -> list[str]:
+    return list(globals().keys()) + ['hash_array', 'hash_pandas_object']
+
+# File: pandas-main/pandas/util/_decorators.py
+from __future__ import annotations
+from functools import wraps
+import inspect
+from textwrap import dedent
+from typing import TYPE_CHECKING, Any, cast
+import warnings
+from pandas._libs.properties import cache_readonly
+from pandas._typing import F, T
+from pandas.util._exceptions import find_stack_level
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+
+def deprecate(name: str, alternative: Callable[..., Any], version: str, alt_name: str | None=None, klass: type[Warning] | None=None, stacklevel: int=2, msg: str | None=None) -> Callable[[F], F]:
+    alt_name = alt_name or alternative.__name__
+    klass = klass or FutureWarning
+    warning_msg = msg or f'{name} is deprecated, use {alt_name} instead.'
+
+    @wraps(alternative)
+    def wrapper(*args, **kwargs) -> Callable[..., Any]:
+        warnings.warn(warning_msg, klass, stacklevel=stacklevel)
+        return alternative(*args, **kwargs)
+    msg = msg or f'Use `{alt_name}` instead.'
+    doc_error_msg = f'deprecate needs a correctly formatted docstring in the target function (should have a one liner short summary, and opening quotes should be in their own line). Found:\n{alternative.__doc__}'
+    if alternative.__doc__:
+        if alternative.__doc__.count('\n') < 3:
+            raise AssertionError(doc_error_msg)
+        (empty1, summary, empty2, doc_string) = alternative.__doc__.split('\n', 3)
+        if empty1 or (empty2 and (not summary)):
+            raise AssertionError(doc_error_msg)
+        wrapper.__doc__ = dedent(f'\n        {summary.strip()}\n\n        .. deprecated:: {version}\n            {msg}\n\n        {dedent(doc_string)}')
+    return wrapper
+
+def deprecate_kwarg(old_arg_name: str, new_arg_name: str | None, mapping: Mapping[Any, Any] | Callable[[Any], Any] | None=None, stacklevel: int=2) -> Callable[[F], F]:
+    if mapping is not None and (not hasattr(mapping, 'get')) and (not callable(mapping)):
+        raise TypeError('mapping from old to new argument values must be dict or callable!')
+
+    def _deprecate_kwarg(func: F) -> F:
+
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Callable[..., Any]:
+            old_arg_value = kwargs.pop(old_arg_name, None)
+            if old_arg_value is not None:
+                if new_arg_name is None:
+                    msg = f'the {old_arg_name!r} keyword is deprecated and will be removed in a future version. Please take steps to stop the use of {old_arg_name!r}'
+                    warnings.warn(msg, FutureWarning, stacklevel=stacklevel)
+                    kwargs[old_arg_name] = old_arg_value
+                    return func(*args, **kwargs)
+                elif mapping is not None:
+                    if callable(mapping):
+                        new_arg_value = mapping(old_arg_value)
+                    else:
+                        new_arg_value = mapping.get(old_arg_value, old_arg_value)
+                    msg = f'the {old_arg_name}={old_arg_value!r} keyword is deprecated, use {new_arg_name}={new_arg_value!r} instead.'
+                else:
+                    new_arg_value = old_arg_value
+                    msg = f'the {old_arg_name!r} keyword is deprecated, use {new_arg_name!r} instead.'
+                warnings.warn(msg, FutureWarning, stacklevel=stacklevel)
+                if kwargs.get(new_arg_name) is not None:
+                    msg = f'Can only specify {old_arg_name!r} or {new_arg_name!r}, not both.'
+                    raise TypeError(msg)
+                kwargs[new_arg_name] = new_arg_value
+            return func(*args, **kwargs)
+        return cast(F, wrapper)
+    return _deprecate_kwarg
+
+def _format_argument_list(allow_args: list[str]) -> str:
+    if 'self' in allow_args:
+        allow_args.remove('self')
+    if not allow_args:
+        return ''
+    elif len(allow_args) == 1:
+        return f" except for the argument '{allow_args[0]}'"
+    else:
+        last = allow_args[-1]
+        args = ', '.join(["'" + x + "'" for x in allow_args[:-1]])
+        return f" except for the arguments {args} and '{last}'"
+
+def future_version_msg(version: str | None) -> str:
+    if version is None:
+        return 'In a future version of pandas'
+    else:
+        return f'Starting with pandas version {version}'
+
+def deprecate_nonkeyword_arguments(version: str | None, allowed_args: list[str] | None=None, name: str | None=None) -> Callable[[F], F]:
+
+    def decorate(func):
+        old_sig = inspect.signature(func)
+        if allowed_args is not None:
+            allow_args = allowed_args
+        else:
+            allow_args = [p.name for p in old_sig.parameters.values() if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD) and p.default is p.empty]
+        new_params = [p.replace(kind=p.KEYWORD_ONLY) if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD) and p.name not in allow_args else p for p in old_sig.parameters.values()]
+        new_params.sort(key=lambda p: p.kind)
+        new_sig = old_sig.replace(parameters=new_params)
+        num_allow_args = len(allow_args)
+        msg = f'{future_version_msg(version)} all arguments of {name or func.__qualname__}{{arguments}} will be keyword-only.'
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if len(args) > num_allow_args:
+                warnings.warn(msg.format(arguments=_format_argument_list(allow_args)), FutureWarning, stacklevel=find_stack_level())
+            return func(*args, **kwargs)
+        wrapper.__signature__ = new_sig
+        return wrapper
+    return decorate
+
+def doc(*docstrings: None | str | Callable, **params: object) -> Callable[[F], F]:
+
+    def decorator(decorated: F) -> F:
+        docstring_components: list[str | Callable] = []
+        if decorated.__doc__:
+            docstring_components.append(dedent(decorated.__doc__))
+        for docstring in docstrings:
+            if docstring is None:
+                continue
+            if hasattr(docstring, '_docstring_components'):
+                docstring_components.extend(docstring._docstring_components)
+            elif isinstance(docstring, str) or docstring.__doc__:
+                docstring_components.append(docstring)
+        params_applied = [component.format(**params) if isinstance(component, str) and len(params) > 0 else component for component in docstring_components]
+        decorated.__doc__ = ''.join([component if isinstance(component, str) else dedent(component.__doc__ or '') for component in params_applied])
+        decorated._docstring_components = docstring_components
+        return decorated
+    return decorator
+
+class Substitution:
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args and kwargs:
+            raise AssertionError('Only positional or keyword args are allowed')
+        self.params = args or kwargs
+
+    def __call__(self, func: F) -> F:
+        func.__doc__ = func.__doc__ and func.__doc__ % self.params
+        return func
+
+    def update(self, *args, **kwargs) -> None:
+        if isinstance(self.params, dict):
+            self.params.update(*args, **kwargs)
+
+class Appender:
+    addendum: str | None
+
+    def __init__(self, addendum: str | None, join: str='', indents: int=0) -> None:
+        if indents > 0:
+            self.addendum = indent(addendum, indents=indents)
+        else:
+            self.addendum = addendum
+        self.join = join
+
+    def __call__(self, func: T) -> T:
+        func.__doc__ = func.__doc__ if func.__doc__ else ''
+        self.addendum = self.addendum if self.addendum else ''
+        docitems = [func.__doc__, self.addendum]
+        func.__doc__ = dedent(self.join.join(docitems))
+        return func
+
+def indent(text: str | None, indents: int=1) -> str:
+    if not text or not isinstance(text, str):
+        return ''
+    jointext = ''.join(['\n'] + ['    '] * indents)
+    return jointext.join(text.split('\n'))
+__all__ = ['Appender', 'cache_readonly', 'deprecate', 'deprecate_kwarg', 'deprecate_nonkeyword_arguments', 'doc', 'future_version_msg', 'Substitution']
+
+def set_module(module) -> Callable[[F], F]:
+
+    def decorator(func: F) -> F:
+        if module is not None:
+            func.__module__ = module
+        return func
+    return decorator
+
+# File: pandas-main/pandas/util/_doctools.py
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+import pandas as pd
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from matplotlib.figure import Figure
+
+class TablePlotter:
+
+    def __init__(self, cell_width: float=0.37, cell_height: float=0.25, font_size: float=7.5) -> None:
+        self.cell_width = cell_width
+        self.cell_height = cell_height
+        self.font_size = font_size
+
+    def _shape(self, df: pd.DataFrame) -> tuple[int, int]:
+        (row, col) = df.shape
+        return (row + df.columns.nlevels, col + df.index.nlevels)
+
+    def _get_cells(self, left, right, vertical) -> tuple[int, int]:
+        if vertical:
+            vcells = max(sum((self._shape(df)[0] for df in left)), self._shape(right)[0])
+            hcells = max((self._shape(df)[1] for df in left)) + self._shape(right)[1]
+        else:
+            vcells = max([self._shape(df)[0] for df in left] + [self._shape(right)[0]])
+            hcells = sum([self._shape(df)[1] for df in left] + [self._shape(right)[1]])
+        return (hcells, vcells)
+
+    def plot(self, left, right, labels: Iterable[str]=(), vertical: bool=True) -> Figure:
+        from matplotlib import gridspec
+        import matplotlib.pyplot as plt
+        if not isinstance(left, list):
+            left = [left]
+        left = [self._conv(df) for df in left]
+        right = self._conv(right)
+        (hcells, vcells) = self._get_cells(left, right, vertical)
+        if vertical:
+            figsize = (self.cell_width * hcells, self.cell_height * vcells)
+        else:
+            figsize = (self.cell_width * hcells, self.cell_height * vcells)
+        fig = plt.figure(figsize=figsize)
+        if vertical:
+            gs = gridspec.GridSpec(len(left), hcells)
+            max_left_cols = max((self._shape(df)[1] for df in left))
+            max_left_rows = max((self._shape(df)[0] for df in left))
+            for (i, (_left, _label)) in enumerate(zip(left, labels)):
+                ax = fig.add_subplot(gs[i, 0:max_left_cols])
+                self._make_table(ax, _left, title=_label, height=1.0 / max_left_rows)
+            ax = plt.subplot(gs[:, max_left_cols:])
+            self._make_table(ax, right, title='Result', height=1.05 / vcells)
+            fig.subplots_adjust(top=0.9, bottom=0.05, left=0.05, right=0.95)
+        else:
+            max_rows = max((self._shape(df)[0] for df in left + [right]))
+            height = 1.0 / np.max(max_rows)
+            gs = gridspec.GridSpec(1, hcells)
+            i = 0
+            for (df, _label) in zip(left, labels):
+                sp = self._shape(df)
+                ax = fig.add_subplot(gs[0, i:i + sp[1]])
+                self._make_table(ax, df, title=_label, height=height)
+                i += sp[1]
+            ax = plt.subplot(gs[0, i:])
+            self._make_table(ax, right, title='Result', height=height)
+            fig.subplots_adjust(top=0.85, bottom=0.05, left=0.05, right=0.95)
+        return fig
+
+    def _conv(self, data):
+        if isinstance(data, pd.Series):
+            if data.name is None:
+                data = data.to_frame(name='')
+            else:
+                data = data.to_frame()
+        data = data.fillna('NaN')
+        return data
+
+    def _insert_index(self, data):
+        data = data.copy()
+        idx_nlevels = data.index.nlevels
+        if idx_nlevels == 1:
+            data.insert(0, 'Index', data.index)
+        else:
+            for i in range(idx_nlevels):
+                data.insert(i, f'Index{i}', data.index._get_level_values(i))
+        col_nlevels = data.columns.nlevels
+        if col_nlevels > 1:
+            col = data.columns._get_level_values(0)
+            values = [data.columns._get_level_values(i)._values for i in range(1, col_nlevels)]
+            col_df = pd.DataFrame(values)
+            data.columns = col_df.columns
+            data = pd.concat([col_df, data])
+            data.columns = col
+        return data
+
+    def _make_table(self, ax, df, title: str, height: float | None=None) -> None:
+        if df is None:
+            ax.set_visible(False)
+            return
+        from pandas import plotting
+        idx_nlevels = df.index.nlevels
+        col_nlevels = df.columns.nlevels
+        df = self._insert_index(df)
+        tb = plotting.table(ax, df, loc=9)
+        tb.set_fontsize(self.font_size)
+        if height is None:
+            height = 1.0 / (len(df) + 1)
+        props = tb.properties()
+        for ((r, c), cell) in props['celld'].items():
+            if c == -1:
+                cell.set_visible(False)
+            elif r < col_nlevels and c < idx_nlevels:
+                cell.set_visible(False)
+            elif r < col_nlevels or c < idx_nlevels:
+                cell.set_facecolor('#AAAAAA')
+            cell.set_height(height)
+        ax.set_title(title, size=self.font_size)
+        ax.axis('off')
+
+def main() -> None:
+    import matplotlib.pyplot as plt
+    p = TablePlotter()
+    df1 = pd.DataFrame({'A': [10, 11, 12], 'B': [20, 21, 22], 'C': [30, 31, 32]})
+    df2 = pd.DataFrame({'A': [10, 12], 'C': [30, 32]})
+    p.plot([df1, df2], pd.concat([df1, df2]), labels=['df1', 'df2'], vertical=True)
+    plt.show()
+    df3 = pd.DataFrame({'X': [10, 12], 'Z': [30, 32]})
+    p.plot([df1, df3], pd.concat([df1, df3], axis=1), labels=['df1', 'df2'], vertical=False)
+    plt.show()
+    idx = pd.MultiIndex.from_tuples([(1, 'A'), (1, 'B'), (1, 'C'), (2, 'A'), (2, 'B'), (2, 'C')])
+    column = pd.MultiIndex.from_tuples([(1, 'A'), (1, 'B')])
+    df3 = pd.DataFrame({'v1': [1, 2, 3, 4, 5, 6], 'v2': [5, 6, 7, 8, 9, 10]}, index=idx)
+    df3.columns = column
+    p.plot(df3, df3, labels=['df3'])
+    plt.show()
+if __name__ == '__main__':
+    main()
+
+# File: pandas-main/pandas/util/_exceptions.py
+from __future__ import annotations
+import contextlib
+import inspect
+import os
+import re
+from typing import TYPE_CHECKING
+import warnings
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from types import FrameType
+
+@contextlib.contextmanager
+def rewrite_exception(old_name: str, new_name: str) -> Generator[None, None, None]:
+    try:
+        yield
+    except Exception as err:
+        if not err.args:
+            raise
+        msg = str(err.args[0])
+        msg = msg.replace(old_name, new_name)
+        args: tuple[str, ...] = (msg,)
+        if len(err.args) > 1:
+            args = args + err.args[1:]
+        err.args = args
+        raise
+
+def find_stack_level() -> int:
+    import pandas as pd
+    pkg_dir = os.path.dirname(pd.__file__)
+    test_dir = os.path.join(pkg_dir, 'tests')
+    frame: FrameType | None = inspect.currentframe()
+    try:
+        n = 0
+        while frame:
+            filename = inspect.getfile(frame)
+            if filename.startswith(pkg_dir) and (not filename.startswith(test_dir)):
+                frame = frame.f_back
+                n += 1
+            else:
+                break
+    finally:
+        del frame
+    return n
+
+@contextlib.contextmanager
+def rewrite_warning(target_message: str, target_category: type[Warning], new_message: str, new_category: type[Warning] | None=None) -> Generator[None, None, None]:
+    if new_category is None:
+        new_category = target_category
+    with warnings.catch_warnings(record=True) as record:
+        yield
+    if len(record) > 0:
+        match = re.compile(target_message)
+        for warning in record:
+            if warning.category is target_category and re.search(match, str(warning.message)):
+                category = new_category
+                message: Warning | str = new_message
+            else:
+                (category, message) = (warning.category, warning.message)
+            warnings.warn_explicit(message=message, category=category, filename=warning.filename, lineno=warning.lineno)
+
+# File: pandas-main/pandas/util/_print_versions.py
+from __future__ import annotations
+import codecs
+import json
+import locale
+import os
+import platform
+import struct
+import sys
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from pandas._typing import JSONSerializable
+from pandas.compat._optional import VERSIONS, get_version, import_optional_dependency
+
+def _get_commit_hash() -> str | None:
+    try:
+        from pandas._version_meson import __git_version__
+        return __git_version__
+    except ImportError:
+        from pandas._version import get_versions
+        versions = get_versions()
+        return versions['full-revisionid']
+
+def _get_sys_info() -> dict[str, JSONSerializable]:
+    uname_result = platform.uname()
+    (language_code, encoding) = locale.getlocale()
+    return {'commit': _get_commit_hash(), 'python': platform.python_version(), 'python-bits': struct.calcsize('P') * 8, 'OS': uname_result.system, 'OS-release': uname_result.release, 'Version': uname_result.version, 'machine': uname_result.machine, 'processor': uname_result.processor, 'byteorder': sys.byteorder, 'LC_ALL': os.environ.get('LC_ALL'), 'LANG': os.environ.get('LANG'), 'LOCALE': {'language-code': language_code, 'encoding': encoding}}
+
+def _get_dependency_info() -> dict[str, JSONSerializable]:
+    deps = ['pandas', 'numpy', 'dateutil', 'pip', 'Cython', 'sphinx', 'IPython']
+    deps.extend(list(VERSIONS))
+    result: dict[str, JSONSerializable] = {}
+    for modname in deps:
+        try:
+            mod = import_optional_dependency(modname, errors='ignore')
+        except Exception:
+            result[modname] = 'N/A'
+        else:
+            result[modname] = get_version(mod) if mod else None
+    return result
+
+def show_versions(as_json: str | bool=False) -> None:
+    sys_info = _get_sys_info()
+    deps = _get_dependency_info()
+    if as_json:
+        j = {'system': sys_info, 'dependencies': deps}
+        if as_json is True:
+            sys.stdout.writelines(json.dumps(j, indent=2))
+        else:
+            assert isinstance(as_json, str)
+            with codecs.open(as_json, 'wb', encoding='utf8') as f:
+                json.dump(j, f, indent=2)
+    else:
+        assert isinstance(sys_info['LOCALE'], dict)
+        language_code = sys_info['LOCALE']['language-code']
+        encoding = sys_info['LOCALE']['encoding']
+        sys_info['LOCALE'] = f'{language_code}.{encoding}'
+        maxlen = max((len(x) for x in deps))
+        print('\nINSTALLED VERSIONS')
+        print('------------------')
+        for (k, v) in sys_info.items():
+            print(f'{k:<{maxlen}}: {v}')
+        print('')
+        for (k, v) in deps.items():
+            print(f'{k:<{maxlen}}: {v}')
+
+# File: pandas-main/pandas/util/_validators.py
+""""""
+from __future__ import annotations
+from collections.abc import Iterable, Sequence
+from typing import TypeVar, overload
+import numpy as np
+from pandas._libs import lib
+from pandas.core.dtypes.common import is_bool, is_integer
+BoolishT = TypeVar('BoolishT', bool, int)
+BoolishNoneT = TypeVar('BoolishNoneT', bool, int, None)
+
+def _check_arg_length(fname, args, max_fname_arg_count, compat_args) -> None:
+    if max_fname_arg_count < 0:
+        raise ValueError("'max_fname_arg_count' must be non-negative")
+    if len(args) > len(compat_args):
+        max_arg_count = len(compat_args) + max_fname_arg_count
+        actual_arg_count = len(args) + max_fname_arg_count
+        argument = 'argument' if max_arg_count == 1 else 'arguments'
+        raise TypeError(f'{fname}() takes at most {max_arg_count} {argument} ({actual_arg_count} given)')
+
+def _check_for_default_values(fname, arg_val_dict, compat_args) -> None:
+    for key in arg_val_dict:
+        try:
+            v1 = arg_val_dict[key]
+            v2 = compat_args[key]
+            if v1 is not None and v2 is None or (v1 is None and v2 is not None):
+                match = False
+            else:
+                match = v1 == v2
+            if not is_bool(match):
+                raise ValueError("'match' is not a boolean")
+        except ValueError:
+            match = arg_val_dict[key] is compat_args[key]
+        if not match:
+            raise ValueError(f"the '{key}' parameter is not supported in the pandas implementation of {fname}()")
+
+def validate_args(fname, args, max_fname_arg_count, compat_args) -> None:
+    _check_arg_length(fname, args, max_fname_arg_count, compat_args)
+    kwargs = dict(zip(compat_args, args))
+    _check_for_default_values(fname, kwargs, compat_args)
+
+def _check_for_invalid_keys(fname, kwargs, compat_args) -> None:
+    diff = set(kwargs) - set(compat_args)
+    if diff:
+        bad_arg = next(iter(diff))
+        raise TypeError(f"{fname}() got an unexpected keyword argument '{bad_arg}'")
+
+def validate_kwargs(fname, kwargs, compat_args) -> None:
+    kwds = kwargs.copy()
+    _check_for_invalid_keys(fname, kwargs, compat_args)
+    _check_for_default_values(fname, kwds, compat_args)
+
+def validate_args_and_kwargs(fname, args, kwargs, max_fname_arg_count, compat_args) -> None:
+    _check_arg_length(fname, args + tuple(kwargs.values()), max_fname_arg_count, compat_args)
+    args_dict = dict(zip(compat_args, args))
+    for key in args_dict:
+        if key in kwargs:
+            raise TypeError(f"{fname}() got multiple values for keyword argument '{key}'")
+    kwargs.update(args_dict)
+    validate_kwargs(fname, kwargs, compat_args)
+
+def validate_bool_kwarg(value: BoolishNoneT, arg_name: str, none_allowed: bool=True, int_allowed: bool=False) -> BoolishNoneT:
+    good_value = is_bool(value)
+    if none_allowed:
+        good_value = good_value or value is None
+    if int_allowed:
+        good_value = good_value or isinstance(value, int)
+    if not good_value:
+        raise ValueError(f'For argument "{arg_name}" expected type bool, received type {type(value).__name__}.')
+    return value
+
+def validate_fillna_kwargs(value, method, validate_scalar_dict_value: bool=True):
+    from pandas.core.missing import clean_fill_method
+    if value is None and method is None:
+        raise ValueError("Must specify a fill 'value' or 'method'.")
+    if value is None and method is not None:
+        method = clean_fill_method(method)
+    elif value is not None and method is None:
+        if validate_scalar_dict_value and isinstance(value, (list, tuple)):
+            raise TypeError(f'"value" parameter must be a scalar or dict, but you passed a "{type(value).__name__}"')
+    elif value is not None and method is not None:
+        raise ValueError("Cannot specify both 'value' and 'method'.")
+    return (value, method)
+
+def validate_percentile(q: float | Iterable[float]) -> np.ndarray:
+    q_arr = np.asarray(q)
+    msg = 'percentiles should all be in the interval [0, 1]'
+    if q_arr.ndim == 0:
+        if not 0 <= q_arr <= 1:
+            raise ValueError(msg)
+    elif not all((0 <= qs <= 1 for qs in q_arr)):
+        raise ValueError(msg)
+    return q_arr
+
+@overload
+def validate_ascending(ascending: BoolishT) -> BoolishT:
+    ...
+
+@overload
+def validate_ascending(ascending: Sequence[BoolishT]) -> list[BoolishT]:
+    ...
+
+def validate_ascending(ascending: bool | int | Sequence[BoolishT]) -> bool | int | list[BoolishT]:
+    kwargs = {'none_allowed': False, 'int_allowed': True}
+    if not isinstance(ascending, Sequence):
+        return validate_bool_kwarg(ascending, 'ascending', **kwargs)
+    return [validate_bool_kwarg(item, 'ascending', **kwargs) for item in ascending]
+
+def validate_endpoints(closed: str | None) -> tuple[bool, bool]:
+    left_closed = False
+    right_closed = False
+    if closed is None:
+        left_closed = True
+        right_closed = True
+    elif closed == 'left':
+        left_closed = True
+    elif closed == 'right':
+        right_closed = True
+    else:
+        raise ValueError("Closed has to be either 'left', 'right' or None")
+    return (left_closed, right_closed)
+
+def validate_inclusive(inclusive: str | None) -> tuple[bool, bool]:
+    left_right_inclusive: tuple[bool, bool] | None = None
+    if isinstance(inclusive, str):
+        left_right_inclusive = {'both': (True, True), 'left': (True, False), 'right': (False, True), 'neither': (False, False)}.get(inclusive)
+    if left_right_inclusive is None:
+        raise ValueError("Inclusive has to be either 'both', 'neither', 'left' or 'right'")
+    return left_right_inclusive
+
+def validate_insert_loc(loc: int, length: int) -> int:
+    if not is_integer(loc):
+        raise TypeError(f'loc must be an integer between -{length} and {length}')
+    if loc < 0:
+        loc += length
+    if not 0 <= loc <= length:
+        raise IndexError(f'loc must be an integer between -{length} and {length}')
+    return loc
+
+def check_dtype_backend(dtype_backend) -> None:
+    if dtype_backend is not lib.no_default:
+        if dtype_backend not in ['numpy_nullable', 'pyarrow']:
+            raise ValueError(f"dtype_backend {dtype_backend} is invalid, only 'numpy_nullable' and 'pyarrow' are allowed.")
+
+# File: pandas-main/pandas/util/version/__init__.py
+from __future__ import annotations
+from collections.abc import Callable
+import itertools
+import re
+from typing import Any, NamedTuple, SupportsInt, Union
+__all__ = ['VERSION_PATTERN', 'InvalidVersion', 'Version', 'parse']
+
+class InfinityType:
+
+    def __repr__(self) -> str:
+        return 'Infinity'
+
+    def __hash__(self) -> int:
+        return hash(repr(self))
+
+    def __lt__(self, other: object) -> bool:
+        return False
+
+    def __le__(self, other: object) -> bool:
+        return False
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, type(self))
+
+    def __gt__(self, other: object) -> bool:
+        return True
+
+    def __ge__(self, other: object) -> bool:
+        return True
+
+    def __neg__(self: object) -> NegativeInfinityType:
+        return NegativeInfinity
+Infinity = InfinityType()
+
+class NegativeInfinityType:
+
+    def __repr__(self) -> str:
+        return '-Infinity'
+
+    def __hash__(self) -> int:
+        return hash(repr(self))
+
+    def __lt__(self, other: object) -> bool:
+        return True
+
+    def __le__(self, other: object) -> bool:
+        return True
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, type(self))
+
+    def __gt__(self, other: object) -> bool:
+        return False
+
+    def __ge__(self, other: object) -> bool:
+        return False
+
+    def __neg__(self: object) -> InfinityType:
+        return Infinity
+NegativeInfinity = NegativeInfinityType()
+LocalType = tuple[Union[int, str], ...]
+CmpPrePostDevType = Union[InfinityType, NegativeInfinityType, tuple[str, int]]
+CmpLocalType = Union[NegativeInfinityType, tuple[Union[tuple[int, str], tuple[NegativeInfinityType, Union[int, str]]], ...]]
+CmpKey = tuple[int, tuple[int, ...], CmpPrePostDevType, CmpPrePostDevType, CmpPrePostDevType, CmpLocalType]
+VersionComparisonMethod = Callable[[CmpKey, CmpKey], bool]
+
+class _Version(NamedTuple):
+    epoch: int
+    release: tuple[int, ...]
+    dev: tuple[str, int] | None
+    pre: tuple[str, int] | None
+    post: tuple[str, int] | None
+    local: LocalType | None
+
+def parse(version: str) -> Version:
+    return Version(version)
+
+class InvalidVersion(ValueError):
+
+class _BaseVersion:
+    _key: tuple[Any, ...]
+
+    def __hash__(self) -> int:
+        return hash(self._key)
+
+    def __lt__(self, other: _BaseVersion) -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+        return self._key < other._key
+
+    def __le__(self, other: _BaseVersion) -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+        return self._key <= other._key
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+        return self._key == other._key
+
+    def __ge__(self, other: _BaseVersion) -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+        return self._key >= other._key
+
+    def __gt__(self, other: _BaseVersion) -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+        return self._key > other._key
+
+    def __ne__(self, other: object) -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+        return self._key != other._key
+_VERSION_PATTERN = '\n    v?\n    (?:\n        (?:(?P<epoch>[0-9]+)!)?                           # epoch\n        (?P<release>[0-9]+(?:\\.[0-9]+)*)                  # release segment\n        (?P<pre>                                          # pre-release\n            [-_\\.]?\n            (?P<pre_l>alpha|a|beta|b|preview|pre|c|rc)\n            [-_\\.]?\n            (?P<pre_n>[0-9]+)?\n        )?\n        (?P<post>                                         # post release\n            (?:-(?P<post_n1>[0-9]+))\n            |\n            (?:\n                [-_\\.]?\n                (?P<post_l>post|rev|r)\n                [-_\\.]?\n                (?P<post_n2>[0-9]+)?\n            )\n        )?\n        (?P<dev>                                          # dev release\n            [-_\\.]?\n            (?P<dev_l>dev)\n            [-_\\.]?\n            (?P<dev_n>[0-9]+)?\n        )?\n    )\n    (?:\\+(?P<local>[a-z0-9]+(?:[-_\\.][a-z0-9]+)*))?       # local version\n'
+VERSION_PATTERN = _VERSION_PATTERN
+
+class Version(_BaseVersion):
+    _regex = re.compile('^\\s*' + VERSION_PATTERN + '\\s*$', re.VERBOSE | re.IGNORECASE)
+    _key: CmpKey
+
+    def __init__(self, version: str) -> None:
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion(f"Invalid version: '{version}'")
+        self._version = _Version(epoch=int(match.group('epoch')) if match.group('epoch') else 0, release=tuple((int(i) for i in match.group('release').split('.'))), pre=_parse_letter_version(match.group('pre_l'), match.group('pre_n')), post=_parse_letter_version(match.group('post_l'), match.group('post_n1') or match.group('post_n2')), dev=_parse_letter_version(match.group('dev_l'), match.group('dev_n')), local=_parse_local_version(match.group('local')))
+        self._key = _cmpkey(self._version.epoch, self._version.release, self._version.pre, self._version.post, self._version.dev, self._version.local)
+
+    def __repr__(self) -> str:
+        return f"<Version('{self}')>"
+
+    def __str__(self) -> str:
+        parts = []
+        if self.epoch != 0:
+            parts.append(f'{self.epoch}!')
+        parts.append('.'.join((str(x) for x in self.release)))
+        if self.pre is not None:
+            parts.append(''.join((str(x) for x in self.pre)))
+        if self.post is not None:
+            parts.append(f'.post{self.post}')
+        if self.dev is not None:
+            parts.append(f'.dev{self.dev}')
+        if self.local is not None:
+            parts.append(f'+{self.local}')
+        return ''.join(parts)
+
+    @property
+    def epoch(self) -> int:
+        return self._version.epoch
+
+    @property
+    def release(self) -> tuple[int, ...]:
+        return self._version.release
+
+    @property
+    def pre(self) -> tuple[str, int] | None:
+        return self._version.pre
+
+    @property
+    def post(self) -> int | None:
+        return self._version.post[1] if self._version.post else None
+
+    @property
+    def dev(self) -> int | None:
+        return self._version.dev[1] if self._version.dev else None
+
+    @property
+    def local(self) -> str | None:
+        if self._version.local:
+            return '.'.join((str(x) for x in self._version.local))
+        else:
+            return None
+
+    @property
+    def public(self) -> str:
+        return str(self).split('+', 1)[0]
+
+    @property
+    def base_version(self) -> str:
+        parts = []
+        if self.epoch != 0:
+            parts.append(f'{self.epoch}!')
+        parts.append('.'.join((str(x) for x in self.release)))
+        return ''.join(parts)
+
+    @property
+    def is_prerelease(self) -> bool:
+        return self.dev is not None or self.pre is not None
+
+    @property
+    def is_postrelease(self) -> bool:
+        return self.post is not None
+
+    @property
+    def is_devrelease(self) -> bool:
+        return self.dev is not None
+
+    @property
+    def major(self) -> int:
+        return self.release[0] if len(self.release) >= 1 else 0
+
+    @property
+    def minor(self) -> int:
+        return self.release[1] if len(self.release) >= 2 else 0
+
+    @property
+    def micro(self) -> int:
+        return self.release[2] if len(self.release) >= 3 else 0
+
+def _parse_letter_version(letter: str | None, number: str | bytes | SupportsInt | None) -> tuple[str, int] | None:
+    if letter:
+        if number is None:
+            number = 0
+        letter = letter.lower()
+        if letter == 'alpha':
+            letter = 'a'
+        elif letter == 'beta':
+            letter = 'b'
+        elif letter in ['c', 'pre', 'preview']:
+            letter = 'rc'
+        elif letter in ['rev', 'r']:
+            letter = 'post'
+        return (letter, int(number))
+    if not letter and number:
+        letter = 'post'
+        return (letter, int(number))
+    return None
+_local_version_separators = re.compile('[\\._-]')
+
+def _parse_local_version(local: str | None) -> LocalType | None:
+    if local is not None:
+        return tuple((part.lower() if not part.isdigit() else int(part) for part in _local_version_separators.split(local)))
+    return None
+
+def _cmpkey(epoch: int, release: tuple[int, ...], pre: tuple[str, int] | None, post: tuple[str, int] | None, dev: tuple[str, int] | None, local: LocalType | None) -> CmpKey:
+    _release = tuple(reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release)))))
+    if pre is None and post is None and (dev is not None):
+        _pre: CmpPrePostDevType = NegativeInfinity
+    elif pre is None:
+        _pre = Infinity
+    else:
+        _pre = pre
+    if post is None:
+        _post: CmpPrePostDevType = NegativeInfinity
+    else:
+        _post = post
+    if dev is None:
+        _dev: CmpPrePostDevType = Infinity
+    else:
+        _dev = dev
+    if local is None:
+        _local: CmpLocalType = NegativeInfinity
+    else:
+        _local = tuple(((i, '') if isinstance(i, int) else (NegativeInfinity, i) for i in local))
+    return (epoch, _release, _pre, _post, _dev, _local)
+