setup.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# __coconut_hash__ = 0x6935ef16

# Compiled with Coconut version 3.0.0-a_dev36

# Coconut Header: -------------------------------------------------------------

from __future__ import print_function, absolute_import, unicode_literals, division
import sys as _coconut_sys
_coconut_cached__coconut__ = _coconut_sys.modules.get(str('_coconut_cached__coconut__'), _coconut_sys.modules.get(str('__coconut__')))
if _coconut_sys.version_info < (3,):
    from __builtin__ import chr, dict, hex, input, int, map, object, oct, open, print, range, str, super, zip, filter, reversed, enumerate, raw_input, xrange, repr, long
    py_chr, py_dict, py_hex, py_input, py_int, py_map, py_object, py_oct, py_open, py_print, py_range, py_str, py_super, py_zip, py_filter, py_reversed, py_enumerate, py_raw_input, py_xrange, py_repr = chr, dict, hex, input, int, map, object, oct, open, print, range, str, super, zip, filter, reversed, enumerate, raw_input, xrange, repr
    _coconut_py_raw_input, _coconut_py_xrange, _coconut_py_int, _coconut_py_long, _coconut_py_print, _coconut_py_str, _coconut_py_super, _coconut_py_unicode, _coconut_py_repr, _coconut_py_dict = raw_input, xrange, int, long, print, str, super, unicode, repr, dict
    from functools import wraps as _coconut_wraps
    from collections import Sequence as _coconut_Sequence
    from future_builtins import *
    chr, str = unichr, unicode
    from io import open
    class object(object):
        __slots__ = ()
        def __ne__(self, other):
            eq = self == other
            return _coconut.NotImplemented if eq is _coconut.NotImplemented else not eq
        def __nonzero__(self):
            if _coconut.hasattr(self, "__bool__"):
                got = self.__bool__()
                if not _coconut.isinstance(got, _coconut.bool):
                    raise _coconut.TypeError("__bool__ should return bool, returned " + _coconut.type(got).__name__)
                return got
            return True
    class int(_coconut_py_int):
        __slots__ = ()
        __doc__ = getattr(_coconut_py_int, "__doc__", "<see help(py_int)>")
        class __metaclass__(type):
            def __instancecheck__(cls, inst):
                return _coconut.isinstance(inst, (_coconut_py_int, _coconut_py_long))
            def __subclasscheck__(cls, subcls):
                return _coconut.issubclass(subcls, (_coconut_py_int, _coconut_py_long))
    class range(object):
        __slots__ = ("_xrange",)
        __doc__ = getattr(_coconut_py_xrange, "__doc__", "<see help(py_xrange)>")
        def __init__(self, *args):
            self._xrange = _coconut_py_xrange(*args)
        def __iter__(self):
            return _coconut.iter(self._xrange)
        def __reversed__(self):
            return _coconut.reversed(self._xrange)
        def __len__(self):
            return _coconut.len(self._xrange)
        def __bool__(self):
            return _coconut.bool(self._xrange)
        def __contains__(self, elem):
            return elem in self._xrange
        def __getitem__(self, index):
            if _coconut.isinstance(index, _coconut.slice):
                args = _coconut.slice(*self._args)
                start, stop, step = (args.start if args.start is not None else 0), args.stop, (args.step if args.step is not None else 1)
                if index.start is None:
                    new_start = start if index.step is None or index.step >= 0 else stop - step
                elif index.start >= 0:
                    new_start = start + step * index.start
                    if (step >= 0 and new_start >= stop) or (step < 0 and new_start <= stop):
                        new_start = stop
                else:
                    new_start = stop + step * index.start
                    if (step >= 0 and new_start <= start) or (step < 0 and new_start >= start):
                        new_start = start
                if index.stop is None:
                    new_stop = stop if index.step is None or index.step >= 0 else start - step
                elif index.stop >= 0:
                    new_stop = start + step * index.stop
                    if (step >= 0 and new_stop >= stop) or (step < 0 and new_stop <= stop):
                        new_stop = stop
                else:
                    new_stop = stop + step * index.stop
                    if (step >= 0 and new_stop <= start) or (step < 0 and new_stop >= start):
                        new_stop = start
                new_step = step if index.step is None else step * index.step
                return self.__class__(new_start, new_stop, new_step)
            else:
                return self._xrange[index]
        def count(self, elem):
            """Count the number of times elem appears in the range."""
            return _coconut_py_int(elem in self._xrange)
        def index(self, elem):
            """Find the index of elem in the range."""
            if elem not in self._xrange: raise _coconut.ValueError(_coconut.repr(elem) + " is not in range")
            start, _, step = self._xrange.__reduce_ex__(2)[1]
            return (elem - start) // step
        def __repr__(self):
            return _coconut.repr(self._xrange)[1:]
        @property
        def _args(self):
            return self._xrange.__reduce__()[1]
        def __reduce_ex__(self, protocol):
            return (self.__class__, self._xrange.__reduce_ex__(protocol)[1])
        def __reduce__(self):
            return self.__reduce_ex__(_coconut.pickle.DEFAULT_PROTOCOL)
        def __hash__(self):
            return _coconut.hash(self._args)
        def __copy__(self):
            return self.__class__(*self._args)
        def __eq__(self, other):
            return self.__class__ is other.__class__ and self._args == other._args
    _coconut_Sequence.register(range)
    @_coconut_wraps(_coconut_py_print)
    def print(*args, **kwargs):
        file = kwargs.get("file", _coconut_sys.stdout)
        if "flush" in kwargs:
            flush = kwargs["flush"]
            del kwargs["flush"]
        else:
            flush = False
        if _coconut.getattr(file, "encoding", None) is not None:
            _coconut_py_print(*(_coconut_py_unicode(x).encode(file.encoding) for x in args), **kwargs)
        else:
            _coconut_py_print(*args, **kwargs)
        if flush:
            file.flush()
    @_coconut_wraps(_coconut_py_raw_input)
    def input(*args, **kwargs):
        if _coconut.getattr(_coconut_sys.stdout, "encoding", None) is not None:
            return _coconut_py_raw_input(*args, **kwargs).decode(_coconut_sys.stdout.encoding)
        return _coconut_py_raw_input(*args, **kwargs).decode()
    @_coconut_wraps(_coconut_py_repr)
    def repr(obj):
        import __builtin__
        try:
            __builtin__.repr = _coconut_repr
            if isinstance(obj, _coconut_py_unicode):
                return _coconut_py_unicode(_coconut_py_repr(obj)[1:])
            if isinstance(obj, _coconut_py_str):
                return "b" + _coconut_py_unicode(_coconut_py_repr(obj))
            return _coconut_py_unicode(_coconut_py_repr(obj))
        finally:
            __builtin__.repr = _coconut_py_repr
    ascii = _coconut_repr = repr
    def raw_input(*args):
        """Coconut uses Python 3 'input' instead of Python 2 'raw_input'."""
        raise _coconut.NameError("Coconut uses Python 3 'input' instead of Python 2 'raw_input'")
    def xrange(*args):
        """Coconut uses Python 3 'range' instead of Python 2 'xrange'."""
        raise _coconut.NameError("Coconut uses Python 3 'range' instead of Python 2 'xrange'")
    def _coconut_exec(obj, globals=None, locals=None):
        """Execute the given source in the context of globals and locals."""
        if locals is None:
            locals = _coconut_sys._getframe(1).f_locals if globals is None else globals
        if globals is None:
            globals = _coconut_sys._getframe(1).f_globals
        exec(obj, globals, locals)
    def _coconut_default_breakpointhook(*args, **kwargs):
        hookname = _coconut.os.getenv("PYTHONBREAKPOINT")
        if hookname != "0":
            if not hookname:
                hookname = "pdb.set_trace"
            modname, dot, funcname = hookname.rpartition(".")
            if not dot:
                modname = "builtins" if _coconut_sys.version_info >= (3,) else "__builtin__"
            if _coconut_sys.version_info >= (2, 7):
                import importlib
                module = importlib.import_module(modname)
            else:
                import imp
                module = imp.load_module(modname, *imp.find_module(modname))
            hook = _coconut.getattr(module, funcname)
            return hook(*args, **kwargs)
    if not hasattr(_coconut_sys, "__breakpointhook__"):
        _coconut_sys.__breakpointhook__ = _coconut_default_breakpointhook
    def breakpoint(*args, **kwargs):
        return _coconut.getattr(_coconut_sys, "breakpointhook", _coconut_default_breakpointhook)(*args, **kwargs)
    if _coconut_sys.version_info < (2, 7):
        import functools as _coconut_functools, copy_reg as _coconut_copy_reg
        def _coconut_new_partial(func, args, keywords):
            return _coconut_functools.partial(func, *(args if args is not None else ()), **(keywords if keywords is not None else {}))
        _coconut_copy_reg.constructor(_coconut_new_partial)
        def _coconut_reduce_partial(self):
            return (_coconut_new_partial, (self.func, self.args, self.keywords))
        _coconut_copy_reg.pickle(_coconut_functools.partial, _coconut_reduce_partial)
    from collections import OrderedDict as _coconut_OrderedDict
    class _coconut_dict_base(_coconut_OrderedDict):
        __slots__ = ()
        __doc__ = getattr(_coconut_OrderedDict, "__doc__", "<see help(py_dict)>")
        __eq__ = _coconut_py_dict.__eq__
        def __repr__(self):
            return "{" + ", ".join("{k!r}: {v!r}".format(k=k, v=v) for k, v in self.items()) + "}"
        def __or__(self, other):
            out = self.copy()
            out.update(other)
            return out
        def __ror__(self, other):
            out = self.__class__(other)
            out.update(self)
            return out
        def __ior__(self, other):
            self.update(other)
            return self
    class _coconut_dict_meta(type):
        def __instancecheck__(cls, inst):
            return _coconut.isinstance(inst, _coconut_py_dict)
        def __subclasscheck__(cls, subcls):
            return _coconut.issubclass(subcls, _coconut_py_dict)
    dict = _coconut_dict_meta(py_str("dict"), _coconut_dict_base.__bases__, _coconut_dict_base.__dict__.copy())
    dict.keys = _coconut_OrderedDict.viewkeys
    dict.values = _coconut_OrderedDict.viewvalues
    dict.items = _coconut_OrderedDict.viewitems
else:
    from builtins import chr, dict, hex, input, int, map, object, oct, open, print, range, str, super, zip, filter, reversed, enumerate, repr
    py_chr, py_dict, py_hex, py_input, py_int, py_map, py_object, py_oct, py_open, py_print, py_range, py_str, py_super, py_zip, py_filter, py_reversed, py_enumerate, py_repr = chr, dict, hex, input, int, map, object, oct, open, print, range, str, super, zip, filter, reversed, enumerate, repr
    _coconut_py_str, _coconut_py_super, _coconut_py_dict = str, super, dict
    from functools import wraps as _coconut_wraps
    exec("_coconut_exec = exec")
    if _coconut_sys.version_info < (3, 7):
        def _coconut_default_breakpointhook(*args, **kwargs):
            hookname = _coconut.os.getenv("PYTHONBREAKPOINT")
            if hookname != "0":
                if not hookname:
                    hookname = "pdb.set_trace"
                modname, dot, funcname = hookname.rpartition(".")
                if not dot:
                    modname = "builtins" if _coconut_sys.version_info >= (3,) else "__builtin__"
                if _coconut_sys.version_info >= (2, 7):
                    import importlib
                    module = importlib.import_module(modname)
                else:
                    import imp
                    module = imp.load_module(modname, *imp.find_module(modname))
                hook = _coconut.getattr(module, funcname)
                return hook(*args, **kwargs)
        if not hasattr(_coconut_sys, "__breakpointhook__"):
            _coconut_sys.__breakpointhook__ = _coconut_default_breakpointhook
        def breakpoint(*args, **kwargs):
            return _coconut.getattr(_coconut_sys, "breakpointhook", _coconut_default_breakpointhook)(*args, **kwargs)
    else:
        py_breakpoint = breakpoint
    if _coconut_sys.version_info < (3, 7):
        from collections import OrderedDict as _coconut_OrderedDict
        class _coconut_dict_base(_coconut_OrderedDict):
            __slots__ = ()
            __doc__ = getattr(_coconut_OrderedDict, "__doc__", "<see help(py_dict)>")
            __eq__ = _coconut_py_dict.__eq__
            def __repr__(self):
                return "{" + ", ".join("{k!r}: {v!r}".format(k=k, v=v) for k, v in self.items()) + "}"
            def __or__(self, other):
                out = self.copy()
                out.update(other)
                return out
            def __ror__(self, other):
                out = self.__class__(other)
                out.update(self)
                return out
            def __ior__(self, other):
                self.update(other)
                return self
        class _coconut_dict_meta(type):
            def __instancecheck__(cls, inst):
                return _coconut.isinstance(inst, _coconut_py_dict)
            def __subclasscheck__(cls, subcls):
                return _coconut.issubclass(subcls, _coconut_py_dict)
        dict = _coconut_dict_meta(py_str("dict"), _coconut_dict_base.__bases__, _coconut_dict_base.__dict__.copy())
    elif _coconut_sys.version_info < (3, 9):
        class _coconut_dict_base(_coconut_py_dict):
            __slots__ = ()
            __doc__ = getattr(_coconut_py_dict, "__doc__", "<see help(py_dict)>")
            def __or__(self, other):
                out = self.copy()
                out.update(other)
                return out
            def __ror__(self, other):
                out = self.__class__(other)
                out.update(self)
                return out
            def __ior__(self, other):
                self.update(other)
                return self
        class _coconut_dict_meta(type):
            def __instancecheck__(cls, inst):
                return _coconut.isinstance(inst, _coconut_py_dict)
            def __subclasscheck__(cls, subcls):
                return _coconut.issubclass(subcls, _coconut_py_dict)
        dict = _coconut_dict_meta(py_str("dict"), _coconut_dict_base.__bases__, _coconut_dict_base.__dict__.copy())
@_coconut_wraps(_coconut_py_super)
def _coconut_super(type=None, object_or_type=None):
    if type is None:
        if object_or_type is not None:
            raise _coconut.TypeError("invalid use of super()")
        frame = _coconut_sys._getframe(1)
        try:
            cls = frame.f_locals["__class__"]
        except _coconut.AttributeError:
            raise _coconut.RuntimeError("super(): __class__ cell not found")
        self = frame.f_locals[frame.f_code.co_varnames[0]]
        return _coconut_py_super(cls, self)
    return _coconut_py_super(type, object_or_type)
super = _coconut_super
class _coconut(object):
    import collections, copy, functools, types, itertools, operator, threading, os, warnings, contextlib, traceback, weakref, multiprocessing
    from multiprocessing import dummy as multiprocessing_dummy
    if _coconut_sys.version_info < (3, 2):
        try:
            from backports.functools_lru_cache import lru_cache
            functools.lru_cache = lru_cache
        except ImportError:
            class you_need_to_install_backports_functools_lru_cache(object):
                __slots__ = ()
            functools.lru_cache = you_need_to_install_backports_functools_lru_cache()
    if _coconut_sys.version_info < (3,):
        import copy_reg as copyreg
    else:
        import copyreg
    if _coconut_sys.version_info < (3, 4):
        try:
            import trollius as asyncio
        except ImportError:
            class you_need_to_install_trollius(object):
                __slots__ = ()
            asyncio = you_need_to_install_trollius()
    else:
        import asyncio
    if _coconut_sys.version_info < (3,):
        import cPickle as pickle
    else:
        import pickle
    OrderedDict = collections.OrderedDict if _coconut_sys.version_info >= (2, 7) else dict
    if _coconut_sys.version_info < (3, 3):
        abc = collections
    else:
        import collections.abc as abc
    if _coconut_sys.version_info < (3, 5):
        class typing_mock(object):
            """The typing module is not available at runtime in Python 3.4 or earlier;
            try hiding your typedefs behind an 'if TYPE_CHECKING:' block."""
            TYPE_CHECKING = False
            Any = Ellipsis
            def cast(self, t, x):
                """typing.cast[T](t: Type[T], x: Any) -> T = x"""
                return x
            def __getattr__(self, name):
                raise _coconut.ImportError("the typing module is not available at runtime in Python 3.4 or earlier; try hiding your typedefs behind an 'if TYPE_CHECKING:' block")
            def TypeVar(name, *args, **kwargs):
                """Runtime mock of typing.TypeVar for Python 3.4 and earlier."""
                return name
            class Generic_mock(object):
                """Runtime mock of typing.Generic for Python 3.4 and earlier."""
                __slots__ = ()
                def __getitem__(self, vars):
                    return _coconut.object
            Generic = Generic_mock()
        typing = typing_mock()
    else:
        import typing
    if _coconut_sys.version_info < (3, 6):
        def NamedTuple(name, fields):
            return _coconut.collections.namedtuple(name, [x for x, t in fields])
        typing.NamedTuple = NamedTuple
        NamedTuple = staticmethod(NamedTuple)
    if _coconut_sys.version_info < (3, 8):
        try:
            from typing_extensions import Protocol
        except ImportError:
            class YouNeedToInstallTypingExtensions(object):
                __slots__ = ()
            Protocol = YouNeedToInstallTypingExtensions
        typing.Protocol = Protocol
    if _coconut_sys.version_info < (3, 10):
        try:
            from typing_extensions import TypeAlias, ParamSpec, Concatenate
        except ImportError:
            class you_need_to_install_typing_extensions(object):
                __slots__ = ()
            TypeAlias = ParamSpec = Concatenate = you_need_to_install_typing_extensions()
        typing.TypeAlias = TypeAlias
        typing.ParamSpec = ParamSpec
        typing.Concatenate = Concatenate
    if _coconut_sys.version_info < (3, 11):
        try:
            from typing_extensions import TypeVarTuple, Unpack
        except ImportError:
            class you_need_to_install_typing_extensions(object):
                __slots__ = ()
            TypeVarTuple = Unpack = you_need_to_install_typing_extensions()
        typing.TypeVarTuple = TypeVarTuple
        typing.Unpack = Unpack
    zip_longest = itertools.zip_longest if _coconut_sys.version_info >= (3,) else itertools.izip_longest
    try:
        import numpy
    except ImportError:
        class you_need_to_install_numpy(object):
            __slots__ = ()
        numpy = you_need_to_install_numpy()
    else:
        abc.Sequence.register(numpy.ndarray)
    numpy_modules = ('numpy', 'pandas', 'torch', 'jaxlib.xla_extension')
    jax_numpy_modules = ('jaxlib.xla_extension',)
    tee_type = type(itertools.tee((), 1)[0])
    reiterables = abc.Sequence, abc.Mapping, abc.Set
    abc.Sequence.register(collections.deque)
    Ellipsis, NotImplemented, NotImplementedError, Exception, AttributeError, ImportError, IndexError, KeyError, NameError, TypeError, ValueError, StopIteration, RuntimeError, all, any, bool, bytes, callable, classmethod, complex, dict, enumerate, filter, float, frozenset, getattr, hasattr, hash, id, int, isinstance, issubclass, iter, len, list, locals, globals, map, min, max, next, object, property, range, reversed, set, setattr, slice, str, sum, super, tuple, type, vars, zip, repr, print, bytearray = Ellipsis, NotImplemented, NotImplementedError, Exception, AttributeError, ImportError, IndexError, KeyError, NameError, TypeError, ValueError, StopIteration, RuntimeError, all, any, bool, bytes, callable, classmethod, complex, dict, enumerate, filter, float, frozenset, getattr, hasattr, hash, id, int, isinstance, issubclass, iter, len, list, locals, globals, map, min, max, next, object, property, range, reversed, set, setattr, slice, str, sum, staticmethod(super), tuple, type, vars, zip, staticmethod(repr), staticmethod(print), bytearray
def _coconut_handle_cls_kwargs(**kwargs):
    """Some code taken from six under the terms of its MIT license."""
    metaclass = kwargs.pop("metaclass", None)
    if kwargs and metaclass is None:
        raise _coconut.TypeError("unexpected keyword argument(s) in class definition: %r" % (kwargs,))
    def coconut_handle_cls_kwargs_wrapper(cls):
        if metaclass is None:
            return cls
        orig_vars = cls.__dict__.copy()
        slots = orig_vars.get("__slots__")
        if slots is not None:
            if _coconut.isinstance(slots, _coconut.str):
                slots = [slots]
            for slots_var in slots:
                orig_vars.pop(slots_var)
        orig_vars.pop("__dict__", None)
        orig_vars.pop("__weakref__", None)
        if _coconut.hasattr(cls, "__qualname__"):
            orig_vars["__qualname__"] = cls.__qualname__
        return metaclass(cls.__name__, cls.__bases__, orig_vars, **kwargs)
    return coconut_handle_cls_kwargs_wrapper
def _coconut_handle_cls_stargs(*args):
    temp_names = ["_coconut_base_cls_%s" % (i,) for i in _coconut.range(_coconut.len(args))]
    ns = _coconut_py_dict(_coconut.zip(temp_names, args))
    _coconut_exec("class _coconut_cls_stargs_base(" + ", ".join(temp_names) + "): pass", ns)
    return ns["_coconut_cls_stargs_base"]
class _coconut_baseclass(object):
    __slots__ = ("__weakref__",)
    def __reduce_ex__(self, _):
        return self.__reduce__()
    def __eq__(self, other):
        return self.__class__ is other.__class__ and self.__reduce__() == other.__reduce__()
    def __hash__(self):
        return _coconut.hash(self.__reduce__())
    def __setstate__(self, setvars):
        for k, v in setvars.items():
            _coconut.setattr(self, k, v)
class _coconut_Sentinel(_coconut_baseclass):
    __slots__ = ()
    def __reduce__(self):
        return (self.__class__, ())
_coconut_sentinel = _coconut_Sentinel()
class MatchError(_coconut_baseclass, Exception):
    """Pattern-matching error. Has attributes .pattern, .value, and .message."""
    max_val_repr_len = 500
    def __init__(self, pattern=None, value=None):
        self.pattern = pattern
        self.value = value
        self._message = None
    @property
    def message(self):
        if self._message is None:
            val_repr = _coconut.repr(self.value)
            self._message = "pattern-matching failed for %s in %s" % (_coconut.repr(self.pattern), val_repr if _coconut.len(val_repr) <= self.max_val_repr_len else val_repr[:self.max_val_repr_len] + "...")
            Exception.__init__(self, self._message)
        return self._message
    def __repr__(self):
        self.message
        return Exception.__repr__(self)
    def __str__(self):
        self.message
        return Exception.__str__(self)
    def __unicode__(self):
        self.message
        return Exception.__unicode__(self)
    def __reduce__(self):
        return (self.__class__, (self.pattern, self.value), {"_message": self._message})
    def __setstate__(self, state):
        _coconut_baseclass.__setstate__(self, state)
        if self._message is not None:
            Exception.__init__(self, self._message)
_coconut_cached_MatchError = None if _coconut_cached__coconut__ is None else getattr(_coconut_cached__coconut__, "MatchError", None)
if _coconut_cached_MatchError is not None:
    if _coconut_sys.version_info >= (3,):
        for _coconut_varname in dir(MatchError):
            try:
                setattr(_coconut_cached_MatchError, _coconut_varname, getattr(MatchError, _coconut_varname))
            except (AttributeError, TypeError):
                pass
    MatchError = _coconut_cached_MatchError
class _coconut_tail_call(_coconut_baseclass):
    __slots__ = ("func", "args", "kwargs")
    def __init__(self, _coconut_func, *args, **kwargs):
        self.func = _coconut_func
        self.args = args
        self.kwargs = kwargs
    def __reduce__(self):
        return (self.__class__, (self.func, self.args, self.kwargs))
_coconut_tco_func_dict = _coconut.dict()
def _coconut_tco(func):
    @_coconut.functools.wraps(func)
    def tail_call_optimized_func(*args, **kwargs):
        call_func = func
        while True:
            if _coconut.isinstance(call_func, _coconut_base_pattern_func):
                call_func = call_func._coconut_tco_func
            elif _coconut.isinstance(call_func, _coconut.types.MethodType):
                wkref = _coconut_tco_func_dict.get(_coconut.id(call_func.__func__))
                wkref_func = None if wkref is None else wkref()
                if wkref_func is call_func.__func__:
                    if call_func.__self__ is None:
                        call_func = call_func._coconut_tco_func
                    else:
                        call_func = _coconut.functools.partial(call_func._coconut_tco_func, call_func.__self__)
            else:
                wkref = _coconut_tco_func_dict.get(_coconut.id(call_func))
                wkref_func = None if wkref is None else wkref()
                if wkref_func is call_func:
                    call_func = call_func._coconut_tco_func
            result = call_func(*args, **kwargs)  # use 'coconut --no-tco' to clean up your traceback
            if not isinstance(result, _coconut_tail_call):
                return result
            call_func, args, kwargs = result.func, result.args, result.kwargs
    tail_call_optimized_func._coconut_tco_func = func
    tail_call_optimized_func.__module__ = _coconut.getattr(func, "__module__", None)
    tail_call_optimized_func.__name__ = _coconut.getattr(func, "__name__", None)
    tail_call_optimized_func.__qualname__ = _coconut.getattr(func, "__qualname__", None)
    _coconut_tco_func_dict[_coconut.id(tail_call_optimized_func)] = _coconut.weakref.ref(tail_call_optimized_func)
    return tail_call_optimized_func
@_coconut.functools.wraps(_coconut.itertools.tee)
def tee(iterable, n=2):
    if n < 0:
        raise ValueError("tee: n cannot be negative")
    elif n == 0:
        return ()
    elif n == 1:
        return (iterable,)
    elif _coconut.isinstance(iterable, _coconut.reiterables):
        return (iterable,) * n
    else:
        if _coconut.getattr(iterable, "__getitem__", None) is not None or _coconut.isinstance(iterable, (_coconut.tee_type, _coconut.abc.Sized, _coconut.abc.Container)):
            existing_copies = [iterable]
            while _coconut.len(existing_copies) < n:
                try:
                    copy = _coconut.copy.copy(iterable)
                except _coconut.TypeError:
                    break
                else:
                    existing_copies.append(copy)
            else:
                return _coconut.tuple(existing_copies)
        return _coconut.itertools.tee(iterable, n)
class _coconut_has_iter(_coconut_baseclass):
    __slots__ = ("lock", "iter")
    def __new__(cls, iterable):
        self = _coconut.object.__new__(cls)
        self.lock = _coconut.threading.Lock()
        self.iter = iterable
        return self
    def get_new_iter(self):
        """Tee the underlying iterator."""
        with self.lock:
            self.iter = _coconut_reiterable(self.iter)
        return self.iter
    def __fmap__(self, func):
        return _coconut_map(func, self)
class reiterable(_coconut_has_iter):
    """Allow an iterator to be iterated over multiple times with the same results."""
    __slots__ = ()
    def __new__(cls, iterable):
        if _coconut.isinstance(iterable, _coconut.reiterables):
            return iterable
        return _coconut_has_iter.__new__(cls, iterable)
    def get_new_iter(self):
        """Tee the underlying iterator."""
        with self.lock:
            self.iter, new_iter = _coconut_tee(self.iter)
        return new_iter
    def __iter__(self):
        return _coconut.iter(self.get_new_iter())
    def __repr__(self):
        return "reiterable(%s)" % (_coconut.repr(self.get_new_iter()),)
    def __reduce__(self):
        return (self.__class__, (self.iter,))
    def __copy__(self):
        return self.__class__(self.get_new_iter())
    def __getitem__(self, index):
        return _coconut_iter_getitem(self.get_new_iter(), index)
    def __reversed__(self):
        return _coconut_reversed(self.get_new_iter())
    def __len__(self):
        if not _coconut.isinstance(self.iter, _coconut.abc.Sized):
            return _coconut.NotImplemented
        return _coconut.len(self.get_new_iter())
    def __contains__(self, elem):
        return elem in self.get_new_iter()
    def count(self, elem):
        """Count the number of times elem appears in the iterable."""
        return self.get_new_iter().count(elem)
    def index(self, elem):
        """Find the index of elem in the iterable."""
        return self.get_new_iter().index(elem)
_coconut.reiterables = (reiterable,) + _coconut.reiterables
def _coconut_iter_getitem_special_case(iterable, start, stop, step):
    iterable = _coconut.itertools.islice(iterable, start, None)
    cache = _coconut.collections.deque(_coconut.itertools.islice(iterable, -stop), maxlen=-stop)
    for index, item in _coconut.enumerate(iterable):
        cached_item = cache.popleft()
        if index % step == 0:
            yield cached_item
        cache.append(item)
def _coconut_iter_getitem(iterable, index):
    """Iterator slicing works just like sequence slicing, including support for negative indices and slices, and support for `slice` objects in the same way as can be done with normal slicing.

    Coconut's iterator slicing is very similar to Python's `itertools.islice`, but unlike `itertools.islice`, Coconut's iterator slicing supports negative indices, and will preferentially call an object's `__iter_getitem__` (Coconut-specific magic method, preferred) or `__getitem__` (general Python magic method), if they exist. Coconut's iterator slicing is also optimized to work well with all of Coconut's built-in objects, only computing the elements of each that are actually necessary to extract the desired slice.

    Some code taken from more_itertools under the terms of its MIT license.
    """
    obj_iter_getitem = _coconut.getattr(iterable, "__iter_getitem__", None)
    if obj_iter_getitem is None:
        obj_iter_getitem = _coconut.getattr(iterable, "__getitem__", None)
    if obj_iter_getitem is not None:
        try:
            result = obj_iter_getitem(index)
        except _coconut.NotImplementedError:
            pass
        else:
            if result is not _coconut.NotImplemented:
                return result
    if not _coconut.isinstance(index, _coconut.slice):
        index = _coconut.operator.index(index)
        if index < 0:
            return _coconut.collections.deque(iterable, maxlen=-index)[0]
        result = _coconut.next(_coconut.itertools.islice(iterable, index, index + 1), _coconut_sentinel)
        if result is _coconut_sentinel:
            raise _coconut.IndexError(".$[] index out of range")
        return result
    start = _coconut.operator.index(index.start) if index.start is not None else None
    stop = _coconut.operator.index(index.stop) if index.stop is not None else None
    step = _coconut.operator.index(index.step) if index.step is not None else 1
    if step == 0:
        raise _coconut.ValueError("slice step cannot be zero")
    if start is None and stop is None and step == -1:
        obj_reversed = _coconut.getattr(iterable, "__reversed__", None)
        if obj_reversed is not None:
            try:
                result = obj_reversed()
            except _coconut.NotImplementedError:
                pass
            else:
                if result is not _coconut.NotImplemented:
                    return result
    if step >= 0:
        start = 0 if start is None else start
        if start < 0:
            cache = _coconut.collections.deque(_coconut.enumerate(iterable, 1), maxlen=-start)
            len_iter = cache[-1][0] if cache else 0
            i = _coconut.max(len_iter + start, 0)
            if stop is None:
                j = len_iter
            elif stop >= 0:
                j = _coconut.min(stop, len_iter)
            else:
                j = _coconut.max(len_iter + stop, 0)
            n = j - i
            if n <= 0:
                return ()
            if n < -start or step != 1:
                cache = _coconut.itertools.islice(cache, 0, n, step)
            return _coconut_map(_coconut.operator.itemgetter(1), cache)
        elif stop is None or stop >= 0:
            return _coconut.itertools.islice(iterable, start, stop, step)
        else:
            return _coconut_iter_getitem_special_case(iterable, start, stop, step)
    else:
        start = -1 if start is None else start
        if stop is not None and stop < 0:
            n = -stop - 1
            cache = _coconut.collections.deque(_coconut.enumerate(iterable, 1), maxlen=n)
            len_iter = cache[-1][0] if cache else 0
            if start < 0:
                i, j = start, stop
            else:
                i, j = _coconut.min(start - len_iter, -1), None
            return _coconut_map(_coconut.operator.itemgetter(1), _coconut.tuple(cache)[i:j:step])
        else:
            if stop is not None:
                m = stop + 1
                iterable = _coconut.itertools.islice(iterable, m, None)
            if start < 0:
                i = start
                n = None
            elif stop is None:
                i = None
                n = start + 1
            else:
                i = None
                n = start - stop
            if n is not None:
                if n <= 0:
                    return ()
                iterable = _coconut.itertools.islice(iterable, 0, n)
            return _coconut.tuple(iterable)[i::step]
class _coconut_base_compose(_coconut_baseclass):
    __slots__ = ("func", "func_infos")
    def __init__(self, func, *func_infos):
        self.func = func
        self.func_infos = []
        for f, stars, none_aware in func_infos:
            if _coconut.isinstance(f, _coconut_base_compose):
                self.func_infos.append((f.func, stars, none_aware))
                self.func_infos += f.func_infos
            else:
                self.func_infos.append((f, stars, none_aware))
        self.func_infos = _coconut.tuple(self.func_infos)
    def __call__(self, *args, **kwargs):
        arg = self.func(*args, **kwargs)
        for f, stars, none_aware in self.func_infos:
            if none_aware and arg is None:
                return arg
            if stars == 0:
                arg = f(arg)
            elif stars == 1:
                arg = f(*arg)
            elif stars == 2:
                arg = f(**arg)
            else:
                raise _coconut.RuntimeError("invalid internal stars value " + _coconut.repr(stars) + " in " + _coconut.repr(self) + " (you should report this at https://github.com/evhub/coconut/issues/new)")
        return arg
    def __repr__(self):
        return _coconut.repr(self.func) + " " + " ".join(".." + "?"*none_aware + "*"*stars + "> " + _coconut.repr(f) for f, stars, none_aware in self.func_infos)
    def __reduce__(self):
        return (self.__class__, (self.func,) + self.func_infos)
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        if _coconut_sys.version_info < (3,):
            return _coconut.types.MethodType(self, obj, objtype)
        else:
            return _coconut.types.MethodType(self, obj)
def _coconut_forward_compose(func, *funcs):
    """Forward composition operator (..>).

    (..>)(f, g) is effectively equivalent to (*args, **kwargs) -> g(f(*args, **kwargs))."""
    return _coconut_base_compose(func, *((f, 0, False) for f in funcs))
def _coconut_back_compose(*funcs):
    """Backward composition operator (<..).

    (<..)(f, g) is effectively equivalent to (*args, **kwargs) -> f(g(*args, **kwargs))."""
    return _coconut_forward_compose(*_coconut.reversed(funcs))
def _coconut_forward_star_compose(func, *funcs):
    """Forward star composition operator (..*>).

    (..*>)(f, g) is effectively equivalent to (*args, **kwargs) -> g(*f(*args, **kwargs))."""
    return _coconut_base_compose(func, *((f, 1, False) for f in funcs))
def _coconut_back_star_compose(*funcs):
    """Backward star composition operator (<*..).

    (<*..)(f, g) is effectively equivalent to (*args, **kwargs) -> f(*g(*args, **kwargs))."""
    return _coconut_forward_star_compose(*_coconut.reversed(funcs))
def _coconut_forward_dubstar_compose(func, *funcs):
    """Forward double star composition operator (..**>).

    (..**>)(f, g) is effectively equivalent to (*args, **kwargs) -> g(**f(*args, **kwargs))."""
    return _coconut_base_compose(func, *((f, 2, False) for f in funcs))
def _coconut_back_dubstar_compose(*funcs):
    """Backward double star composition operator (<**..).

    (<**..)(f, g) is effectively equivalent to (*args, **kwargs) -> f(**g(*args, **kwargs))."""
    return _coconut_forward_dubstar_compose(*_coconut.reversed(funcs))
def _coconut_forward_none_compose(func, *funcs):
    """Forward none-aware composition operator (..?>).

    (..?>)(f, g) is effectively equivalent to (*args, **kwargs) -> g?(f(*args, **kwargs))."""
    return _coconut_base_compose(func, *((f, 0, True) for f in funcs))
def _coconut_back_none_compose(*funcs):
    """Backward none-aware composition operator (<..?).

    (<..?)(f, g) is effectively equivalent to (*args, **kwargs) -> f?(g(*args, **kwargs))."""
    return _coconut_forward_none_compose(*_coconut.reversed(funcs))
def _coconut_forward_none_star_compose(func, *funcs):
    """Forward none-aware star composition operator (..?*>).

    (..?*>)(f, g) is effectively equivalent to (*args, **kwargs) -> g?(*f(*args, **kwargs))."""
    return _coconut_base_compose(func, *((f, 1, True) for f in funcs))
def _coconut_back_none_star_compose(*funcs):
    """Backward none-aware star composition operator (<*?..).

    (<*?..)(f, g) is effectively equivalent to (*args, **kwargs) -> f?(*g(*args, **kwargs))."""
    return _coconut_forward_none_star_compose(*_coconut.reversed(funcs))
def _coconut_forward_none_dubstar_compose(func, *funcs):
    """Forward none-aware double star composition operator (..?**>).

    (..?**>)(f, g) is effectively equivalent to (*args, **kwargs) -> g?(**f(*args, **kwargs))."""
    return _coconut_base_compose(func, *((f, 2, True) for f in funcs))
def _coconut_back_none_dubstar_compose(*funcs):
    """Backward none-aware double star composition operator (<**?..).

    (<**?..)(f, g) is effectively equivalent to (*args, **kwargs) -> f?(**g(*args, **kwargs))."""
    return _coconut_forward_none_dubstar_compose(*_coconut.reversed(funcs))
def _coconut_pipe(x, f):
    """Pipe operator (|>). Equivalent to (x, f) -> f(x)."""
    return f(x)
def _coconut_star_pipe(xs, f):
    """Star pipe operator (*|>). Equivalent to (xs, f) -> f(*xs)."""
    return f(*xs)
def _coconut_dubstar_pipe(kws, f):
    """Double star pipe operator (**|>). Equivalent to (kws, f) -> f(**kws)."""
    return f(**kws)
def _coconut_back_pipe(f, x):
    """Backward pipe operator (<|). Equivalent to (f, x) -> f(x)."""
    return f(x)
def _coconut_back_star_pipe(f, xs):
    """Backward star pipe operator (<*|). Equivalent to (f, xs) -> f(*xs)."""
    return f(*xs)
def _coconut_back_dubstar_pipe(f, kws):
    """Backward double star pipe operator (<**|). Equivalent to (f, kws) -> f(**kws)."""
    return f(**kws)
def _coconut_none_pipe(x, f):
    """Nullable pipe operator (|?>). Equivalent to (x, f) -> f(x) if x is not None else None."""
    return None if x is None else f(x)
def _coconut_none_star_pipe(xs, f):
    """Nullable star pipe operator (|?*>). Equivalent to (xs, f) -> f(*xs) if xs is not None else None."""
    return None if xs is None else f(*xs)
def _coconut_none_dubstar_pipe(kws, f):
    """Nullable double star pipe operator (|?**>). Equivalent to (kws, f) -> f(**kws) if kws is not None else None."""
    return None if kws is None else f(**kws)
def _coconut_back_none_pipe(f, x):
    """Nullable backward pipe operator (<?|). Equivalent to (f, x) -> f(x) if x is not None else None."""
    return None if x is None else f(x)
def _coconut_back_none_star_pipe(f, xs):
    """Nullable backward star pipe operator (<*?|). Equivalent to (f, xs) -> f(*xs) if xs is not None else None."""
    return None if xs is None else f(*xs)
def _coconut_back_none_dubstar_pipe(f, kws):
    """Nullable backward double star pipe operator (<**?|). Equivalent to (kws, f) -> f(**kws) if kws is not None else None."""
    return None if kws is None else f(**kws)
def _coconut_assert(cond, msg=None):
    """Assert operator (assert). Asserts condition with optional message."""
    if not cond:
        assert False, msg if msg is not None else "(assert) got falsey value " + _coconut.repr(cond)
def _coconut_raise(exc=None, from_exc=None):
    """Raise operator (raise). Raises exception with optional cause."""
    if exc is None:
        raise
    if from_exc is not None:
        exc.__cause__ = from_exc
    raise exc
def _coconut_bool_and(a, b):
    """Boolean and operator (and). Equivalent to (a, b) -> a and b."""
    return a and b
def _coconut_bool_or(a, b):
    """Boolean or operator (or). Equivalent to (a, b) -> a or b."""
    return a or b
def _coconut_in(a, b):
    """Containment operator (in). Equivalent to (a, b) -> a in b."""
    return a in b
def _coconut_not_in(a, b):
    """Negative containment operator (not in). Equivalent to (a, b) -> a not in b."""
    return a not in b
def _coconut_none_coalesce(a, b):
    """None coalescing operator (??). Equivalent to (a, b) -> a if a is not None else b."""
    return b if a is None else a
def _coconut_minus(a, b=_coconut_sentinel):
    """Minus operator (-). Effectively equivalent to (a, b=None) -> a - b if b is not None else -a."""
    if b is _coconut_sentinel:
        return -a
    return a - b
def _coconut_comma_op(*args):
    """Comma operator (,). Equivalent to (*args) -> args."""
    return args
if _coconut_sys.version_info < (3, 5):
    def _coconut_matmul(a, b, **kwargs):
        """Matrix multiplication operator (@). Implements operator.matmul on any Python version."""
        in_place = kwargs.pop("in_place", False)
        if kwargs:
            raise _coconut.TypeError("_coconut_matmul() got unexpected keyword arguments " + _coconut.repr(kwargs))
        if in_place and _coconut.hasattr(a, "__imatmul__"):
            try:
                result = a.__imatmul__(b)
            except _coconut.NotImplementedError:
                pass
            else:
                if result is not _coconut.NotImplemented:
                    return result
        if _coconut.hasattr(a, "__matmul__"):
            try:
                result = a.__matmul__(b)
            except _coconut.NotImplementedError:
                pass
            else:
                if result is not _coconut.NotImplemented:
                    return result
        if _coconut.hasattr(b, "__rmatmul__"):
            try:
                result = b.__rmatmul__(a)
            except _coconut.NotImplementedError:
                pass
            else:
                if result is not _coconut.NotImplemented:
                    return result
        if "numpy" in (a.__class__.__module__, b.__class__.__module__):
            from numpy import matmul
            return matmul(a, b)
        raise _coconut.TypeError("unsupported operand type(s) for @: " + _coconut.repr(_coconut.type(a)) + " and " + _coconut.repr(_coconut.type(b)))
else:
    _coconut_matmul = _coconut.operator.matmul
class scan(_coconut_has_iter):
    """Reduce func over iterable, yielding intermediate results,
    optionally starting from initial."""
    __slots__ = ("func", "initial")
    def __new__(cls, function, iterable, initial=_coconut_sentinel):
        self = _coconut_has_iter.__new__(cls, iterable)
        self.func = function
        self.initial = initial
        return self
    def __repr__(self):
        return "scan(%r, %s%s)" % (self.func, _coconut.repr(self.iter), "" if self.initial is _coconut_sentinel else ", " + _coconut.repr(self.initial))
    def __reduce__(self):
        return (self.__class__, (self.func, self.iter, self.initial))
    def __copy__(self):
        return self.__class__(self.func, self.get_new_iter(), self.initial)
    def __iter__(self):
        acc = self.initial
        if acc is not _coconut_sentinel:
            yield acc
        for item in self.iter:
            if acc is _coconut_sentinel:
                acc = item
            else:
                acc = self.func(acc, item)
            yield acc
    def __len__(self):
        if not _coconut.isinstance(self.iter, _coconut.abc.Sized):
            return _coconut.NotImplemented
        return _coconut.len(self.iter)
class reversed(_coconut_has_iter):
    __slots__ = ()
    __doc__ = getattr(_coconut.reversed, "__doc__", "<see help(py_reversed)>")
    def __new__(cls, iterable):
        if _coconut.isinstance(iterable, _coconut.range):
            return iterable[::-1]
        if _coconut.getattr(iterable, "__reversed__", None) is None or _coconut.isinstance(iterable, (_coconut.list, _coconut.tuple)):
            self = _coconut_has_iter.__new__(cls, iterable)
            return self
        return _coconut.reversed(iterable)
    def __repr__(self):
        return "reversed(%s)" % (_coconut.repr(self.iter),)
    def __reduce__(self):
        return (self.__class__, (self.iter,))
    def __copy__(self):
        return self.__class__(self.get_new_iter())
    def __iter__(self):
        return _coconut.iter(_coconut.reversed(self.iter))
    def __getitem__(self, index):
        if _coconut.isinstance(index, _coconut.slice):
            return _coconut_iter_getitem(self.iter, _coconut.slice(-(index.start + 1) if index.start is not None else None, -(index.stop + 1) if index.stop else None, -(index.step if index.step is not None else 1)))
        return _coconut_iter_getitem(self.iter, -(index + 1))
    def __reversed__(self):
        return self.iter
    def __len__(self):
        if not _coconut.isinstance(self.iter, _coconut.abc.Sized):
            return _coconut.NotImplemented
        return _coconut.len(self.iter)
    def __contains__(self, elem):
        return elem in self.iter
    def count(self, elem):
        """Count the number of times elem appears in the reversed iterable."""
        return self.iter.count(elem)
    def index(self, elem):
        """Find the index of elem in the reversed iterable."""
        return _coconut.len(self.iter) - self.iter.index(elem) - 1
    def __fmap__(self, func):
        return self.__class__(_coconut_map(func, self.iter))
class flatten(_coconut_has_iter):
    """Flatten an iterable of iterables into a single iterable.
    Only flattens the top level of the iterable."""
    __slots__ = ("levels", "_made_reit")
    def __new__(cls, iterable, levels=1):
        if levels is not None:
            levels = _coconut.operator.index(levels)
            if levels < 0:
                raise _coconut.ValueError("flatten: levels cannot be negative")
            if levels == 0:
                return iterable
        self = _coconut_has_iter.__new__(cls, iterable)
        self.levels = levels
        self._made_reit = False
        return self
    def get_new_iter(self):
        """Tee the underlying iterator."""
        with self.lock:
            if not self._made_reit:
                for i in _coconut.reversed(_coconut.range(0 if self.levels is None else self.levels + 1)):
                    mapper = _coconut_reiterable
                    for _ in _coconut.range(i):
                        mapper = _coconut.functools.partial(_coconut_map, mapper)
                    self.iter = mapper(self.iter)
                self._made_reit = True
        return self.iter
    def __iter__(self):
        if self.levels is None:
            return self._iter_all_levels()
        new_iter = self.iter
        for _ in _coconut.range(self.levels):
            new_iter = _coconut.itertools.chain.from_iterable(new_iter)
        return new_iter
    def _iter_all_levels(self, new=False):
        """Iterate over all levels of the iterable."""
        for item in (self.get_new_iter() if new else self.iter):
            if _coconut.isinstance(item, _coconut.abc.Iterable):
                for subitem in self.__class__(item, None):
                    yield subitem
            else:
                yield item
    def __reversed__(self):
        if self.levels is None:
            return _coconut.reversed(_coconut.tuple(self._iter_all_levels(new=True)))
        reversed_iter = self.get_new_iter()
        for i in _coconut.reversed(_coconut.range(self.levels + 1)):
            reverser = _coconut_reversed
            for _ in _coconut.range(i):
                reverser = _coconut.functools.partial(_coconut_map, reverser)
            reversed_iter = reverser(reversed_iter)
        return self.__class__(reversed_iter, self.levels)
    def __repr__(self):
        return "flatten(" + _coconut.repr(self.iter) + (", " + _coconut.repr(self.levels) if self.levels is not None else "") + ")"
    def __reduce__(self):
        return (self.__class__, (self.iter, self.levels))
    def __copy__(self):
        return self.__class__(self.get_new_iter(), self.levels)
    def __contains__(self, elem):
        if self.levels == 1:
            return _coconut.any(elem in it for it in self.get_new_iter())
        raise _coconut.TypeError("flatten.__contains__ only supported for levels=1")
    def count(self, elem):
        """Count the number of times elem appears in the flattened iterable."""
        if self.levels != 1:
            raise _coconut.ValueError("flatten.count only supported for levels=1")
        return _coconut.sum(it.count(elem) for it in self.get_new_iter())
    def index(self, elem):
        """Find the index of elem in the flattened iterable."""
        if self.levels != 1:
            raise _coconut.ValueError("flatten.index only supported for levels=1")
        ind = 0
        for it in self.get_new_iter():
            try:
                return ind + it.index(elem)
            except _coconut.ValueError:
                ind += _coconut.len(it)
        raise ValueError("%r not in %r" % (elem, self))
    def __fmap__(self, func):
        if self.levels == 1:
            return self.__class__(_coconut_map(_coconut.functools.partial(_coconut_map, func), self.get_new_iter()))
        return _coconut_map(func, self)
class cartesian_product(_coconut_baseclass):
    __slots__ = ("iters", "repeat")
    __doc__ = getattr(_coconut.itertools.product, "__doc__", "Cartesian product of input iterables.") + """

Additionally supports Cartesian products of numpy arrays."""
    def __new__(cls, *iterables, **kwargs):
        repeat = _coconut.operator.index(kwargs.pop("repeat", 1))
        if kwargs:
            raise _coconut.TypeError("cartesian_product() got unexpected keyword arguments " + _coconut.repr(kwargs))
        if repeat == 0:
            iterables = ()
            repeat = 1
        if repeat < 0:
            raise _coconut.ValueError("cartesian_product: repeat cannot be negative")
        if iterables and _coconut.all(it.__class__.__module__ in _coconut.numpy_modules for it in iterables):
            if _coconut.any(it.__class__.__module__ in _coconut.jax_numpy_modules for it in iterables):
                from jax import numpy
            else:
                numpy = _coconut.numpy
            iterables *= repeat
            dtype = numpy.result_type(*iterables)
            arr = numpy.empty([_coconut.len(a) for a in iterables] + [_coconut.len(iterables)], dtype=dtype)
            for i, a in _coconut.enumerate(numpy.ix_(*iterables)):
                arr[..., i] = a
            return arr.reshape(-1, _coconut.len(iterables))
        self = _coconut.object.__new__(cls)
        self.iters = iterables
        self.repeat = repeat
        return self
    def __iter__(self):
        return _coconut.itertools.product(*self.iters, repeat=self.repeat)
    def __repr__(self):
        return "cartesian_product(" + ", ".join(_coconut.repr(it) for it in self.iters) + (", repeat=" + _coconut.repr(self.repeat) if self.repeat != 1 else "") + ")"
    def __reduce__(self):
        return (self.__class__, self.iters, {"repeat": self.repeat})
    def __copy__(self):
        self.iters = _coconut.tuple(_coconut_reiterable(it) for it in self.iters)
        return self.__class__(*self.iters, repeat=self.repeat)
    @property
    def all_iters(self):
        return _coconut.itertools.chain.from_iterable(_coconut.itertools.repeat(self.iters, self.repeat))
    def __len__(self):
        total_len = 1
        for it in self.iters:
            if not _coconut.isinstance(it, _coconut.abc.Sized):
                return _coconut.NotImplemented
            total_len *= _coconut.len(it)
        return total_len ** self.repeat
    def __contains__(self, elem):
        for e, it in _coconut.zip_longest(elem, self.all_iters, fillvalue=_coconut_sentinel):
            if e is _coconut_sentinel or it is _coconut_sentinel or e not in it:
                return False
        return True
    def count(self, elem):
        """Count the number of times elem appears in the product."""
        total_count = 1
        for e, it in _coconut.zip_longest(elem, self.all_iters, fillvalue=_coconut_sentinel):
            if e is _coconut_sentinel or it is _coconut_sentinel:
                return 0
            total_count *= it.count(e)
            if not total_count:
                return total_count
        return total_count
    def __fmap__(self, func):
        return _coconut_map(func, self)
class map(_coconut_baseclass, _coconut.map):
    __slots__ = ("func", "iters")
    __doc__ = getattr(_coconut.map, "__doc__", "<see help(py_map)>")
    def __new__(cls, function, *iterables, **kwargs):
        strict = kwargs.pop("strict", False)
        if kwargs:
            raise _coconut.TypeError(cls.__name__ + "() got unexpected keyword arguments " + _coconut.repr(kwargs))
        if strict and _coconut.len(iterables) > 1:
            return _coconut_starmap(function, _coconut_zip(*iterables, strict=True))
        self = _coconut.map.__new__(cls, function, *iterables)
        self.func = function
        self.iters = iterables
        return self
    def __getitem__(self, index):
        if _coconut.isinstance(index, _coconut.slice):
            return self.__class__(self.func, *(_coconut_iter_getitem(it, index) for it in self.iters))
        return self.func(*(_coconut_iter_getitem(it, index) for it in self.iters))
    def __reversed__(self):
        return self.__class__(self.func, *(_coconut_reversed(it) for it in self.iters))
    def __len__(self):
        if not _coconut.all(_coconut.isinstance(it, _coconut.abc.Sized) for it in self.iters):
            return _coconut.NotImplemented
        return _coconut.min(_coconut.len(it) for it in self.iters)
    def __repr__(self):
        return "%s(%r, %s)" % (self.__class__.__name__, self.func, ", ".join((_coconut.repr(it) for it in self.iters)))
    def __reduce__(self):
        return (self.__class__, (self.func,) + self.iters)
    def __copy__(self):
        self.iters = _coconut.tuple(_coconut_reiterable(it) for it in self.iters)
        return self.__class__(self.func, *self.iters)
    def __iter__(self):
        return _coconut.iter(_coconut.map(self.func, *self.iters))
    def __fmap__(self, func):
        return self.__class__(_coconut_forward_compose(self.func, func), *self.iters)
class _coconut_parallel_concurrent_map_func_wrapper(_coconut_baseclass):
    __slots__ = ("map_cls", "func", "star")
    def __init__(self, map_cls, func, star):
        self.map_cls = map_cls
        self.func = func
        self.star = star
    def __reduce__(self):
        return (self.__class__, (self.map_cls, self.func, self.star))
    def __call__(self, *args, **kwargs):
        self.map_cls.get_pool_stack().append(None)
        try:
            if self.star:
                assert _coconut.len(args) == 1, "internal parallel/concurrent map error (you should report this at https://github.com/evhub/coconut/issues/new)"
                return self.func(*args[0], **kwargs)
            else:
                return self.func(*args, **kwargs)
        except:
            _coconut.print(self.map_cls.__name__ + " error:")
            _coconut.traceback.print_exc()
            raise
        finally:
            assert self.map_cls.get_pool_stack().pop() is None, "internal parallel/concurrent map error (you should report this at https://github.com/evhub/coconut/issues/new)"
class _coconut_base_parallel_concurrent_map(map):
    __slots__ = ("result", "chunksize", "strict")
    @classmethod
    def get_pool_stack(cls):
        return cls.threadlocal_ns.__dict__.setdefault("pool_stack", [None])
    def __new__(cls, function, *iterables, **kwargs):
        self = _coconut_map.__new__(cls, function, *iterables)
        self.result = None
        self.chunksize = kwargs.pop("chunksize", 1)
        self.strict = kwargs.pop("strict", False)
        if kwargs:
            raise _coconut.TypeError(cls.__name__ + "() got unexpected keyword arguments " + _coconut.repr(kwargs))
        if cls.get_pool_stack()[-1] is not None:
            return self.get_list()
        return self
    @classmethod
    @_coconut.contextlib.contextmanager
    def multiple_sequential_calls(cls, max_workers=None):
        """Context manager that causes nested calls to use the same pool."""
        if cls.get_pool_stack()[-1] is None:
            cls.get_pool_stack()[-1] = cls.make_pool(max_workers)
            try:
                yield
            finally:
                cls.get_pool_stack()[-1].terminate()
                cls.get_pool_stack()[-1] = None
        else:
            yield
    def get_list(self):
        if self.result is None:
            with self.multiple_sequential_calls():
                if _coconut.len(self.iters) == 1:
                    self.result = _coconut.list(self.get_pool_stack()[-1].imap(_coconut_parallel_concurrent_map_func_wrapper(self.__class__, self.func, False), self.iters[0], self.chunksize))
                elif self.strict:
                    self.result = _coconut.list(self.get_pool_stack()[-1].imap(_coconut_parallel_concurrent_map_func_wrapper(self.__class__, self.func, True), _coconut_zip(*self.iters, strict=True), self.chunksize))
                else:
                    self.result = _coconut.list(self.get_pool_stack()[-1].imap(_coconut_parallel_concurrent_map_func_wrapper(self.__class__, self.func, True), _coconut.zip(*self.iters), self.chunksize))
            self.func = _coconut_ident
            self.iters = (self.result,)
        return self.result
    def __iter__(self):
        return _coconut.iter(self.get_list())
class parallel_map(_coconut_base_parallel_concurrent_map):
    """Multi-process implementation of map. Requires arguments to be pickleable.

    For multiple sequential calls, use:
        with parallel_map.multiple_sequential_calls():
            ...
    """
    __slots__ = ()
    threadlocal_ns = _coconut.threading.local()
    @staticmethod
    def make_pool(max_workers=None):
        return _coconut.multiprocessing.Pool(max_workers)
class concurrent_map(_coconut_base_parallel_concurrent_map):
    """Multi-thread implementation of map.

    For multiple sequential calls, use:
        with concurrent_map.multiple_sequential_calls():
            ...
    """
    __slots__ = ()
    threadlocal_ns = _coconut.threading.local()
    @staticmethod
    def make_pool(max_workers=None):
        return _coconut.multiprocessing_dummy.Pool(_coconut.multiprocessing.cpu_count() * 5 if max_workers is None else max_workers)
class zip(_coconut_baseclass, _coconut.zip):
    __slots__ = ("iters", "strict")
    __doc__ = getattr(_coconut.zip, "__doc__", "<see help(py_zip)>")
    def __new__(cls, *iterables, **kwargs):
        self = _coconut.zip.__new__(cls, *iterables)
        self.iters = iterables
        self.strict = kwargs.pop("strict", False)
        if kwargs:
            raise _coconut.TypeError(cls.__name__ + "() got unexpected keyword arguments " + _coconut.repr(kwargs))
        return self
    def __getitem__(self, index):
        if _coconut.isinstance(index, _coconut.slice):
            return self.__class__(*(_coconut_iter_getitem(it, index) for it in self.iters), strict=self.strict)
        return _coconut.tuple(_coconut_iter_getitem(it, index) for it in self.iters)
    def __reversed__(self):
        return self.__class__(*(_coconut_reversed(it) for it in self.iters), strict=self.strict)
    def __len__(self):
        if not _coconut.all(_coconut.isinstance(it, _coconut.abc.Sized) for it in self.iters):
            return _coconut.NotImplemented
        return _coconut.min(_coconut.len(it) for it in self.iters)
    def __repr__(self):
        return "zip(%s%s)" % (", ".join((_coconut.repr(it) for it in self.iters)), ", strict=True" if self.strict else "")
    def __reduce__(self):
        return (self.__class__, self.iters, {"strict": self.strict})
    def __copy__(self):
        self.iters = _coconut.tuple(_coconut_reiterable(it) for it in self.iters)
        return self.__class__(*self.iters, strict=self.strict)
    def __iter__(self):
        for items in _coconut.iter(_coconut.zip(*self.iters, strict=self.strict) if _coconut_sys.version_info >= (3, 10) else _coconut.zip_longest(*self.iters, fillvalue=_coconut_sentinel) if self.strict else _coconut.zip(*self.iters)):
            if self.strict and _coconut_sys.version_info < (3, 10) and _coconut.any(x is _coconut_sentinel for x in items):
                raise _coconut.ValueError("zip(..., strict=True) arguments have mismatched lengths")
            yield items
    def __fmap__(self, func):
        return _coconut_map(func, self)
class zip_longest(zip):
    __slots__ = ("fillvalue",)
    __doc__ = getattr(_coconut.zip_longest, "__doc__", "Version of zip that fills in missing values with fillvalue.")
    def __new__(cls, *iterables, **kwargs):
        self = _coconut_zip.__new__(cls, *iterables, strict=False)
        self.fillvalue = kwargs.pop("fillvalue", None)
        if kwargs:
            raise _coconut.TypeError(cls.__name__ + "() got unexpected keyword arguments " + _coconut.repr(kwargs))
        return self
    def __getitem__(self, index):
        self_len = None
        if _coconut.isinstance(index, _coconut.slice):
            if self_len is None:
                self_len = self.__len__()
                if self_len is _coconut.NotImplemented:
                    return self_len
            new_ind = _coconut.slice(index.start + self_len if index.start is not None and index.start < 0 else index.start, index.stop + self_len if index.stop is not None and index.stop < 0 else index.stop, index.step)
            return self.__class__(*(_coconut_iter_getitem(it, new_ind) for it in self.iters))
        if index < 0:
            if self_len is None:
                self_len = self.__len__()
                if self_len is _coconut.NotImplemented:
                    return self_len
            index += self_len
        result = []
        got_non_default = False
        for it in self.iters:
            try:
                result.append(_coconut_iter_getitem(it, index))
            except _coconut.IndexError:
                result.append(self.fillvalue)
            else:
                got_non_default = True
        if not got_non_default:
            raise _coconut.IndexError("zip_longest index out of range")
        return _coconut.tuple(result)
    def __len__(self):
        if not _coconut.all(_coconut.isinstance(it, _coconut.abc.Sized) for it in self.iters):
            return _coconut.NotImplemented
        return _coconut.max(_coconut.len(it) for it in self.iters)
    def __repr__(self):
        return "zip_longest(%s, fillvalue=%s)" % (", ".join((_coconut.repr(it) for it in self.iters)), _coconut.repr(self.fillvalue))
    def __reduce__(self):
        return (self.__class__, self.iters, {"fillvalue": self.fillvalue})
    def __copy__(self):
        self.iters = _coconut.tuple(_coconut_reiterable(it) for it in self.iters)
        return self.__class__(*self.iters, fillvalue=self.fillvalue)
    def __iter__(self):
        return _coconut.iter(_coconut.zip_longest(*self.iters, fillvalue=self.fillvalue))
class filter(_coconut_baseclass, _coconut.filter):
    __slots__ = ("func", "iter")
    __doc__ = getattr(_coconut.filter, "__doc__", "<see help(py_filter)>")
    def __new__(cls, function, iterable):
        self = _coconut.filter.__new__(cls, function, iterable)
        self.func = function
        self.iter = iterable
        return self
    def __reversed__(self):
        return self.__class__(self.func, _coconut_reversed(self.iter))
    def __repr__(self):
        return "filter(%r, %s)" % (self.func, _coconut.repr(self.iter))
    def __reduce__(self):
        return (self.__class__, (self.func, self.iter))
    def __copy__(self):
        self.iter = _coconut_reiterable(self.iter)
        return self.__class__(self.func, self.iter)
    def __iter__(self):
        return _coconut.iter(_coconut.filter(self.func, self.iter))
    def __fmap__(self, func):
        return _coconut_map(func, self)
class enumerate(_coconut_baseclass, _coconut.enumerate):
    __slots__ = ("iter", "start")
    __doc__ = getattr(_coconut.enumerate, "__doc__", "<see help(py_enumerate)>")
    def __new__(cls, iterable, start=0):
        start = _coconut.operator.index(start)
        self = _coconut.enumerate.__new__(cls, iterable, start)
        self.iter = iterable
        self.start = start
        return self
    def __repr__(self):
        return "enumerate(%s, %r)" % (_coconut.repr(self.iter), self.start)
    def __fmap__(self, func):
        return _coconut_map(func, self)
    def __reduce__(self):
        return (self.__class__, (self.iter, self.start))
    def __copy__(self):
        self.iter = _coconut_reiterable(self.iter)
        return self.__class__(self.iter, self.start)
    def __iter__(self):
        return _coconut.iter(_coconut.enumerate(self.iter, self.start))
    def __getitem__(self, index):
        if _coconut.isinstance(index, _coconut.slice):
            return self.__class__(_coconut_iter_getitem(self.iter, index), self.start + (0 if index.start is None else index.start if index.start >= 0 else _coconut.len(self.iter) + index.start))
        return (self.start + index, _coconut_iter_getitem(self.iter, index))
    def __len__(self):
        if not _coconut.isinstance(self.iter, _coconut.abc.Sized):
            return _coconut.NotImplemented
        return _coconut.len(self.iter)
class multi_enumerate(_coconut_has_iter):
    """Enumerate an iterable of iterables. Works like enumerate, but indexes
    through inner iterables and produces a tuple index representing the index
    in each inner iterable. Supports indexing.

    For numpy arrays, effectively equivalent to:
        it = np.nditer(iterable, flags=["multi_index", "refs_ok"])
        for x in it:
            yield it.multi_index, x

    Also supports len for numpy arrays.
    """
    __slots__ = ()
    def __repr__(self):
        return "multi_enumerate(%s)" % (_coconut.repr(self.iter),)
    def __reduce__(self):
        return (self.__class__, (self.iter,))
    def __copy__(self):
        return self.__class__(self.get_new_iter())
    @property
    def is_numpy(self):
        return self.iter.__class__.__module__ in _coconut.numpy_modules
    def __iter__(self):
        if self.is_numpy:
            it = _coconut.numpy.nditer(self.iter, ["multi_index", "refs_ok"], [["readonly"]])
            for x in it:
                x, = x.flatten()
                yield it.multi_index, x
        else:
            ind = [-1]
            its = [_coconut.iter(self.iter)]
            while its:
                ind[-1] += 1
                try:
                    x = _coconut.next(its[-1])
                except _coconut.StopIteration:
                    ind.pop()
                    its.pop()
                else:
                    if _coconut.isinstance(x, _coconut.abc.Iterable):
                        ind.append(-1)
                        its.append(_coconut.iter(x))
                    else:
                        yield _coconut.tuple(ind), x
    def __getitem__(self, index):
        if self.is_numpy and not _coconut.isinstance(index, _coconut.slice):
            multi_ind = []
            for i in _coconut.reversed(self.iter.shape):
                multi_ind.append(index % i)
                index //= i
            multi_ind = _coconut.tuple(_coconut.reversed(multi_ind))
            return multi_ind, self.iter[multi_ind]
        return _coconut_iter_getitem(_coconut.iter(self), index)
    def __len__(self):
        if self.is_numpy:
            return self.iter.size
        return _coconut.NotImplemented
class count(_coconut_baseclass):
    __slots__ = ("start", "step")
    __doc__ = getattr(_coconut.itertools.count, "__doc__", "count(start, step) returns an infinite iterator starting at start and increasing by step.")
    def __init__(self, start=0, step=1):
        self.start = start
        self.step = step
    def __reduce__(self):
        return (self.__class__, (self.start, self.step))
    def __repr__(self):
        return "count(%s, %s)" % (_coconut.repr(self.start), _coconut.repr(self.step))
    def __iter__(self):
        while True:
            yield self.start
            if self.step:
                self.start += self.step
    def __fmap__(self, func):
        return _coconut_map(func, self)
    def __contains__(self, elem):
        if not self.step:
            return elem == self.start
        if self.step > 0 and elem < self.start or self.step < 0 and elem > self.start:
            return False
        return (elem - self.start) % self.step == 0
    def __getitem__(self, index):
        if _coconut.isinstance(index, _coconut.slice):
            if (index.start is None or index.start >= 0) and (index.stop is None or index.stop >= 0):
                new_start, new_step = self.start, self.step
                if self.step and index.start is not None:
                    new_start += self.step * index.start
                if self.step and index.step is not None:
                    new_step *= index.step
                if index.stop is None:
                    return self.__class__(new_start, new_step)
                if self.step and _coconut.isinstance(self.start, _coconut.int) and _coconut.isinstance(self.step, _coconut.int):
                    return _coconut.range(new_start, self.start + self.step * index.stop, new_step)
                return _coconut_map(self.__getitem__, _coconut.range(index.start if index.start is not None else 0, index.stop, index.step if index.step is not None else 1))
            raise _coconut.IndexError("count() indices cannot be negative")
        if index < 0:
            raise _coconut.IndexError("count() indices cannot be negative")
        return self.start + self.step * index if self.step else self.start
    def count(self, elem):
        """Count the number of times elem appears in the count."""
        if not self.step:
            return _coconut.float("inf") if elem == self.start else 0
        return _coconut.int(elem in self)
    def index(self, elem):
        """Find the index of elem in the count."""
        if elem not in self:
            raise _coconut.ValueError(_coconut.repr(elem) + " not in " + _coconut.repr(self))
        return (elem - self.start) // self.step if self.step else 0
    def __reversed__(self):
        if not self.step:
            return self
        raise _coconut.TypeError(_coconut.repr(self) + " object is not reversible")
class cycle(_coconut_has_iter):
    """cycle is a modified version of itertools.cycle with a times parameter
    that controls the number of times to cycle through the given iterable
    before stopping."""
    __slots__ = ("times",)
    def __new__(cls, iterable, times=None):
        self = _coconut_has_iter.__new__(cls, iterable)
        if times is None:
            self.times = None
        else:
            self.times = _coconut.operator.index(times)
            if self.times < 0:
                raise _coconut.ValueError("cycle: times cannot be negative")
        return self
    def __reduce__(self):
        return (self.__class__, (self.iter, self.times))
    def __copy__(self):
        return self.__class__(self.get_new_iter(), self.times)
    def __repr__(self):
        return "cycle(%s, %r)" % (_coconut.repr(self.iter), self.times)
    def __iter__(self):
        i = 0
        while self.times is None or i < self.times:
            for x in self.get_new_iter():
                yield x
            i += 1
    def __contains__(self, elem):
        return elem in self.iter
    def __getitem__(self, index):
        if not _coconut.isinstance(index, _coconut.slice):
            if self.times is not None and index // _coconut.len(self.iter) >= self.times:
                raise _coconut.IndexError("cycle index out of range")
            return self.iter[index % _coconut.len(self.iter)]
        if self.times is None:
            return _coconut_map(self.__getitem__, _coconut_count()[index])
        else:
            return _coconut_map(self.__getitem__, _coconut_range(0, _coconut.len(self))[index])
    def __len__(self):
        if self.times is None or not _coconut.isinstance(self.iter, _coconut.abc.Sized):
            return _coconut.NotImplemented
        return _coconut.len(self.iter) * self.times
    def __reversed__(self):
        if self.times is None:
            raise _coconut.TypeError(_coconut.repr(self) + " object is not reversible")
        return self.__class__(_coconut_reversed(self.get_new_iter()), self.times)
    def count(self, elem):
        """Count the number of times elem appears in the cycle."""
        return self.iter.count(elem) * (float("inf") if self.times is None else self.times)
    def index(self, elem):
        """Find the index of elem in the cycle."""
        if elem not in self.iter:
            raise _coconut.ValueError(_coconut.repr(elem) + " not in " + _coconut.repr(self))
        return self.iter.index(elem)
class windowsof(_coconut_has_iter):
    """Produces an iterable that effectively mimics a sliding window over iterable of the given size.
    The step determines the spacing between windowsof.

    If the size is larger than the iterable, windowsof will produce an empty iterable.
    If that is not the desired behavior, fillvalue can be passed and will be used in place of missing values."""
    __slots__ = ("size", "fillvalue", "step")
    def __new__(cls, size, iterable, fillvalue=_coconut_sentinel, step=1):
        self = _coconut_has_iter.__new__(cls, iterable)
        self.size = _coconut.operator.index(size)
        if self.size < 1:
            raise _coconut.ValueError("windowsof: size must be >= 1; not %r" % (self.size,))
        self.fillvalue = fillvalue
        self.step = _coconut.operator.index(step)
        if self.step < 1:
            raise _coconut.ValueError("windowsof: step must be >= 1; not %r" % (self.step,))
        return self
    def __reduce__(self):
        return (self.__class__, (self.size, self.iter, self.fillvalue, self.step))
    def __copy__(self):
        return self.__class__(self.size, self.get_new_iter(), self.fillvalue, self.step)
    def __repr__(self):
        return "windowsof(" + _coconut.repr(self.size) + ", " + _coconut.repr(self.iter) + (", fillvalue=" + _coconut.repr(self.fillvalue) if self.fillvalue is not _coconut_sentinel else "") + (", step=" + _coconut.repr(self.step) if self.step != 1 else "") + ")"
    def __iter__(self):
        cache = _coconut.collections.deque()
        i = 0
        for x in self.iter:
            i += 1
            cache.append(x)
            if _coconut.len(cache) == self.size:
                yield _coconut.tuple(cache)
                for _ in _coconut.range(self.step):
                    cache.popleft()
        if self.fillvalue is not _coconut_sentinel and (i < self.size or i % self.step != 0):
            while _coconut.len(cache) < self.size:
                cache.append(self.fillvalue)
            yield _coconut.tuple(cache)
    def __len__(self):
        if not _coconut.isinstance(self.iter, _coconut.abc.Sized):
            return _coconut.NotImplemented
        if _coconut.len(self.iter) < self.size:
            return 0 if self.fillvalue is _coconut_sentinel else 1
        return (_coconut.len(self.iter) - self.size + self.step) // self.step + _coconut.int(_coconut.len(self.iter) % self.step != 0 if self.fillvalue is not _coconut_sentinel else 0)
class groupsof(_coconut_has_iter):
    """groupsof(n, iterable) splits iterable into groups of size n.

    If the length of the iterable is not divisible by n, the last group will be of size < n.
    """
    __slots__ = ("group_size", "fillvalue")
    def __new__(cls, n, iterable, fillvalue=_coconut_sentinel):
        self = _coconut_has_iter.__new__(cls, iterable)
        self.group_size = _coconut.operator.index(n)
        if self.group_size < 1:
            raise _coconut.ValueError("group size must be >= 1; not %r" % (self.group_size,))
        self.fillvalue = fillvalue
        return self
    def __iter__(self):
        iterator = _coconut.iter(self.iter)
        loop = True
        while loop:
            group = []
            for _ in _coconut.range(self.group_size):
                try:
                    group.append(_coconut.next(iterator))
                except _coconut.StopIteration:
                    loop = False
                    break
            if group:
                if not loop and self.fillvalue is not _coconut_sentinel:
                    while _coconut.len(group) < self.group_size:
                        group.append(self.fillvalue)
                yield _coconut.tuple(group)
    def __len__(self):
        if not _coconut.isinstance(self.iter, _coconut.abc.Sized):
            return _coconut.NotImplemented
        return (_coconut.len(self.iter) + self.group_size - 1) // self.group_size
    def __repr__(self):
        return "groupsof(" + _coconut.repr(self.group_size) + ", " + _coconut.repr(self.iter) + (", fillvalue=" + _coconut.repr(self.fillvalue) if self.fillvalue is not _coconut_sentinel else "") + ")"
    def __reduce__(self):
        return (self.__class__, (self.group_size, self.iter))
    def __copy__(self):
        return self.__class__(self.group_size, self.get_new_iter())
class recursive_iterator(_coconut_baseclass):
    """Decorator that optimizes a recursive function that returns an iterator (e.g. a recursive generator)."""
    __slots__ = ("func", "reit_store", "backup_reit_store")
    def __init__(self, func):
        self.func = func
        self.reit_store = _coconut.dict()
        self.backup_reit_store = []
    def __call__(self, *args, **kwargs):
        key = (args, _coconut.frozenset(kwargs.items()))
        use_backup = False
        try:
            _coconut.hash(key)
        except _coconut.Exception:
            try:
                key = _coconut.pickle.dumps(key, -1)
            except _coconut.Exception:
                use_backup = True
        if use_backup:
            for k, v in self.backup_reit_store:
                if k == key:
                    return reit
            reit = _coconut_reiterable(self.func(*args, **kwargs))
            self.backup_reit_store.append([key, reit])
            return reit
        else:
            reit = self.reit_store.get(key)
            if reit is None:
                reit = _coconut_reiterable(self.func(*args, **kwargs))
                self.reit_store[key] = reit
            return reit
    def __repr__(self):
        return "recursive_iterator(%r)" % (self.func,)
    def __reduce__(self):
        return (self.__class__, (self.func,))
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        if _coconut_sys.version_info < (3,):
            return _coconut.types.MethodType(self, obj, objtype)
        else:
            return _coconut.types.MethodType(self, obj)
class _coconut_FunctionMatchErrorContext(_coconut_baseclass):
    __slots__ = ("exc_class", "taken")
    threadlocal_ns = _coconut.threading.local()
    def __init__(self, exc_class):
        self.exc_class = exc_class
        self.taken = False
    @classmethod
    def get_contexts(cls):
        return cls.threadlocal_ns.__dict__.setdefault("contexts", [])
    def __enter__(self):
        self.get_contexts().append(self)
    def __exit__(self, type, value, traceback):
        self.get_contexts().pop()
    def __reduce__(self):
        return (self.__class__, (self.exc_class,))
def _coconut_get_function_match_error():
    contexts = _coconut_FunctionMatchErrorContext.get_contexts()
    if not contexts:
        return _coconut_MatchError
    ctx = contexts[-1]
    if ctx.taken:
        return _coconut_MatchError
    ctx.taken = True
    return ctx.exc_class
class _coconut_base_pattern_func(_coconut_baseclass):
    _coconut_is_match = True
    def __init__(self, *funcs):
        self.FunctionMatchError = _coconut.type(_coconut_py_str("MatchError"), (_coconut_MatchError,), _coconut_py_dict())
        self.patterns = []
        self.__doc__ = None
        self.__name__ = None
        if _coconut_sys.version_info >= (3, 7):
            self.__qualname__ = None
        for func in funcs:
            self.add_pattern(func)
    def add_pattern(self, func):
        if _coconut.isinstance(func, _coconut_base_pattern_func):
            self.patterns += func.patterns
        else:
            self.patterns.append(func)
        self.__doc__ = _coconut.getattr(func, "__doc__", self.__doc__)
        self.__name__ = _coconut.getattr(func, "__name__", self.__name__)
        if _coconut_sys.version_info >= (3, 7):
            self.__qualname__ = _coconut.getattr(func, "__qualname__", self.__qualname__)
    def __call__(self, *args, **kwargs):
        for func in self.patterns[:-1]:
            try:
                with _coconut_FunctionMatchErrorContext(self.FunctionMatchError):
                    return func(*args, **kwargs)
            except self.FunctionMatchError:
                pass
        return self.patterns[-1](*args, **kwargs)
    def _coconut_tco_func(self, *args, **kwargs):
        for func in self.patterns[:-1]:
            try:
                with _coconut_FunctionMatchErrorContext(self.FunctionMatchError):
                    return func(*args, **kwargs)
            except self.FunctionMatchError:
                pass
        return _coconut_tail_call(self.patterns[-1], *args, **kwargs)
    def __repr__(self):
        return "addpattern(%r)(*%r)" % (self.patterns[0], self.patterns[1:])
    def __reduce__(self):
        return (self.__class__, _coconut.tuple(self.patterns))
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        if _coconut_sys.version_info < (3,):
            return _coconut.types.MethodType(self, obj, objtype)
        else:
            return _coconut.types.MethodType(self, obj)
def _coconut_mark_as_match(base_func):
    base_func._coconut_is_match = True
    return base_func
def addpattern(base_func, *add_funcs, **kwargs):
    """Decorator to add a new case to a pattern-matching function (where the new case is checked last).

    Pass allow_any_func=True to allow any object as the base_func rather than just pattern-matching functions.
    If add_funcs are passed, addpattern(base_func, add_func) is equivalent to addpattern(base_func)(add_func).
    """
    allow_any_func = kwargs.pop("allow_any_func", False)
    if not allow_any_func and not _coconut.getattr(base_func, "_coconut_is_match", False):
        _coconut.warnings.warn("Possible misuse of addpattern with non-pattern-matching function " + _coconut.repr(base_func) + " (pass allow_any_func=True to dismiss)", stacklevel=2)
    if kwargs:
        raise _coconut.TypeError("addpattern() got unexpected keyword arguments " + _coconut.repr(kwargs))
    if add_funcs:
        return _coconut_base_pattern_func(base_func, *add_funcs)
    return _coconut.functools.partial(_coconut_base_pattern_func, base_func)
_coconut_addpattern = addpattern
def prepattern(*args, **kwargs):
    """Deprecated built-in 'prepattern' disabled by --strict compilation; use 'addpattern' instead."""
    raise _coconut.NameError("deprecated built-in 'prepattern' disabled by --strict compilation; use 'addpattern' instead")
class _coconut_partial(_coconut_baseclass):
    __slots__ = ("func", "_argdict", "_arglen", "_pos_kwargs", "_stargs", "keywords")
    def __init__(self, _coconut_func, _coconut_argdict, _coconut_arglen, _coconut_pos_kwargs, *args, **kwargs):
        self.func = _coconut_func
        self._argdict = _coconut_argdict
        self._arglen = _coconut_arglen
        self._pos_kwargs = _coconut_pos_kwargs
        self._stargs = args
        self.keywords = kwargs
    def __reduce__(self):
        return (self.__class__, (self.func, self._argdict, self._arglen, self._pos_kwargs) + self._stargs, {"keywords": self.keywords})
    @property
    def args(self):
        return _coconut.tuple(self._argdict.get(i) for i in _coconut.range(self._arglen)) + self._stargs
    @property
    def required_nargs(self):
        return self._arglen - _coconut.len(self._argdict) + len(self._pos_kwargs)
    def __call__(self, *args, **kwargs):
        callargs = []
        argind = 0
        for i in _coconut.range(self._arglen):
            if i in self._argdict:
                callargs.append(self._argdict[i])
            elif argind >= _coconut.len(args):
                raise _coconut.TypeError("expected at least " + _coconut.str(self.required_nargs) + " argument(s) to " + _coconut.repr(self))
            else:
                callargs.append(args[argind])
                argind += 1
        for k in self._pos_kwargs:
            if k in kwargs:
                raise _coconut.TypeError(_coconut.repr(k) + " is an invalid keyword argument for " + _coconut.repr(self))
            elif argind >= _coconut.len(args):
                raise _coconut.TypeError("expected at least " + _coconut.str(self.required_nargs) + " argument(s) to " + _coconut.repr(self))
            else:
                kwargs[k] = args[argind]
                argind += 1
        callargs += self._stargs
        callargs += args[argind:]
        callkwargs = self.keywords.copy()
        callkwargs.update(kwargs)
        return self.func(*callargs, **callkwargs)
    def __repr__(self):
        args = []
        for i in _coconut.range(self._arglen):
            if i in self._argdict:
                args.append(_coconut.repr(self._argdict[i]))
            else:
                args.append("?")
        for arg in self._stargs:
            args.append(_coconut.repr(arg))
        for k in self._pos_kwargs:
            args.append(k + "=?")
        for k, v in self.keywords.items():
            args.append(k + "=" + _coconut.repr(v))
        return "%r$(%s)" % (self.func, ", ".join(args))
def consume(iterable, keep_last=0):
    """consume(iterable, keep_last) fully exhausts iterable and returns the last keep_last elements."""
    return _coconut.collections.deque(iterable, maxlen=keep_last)
class starmap(_coconut_baseclass, _coconut.itertools.starmap):
    __slots__ = ("func", "iter")
    __doc__ = getattr(_coconut.itertools.starmap, "__doc__", "starmap(func, iterable) = (func(*args) for args in iterable)")
    def __new__(cls, function, iterable):
        self = _coconut.itertools.starmap.__new__(cls, function, iterable)
        self.func = function
        self.iter = iterable
        return self
    def __getitem__(self, index):
        if _coconut.isinstance(index, _coconut.slice):
            return self.__class__(self.func, _coconut_iter_getitem(self.iter, index))
        return self.func(*_coconut_iter_getitem(self.iter, index))
    def __reversed__(self):
        return self.__class__(self.func, *_coconut_reversed(self.iter))
    def __len__(self):
        if not _coconut.isinstance(self.iter, _coconut.abc.Sized):
            return _coconut.NotImplemented
        return _coconut.len(self.iter)
    def __repr__(self):
        return "starmap(%r, %s)" % (self.func, _coconut.repr(self.iter))
    def __reduce__(self):
        return (self.__class__, (self.func, self.iter))
    def __copy__(self):
        self.iter = _coconut_reiterable(self.iter)
        return self.__class__(self.func, self.iter)
    def __iter__(self):
        return _coconut.iter(_coconut.itertools.starmap(self.func, self.iter))
    def __fmap__(self, func):
        return self.__class__(_coconut_forward_compose(self.func, func), self.iter)
class multiset(_coconut.collections.Counter, object):
    __slots__ = ()
    __doc__ = getattr(_coconut.collections.Counter, "__doc__", "multiset is a version of set that counts the number of times each element is added.")
    def add(self, item):
        """Add an element to a multiset."""
        self[item] += 1
    def discard(self, item):
        """Remove an element from a multiset if it is a member."""
        item_count = self[item]
        if item_count > 0:
            self[item] = item_count - 1
            if item_count - 1 <= 0:
                del self[item]
    def remove(self, item):
        """Remove an element from a multiset; it must be a member."""
        item_count = self[item]
        if item_count > 0:
            self[item] = item_count - 1
            if item_count - 1 <= 0:
                del self[item]
        else:
            raise _coconut.KeyError(item)
    def isdisjoint(self, other):
        """Return True if two multisets have a null intersection."""
        return not self & other
    def __xor__(self, other):
        return self - other | other - self
    def count(self, item):
        """Return the number of times an element occurs in a multiset.
        Equivalent to multiset[item], but additionally verifies the count is non-negative."""
        result = self[item]
        if result < 0:
            raise _coconut.ValueError("multiset has negative count for " + _coconut.repr(item))
        return result
    if _coconut_sys.version_info < (3, 10):
        def total(self):
            """Compute the sum of the counts in a multiset.
            Note that total_size is different from len(multiset), which only counts the unique elements."""
            return _coconut.sum(self.values())
        def __eq__(self, other):
            if not _coconut.isinstance(other, _coconut.dict):
                return False
            if not _coconut.isinstance(other, _coconut.collections.Counter):
                return _coconut.NotImplemented
            for k, v in self.items():
                if other[k] != v:
                    return False
            for k, v in other.items():
                if self[k] != v:
                    return False
            return True
        __ne__ = _coconut.object.__ne__
        def __le__(self, other):
            if not _coconut.isinstance(other, _coconut.collections.Counter):
                return _coconut.NotImplemented
            for k, v in self.items():
                if not (v <= other[k]):
                    return False
            for k, v in other.items():
                if not (self[k] <= v):
                    return False
            return True
        def __lt__(self, other):
            if not _coconut.isinstance(other, _coconut.collections.Counter):
                return _coconut.NotImplemented
            found_diff = False
            for k, v in self.items():
                if not (v <= other[k]):
                    return False
                found_diff = found_diff or v != other[k]
            for k, v in other.items():
                if not (self[k] <= v):
                    return False
                found_diff = found_diff or self[k] != v
            return found_diff
    if _coconut_sys.version_info < (3,):
        keys = _coconut.collections.Counter.viewkeys
        values = _coconut.collections.Counter.viewvalues
        items = _coconut.collections.Counter.viewitems
_coconut.abc.MutableSet.register(multiset)
def _coconut_base_makedata(data_type, args):
    if _coconut.hasattr(data_type, "_make") and _coconut.issubclass(data_type, _coconut.tuple):
        return data_type._make(args)
    if _coconut.issubclass(data_type, (_coconut.range, _coconut.abc.Iterator)):
        return args
    if _coconut.issubclass(data_type, _coconut.str):
        return "".join(args)
    return data_type(args)
def makedata(data_type, *args):
    """Construct an object of the given data_type containing the given arguments."""
    return _coconut_base_makedata(data_type, args)
def datamaker(*args, **kwargs):
    """Deprecated built-in 'datamaker' disabled by --strict compilation; use 'makedata' instead."""
    raise _coconut.NameError("deprecated built-in 'datamaker' disabled by --strict compilation; use 'makedata' instead")
if _coconut_sys.version_info < (3, 3):
    _coconut_amap = None
else:
    class _coconut_amap(_coconut_baseclass):
        __slots__ = ("func", "aiter")
        def __init__(self, func, aiter):
            self.func = func
            self.aiter = aiter
        def __reduce__(self):
            return (self.__class__, (self.func, self.aiter))
        def __repr__(self):
            return "fmap(" + _coconut.repr(self.func) + ", " + _coconut.repr(self.aiter) + ")"
        def __aiter__(self):
            return self
        if _coconut_sys.version_info < (3, 5):
            _coconut_anext_ns = {}
            _coconut_exec("""def __anext__(self):
                result = yield from self.aiter.__anext__()
                return self.func(result)""", _coconut_anext_ns)
            __anext__ = _coconut.asyncio.coroutine(_coconut_anext_ns["__anext__"])
        else:
            _coconut_anext_ns = {}
            _coconut_exec("""async def __anext__(self):
                return self.func(await self.aiter.__anext__())""", _coconut_anext_ns)
            __anext__ = _coconut_anext_ns["__anext__"]
def fmap(func, obj, **kwargs):
    """fmap(func, obj) creates a copy of obj with func applied to its contents.
    Supports asynchronous iterables, mappings (maps over .items()), and numpy arrays (uses np.vectorize).

    Override by defining obj.__fmap__(func).
    """
    starmap_over_mappings = kwargs.pop("starmap_over_mappings", False)
    if kwargs:
        raise _coconut.TypeError("fmap() got unexpected keyword arguments " + _coconut.repr(kwargs))
    obj_fmap = _coconut.getattr(obj, "__fmap__", None)
    if obj_fmap is not None:
        try:
            result = obj_fmap(func)
        except _coconut.NotImplementedError:
            pass
        else:
            if result is not _coconut.NotImplemented:
                return result
    if obj.__class__.__module__ in _coconut.jax_numpy_modules:
        import jax.numpy as jnp
        return jnp.vectorize(func)(obj)
    if obj.__class__.__module__ in _coconut.numpy_modules:
        return _coconut.numpy.vectorize(func)(obj)
    obj_aiter = _coconut.getattr(obj, "__aiter__", None)
    if obj_aiter is not None and _coconut_amap is not None:
        try:
            aiter = obj_aiter()
        except _coconut.NotImplementedError:
            pass
        else:
            if aiter is not _coconut.NotImplemented:
                return _coconut_amap(func, aiter)
    if starmap_over_mappings:
        return _coconut_base_makedata(obj.__class__, _coconut_starmap(func, obj.items()) if _coconut.isinstance(obj, _coconut.abc.Mapping) else _coconut_map(func, obj))
    else:
        return _coconut_base_makedata(obj.__class__, _coconut_map(func, obj.items() if _coconut.isinstance(obj, _coconut.abc.Mapping) else obj))
def _coconut_memoize_helper(maxsize=None, typed=False):
    return maxsize, typed
def memoize(*args, **kwargs):
    """Decorator that memoizes a function, preventing it from being recomputed
    if it is called multiple times with the same arguments."""
    if not kwargs and _coconut.len(args) == 1 and _coconut.callable(args[0]):
        return _coconut.functools.lru_cache(maxsize=None)(args[0])
    if _coconut.len(kwargs) == 1 and "user_function" in kwargs and _coconut.callable(kwargs["user_function"]):
        return _coconut.functools.lru_cache(maxsize=None)(kwargs["user_function"])
    maxsize, typed = _coconut_memoize_helper(*args, **kwargs)
    return _coconut.functools.lru_cache(maxsize, typed)
def _coconut_call_set_names(cls):
    if _coconut_sys.version_info < (3, 6):
        for k, v in _coconut.vars(cls).items():
            set_name = _coconut.getattr(v, "__set_name__", None)
            if set_name is not None:
                set_name(cls, k)
class override(_coconut_baseclass):
    __slots__ = ("func",)
    def __init__(self, func):
        self.func = func
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self.func
        if _coconut_sys.version_info < (3,):
            return _coconut.types.MethodType(self.func, obj, objtype)
        else:
            return _coconut.types.MethodType(self.func, obj)
    def __set_name__(self, obj, name):
        if not _coconut.hasattr(_coconut.super(obj, obj), name):
            raise _coconut.RuntimeError(obj.__name__ + "." + name + " marked with @override but not overriding anything")
    def __reduce__(self):
        return (self.__class__, (self.func,))
def reveal_type(obj):
    """Special function to get MyPy to print the type of the given expression.
    At runtime, reveal_type is the identity function."""
    return obj
def reveal_locals():
    """Special function to get MyPy to print the type of the current locals.
    At runtime, reveal_locals always returns None."""
    pass
def _coconut_dict_merge(*dicts, **kwargs):
    for_func = kwargs.pop("for_func", False)
    assert not kwargs, "error with internal Coconut function _coconut_dict_merge (you should report this at https://github.com/evhub/coconut/issues/new)"
    newdict = _coconut.dict()
    prevlen = 0
    for d in dicts:
        newdict.update(d)
        if for_func:
            if _coconut.len(newdict) != prevlen + _coconut.len(d):
                raise _coconut.TypeError("multiple values for the same keyword argument")
            prevlen = _coconut.len(newdict)
    return newdict
def ident(x, **kwargs):
    """The identity function. Generally equivalent to x -> x. Useful in point-free programming.
    Accepts one keyword-only argument, side_effect, which specifies a function to call on the argument before it is returned."""
    side_effect = kwargs.pop("side_effect", None)
    if kwargs:
        raise _coconut.TypeError("ident() got unexpected keyword arguments " + _coconut.repr(kwargs))
    if side_effect is not None:
        side_effect(x)
    return x
def call(_coconut_f, *args, **kwargs):
    """Function application operator function.

    Equivalent to:
        def call(f, /, *args, **kwargs) = f(*args, **kwargs).
    """
    return _coconut_f(*args, **kwargs)
def of(*args, **kwargs):
    """Deprecated built-in 'of' disabled by --strict compilation; use 'call' instead."""
    raise _coconut.NameError("deprecated built-in 'of' disabled by --strict compilation; use 'call' instead")
def safe_call(_coconut_f, *args, **kwargs):
    """safe_call is a version of call that catches any Exceptions and
    returns an Expected containing either the result or the error.

    Equivalent to:
        def safe_call(f, /, *args, **kwargs):
            try:
                return Expected(f(*args, **kwargs))
            except Exception as err:
                return Expected(error=err)
    """
    try:
        return _coconut_Expected(_coconut_f(*args, **kwargs))
    except _coconut.Exception as err:
        return _coconut_Expected(error=err)
class Expected(_coconut.collections.namedtuple("Expected", ("result", "error")), object):
    '''Coconut's Expected built-in is a Coconut data that represents a value
    that may or may not be an error, similar to Haskell's Either.

    Effectively equivalent to:
        data Expected[T](result: T? = None, error: BaseException? = None):
            def __bool__(self) -> bool:
                return self.error is None
            def __fmap__[U](self, func: T -> U) -> Expected[U]:
                return self.__class__(func(self.result)) if self else self
            def and_then[U](self, func: T -> Expected[U]) -> Expected[U]:
                """Maps a T -> Expected[U] over an Expected[T] to produce an Expected[U].
                Implements a monadic bind. Equivalent to fmap ..> .join()."""
                return self |> fmap$(func) |> .join()
            def join(self: Expected[Expected[T]]) -> Expected[T]:
                """Monadic join. Converts Expected[Expected[T]] to Expected[T]."""
                if not self:
                    return self
                if not self.result `isinstance` Expected:
                    raise TypeError("Expected.join() requires an Expected[Expected[_]]")
                return self.result
            def map_error(self, func: BaseException -> BaseException) -> Expected[T]:
                """Maps func over the error if it exists."""
                return self if self else self.__class__(error=func(self.error))
            def or_else[U](self, func: BaseException -> Expected[U]) -> Expected[T | U]:
                """Return self if no error, otherwise return the result of evaluating func on the error."""
                return self if self else func(self.error)
            def result_or[U](self, default: U) -> T | U:
                """Return the result if it exists, otherwise return the default."""
                return self.result if self else default
            def result_or_else[U](self, func: BaseException -> U) -> T | U:
                """Return the result if it exists, otherwise return the result of evaluating func on the error."""
                return self.result if self else func(self.error)
            def unwrap(self) -> T:
                """Unwrap the result or raise the error."""
                if not self:
                    raise self.error
                return self.result
    '''
    __slots__ = ()
    _coconut_is_data = True
    __match_args__ = ("result", "error")
    _coconut_data_defaults = {0: None, 1: None}
    def __add__(self, other): return _coconut.NotImplemented
    def __mul__(self, other): return _coconut.NotImplemented
    def __rmul__(self, other): return _coconut.NotImplemented
    __ne__ = _coconut.object.__ne__
    def __eq__(self, other):
        return self.__class__ is other.__class__ and _coconut.tuple.__eq__(self, other)
    def __hash__(self):
        return _coconut.tuple.__hash__(self) ^ hash(self.__class__)
    def __new__(cls, result=_coconut_sentinel, error=None):
        if result is not _coconut_sentinel and error is not None:
            raise _coconut.TypeError("Expected cannot have both a result and an error")
        if result is _coconut_sentinel and error is None:
            raise _coconut.TypeError("Expected must have either a result or an error")
        if result is _coconut_sentinel:
            result = None
        return _coconut.tuple.__new__(cls, (result, error))
    def __bool__(self):
        return self.error is None
    def __fmap__(self, func):
        """Maps func over the result if it exists.

        __fmap__ should be used directly only when fmap is not available (e.g. when consuming an Expected in vanilla Python).
        """
        return self.__class__(func(self.result)) if self else self
    def and_then(self, func):
        """Maps a T -> Expected[U] over an Expected[T] to produce an Expected[U].
        Implements a monadic bind. Equivalent to fmap ..> .join()."""
        return self.__fmap__(func).join()
    def join(self):
        """Monadic join. Converts Expected[Expected[T]] to Expected[T]."""
        if not self:
            return self
        if not _coconut.isinstance(self.result, _coconut_Expected):
            raise _coconut.TypeError("Expected.join() requires an Expected[Expected[_]]")
        return self.result
    def map_error(self, func):
        """Maps func over the error if it exists."""
        return self if self else self.__class__(error=func(self.error))
    def or_else(self, func):
        """Return self if no error, otherwise return the result of evaluating func on the error."""
        if self:
            return self
        got = func(self.error)
        if not _coconut.isinstance(got, _coconut_Expected):
            raise _coconut.TypeError("Expected.or_else() requires a function that returns an Expected")
        return got
    def result_or(self, default):
        """Return the result if it exists, otherwise return the default."""
        return self.result if self else default
    def result_or_else(self, func):
        """Return the result if it exists, otherwise return the result of evaluating func on the error."""
        return self.result if self else func(self.error)
    def unwrap(self):
        """Unwrap the result or raise the error."""
        if not self:
            raise self.error
        return self.result
class flip(_coconut_baseclass):
    """Given a function, return a new function with inverse argument order.
    If nargs is passed, only the first nargs arguments are reversed."""
    __slots__ = ("func", "nargs")
    def __init__(self, func, nargs=None):
        self.func = func
        if nargs is None:
            self.nargs = None
        else:
            self.nargs = _coconut.operator.index(nargs)
            if self.nargs < 0:
                raise _coconut.ValueError("flip: nargs cannot be negative")
    def __reduce__(self):
        return (self.__class__, (self.func, self.nargs))
    def __call__(self, *args, **kwargs):
        if self.nargs is None:
            return self.func(*args[::-1], **kwargs)
        if self.nargs == 0:
            return self.func(*args, **kwargs)
        return self.func(*(args[self.nargs-1::-1] + args[self.nargs:]), **kwargs)
    def __repr__(self):
        return "flip(%r%s)" % (self.func, "" if self.nargs is None else ", " + _coconut.repr(self.nargs))
class const(_coconut_baseclass):
    """Create a function that, whatever its arguments, just returns the given value."""
    __slots__ = ("value",)
    def __init__(self, value):
        self.value = value
    def __reduce__(self):
        return (self.__class__, (self.value,))
    def __call__(self, *args, **kwargs):
        return self.value
    def __repr__(self):
        return "const(%s)" % (_coconut.repr(self.value),)
class _coconut_lifted(_coconut_baseclass):
    __slots__ = ("func", "func_args", "func_kwargs")
    def __init__(self, _coconut_func, *func_args, **func_kwargs):
        self.func = _coconut_func
        self.func_args = func_args
        self.func_kwargs = func_kwargs
    def __reduce__(self):
        return (self.__class__, (self.func,) + self.func_args, {"func_kwargs": self.func_kwargs})
    def __call__(self, *args, **kwargs):
        return self.func(*(g(*args, **kwargs) for g in self.func_args), **_coconut_py_dict((k, h(*args, **kwargs)) for k, h in self.func_kwargs.items()))
    def __repr__(self):
        return "lift(%r)(%s%s)" % (self.func, ", ".join(_coconut.repr(g) for g in self.func_args), ", ".join(k + "=" + _coconut.repr(h) for k, h in self.func_kwargs.items()))
class lift(_coconut_baseclass):
    """Lifts a function up so that all of its arguments are functions.

    For a binary function f(x, y) and two unary functions g(z) and h(z), lift works as the S' combinator:
        lift(f)(g, h)(z) == f(g(z), h(z))

    In general, lift is requivalent to:
        def lift(f) = ((*func_args, **func_kwargs) -> (*args, **kwargs) ->
            f(*(g(*args, **kwargs) for g in func_args), **{k: h(*args, **kwargs) for k, h in func_kwargs.items()}))

    lift also supports a shortcut form such that lift(f, *func_args, **func_kwargs) is equivalent to lift(f)(*func_args, **func_kwargs).
    """
    __slots__ = ("func",)
    def __new__(cls, func, *func_args, **func_kwargs):
        self = _coconut.object.__new__(cls)
        self.func = func
        if func_args or func_kwargs:
            self = self(*func_args, **func_kwargs)
        return self
    def __reduce__(self):
        return (self.__class__, (self.func,))
    def __call__(self, *func_args, **func_kwargs):
        return _coconut_lifted(self.func, *func_args, **func_kwargs)
    def __repr__(self):
        return "lift(%r)" % (self.func,)
def all_equal(iterable):
    """For a given iterable, check whether all elements in that iterable are equal to each other.

    Supports numpy arrays. Assumes transitivity and 'x != y' being equivalent to 'not (x == y)'.
    """
    if iterable.__class__.__module__ in _coconut.numpy_modules:
        return not _coconut.len(iterable) or (iterable == iterable[0]).all()
    first_item = _coconut_sentinel
    for item in iterable:
        if first_item is _coconut_sentinel:
            first_item = item
        elif first_item != item:
            return False
    return True
def collectby(key_func, iterable, value_func=None, reduce_func=None):
    """Collect the items in iterable into a dictionary of lists keyed by key_func(item).

    if value_func is passed, collect value_func(item) into each list instead of item.

    If reduce_func is passed, instead of collecting the items into lists, reduce over
    the items of each key with reduce_func, effectively implementing a MapReduce operation.
    """
    collection = _coconut.collections.defaultdict(_coconut.list) if reduce_func is None else _coconut.dict()
    for item in iterable:
        key = key_func(item)
        if value_func is not None:
            item = value_func(item)
        if reduce_func is None:
            collection[key].append(item)
        else:
            old_item = collection.get(key, _coconut_sentinel)
            if old_item is not _coconut_sentinel:
                item = reduce_func(old_item, item)
            collection[key] = item
    return collection
def _namedtuple_of(**kwargs):
    """Construct an anonymous namedtuple of the given keyword arguments."""
    if _coconut_sys.version_info < (3, 6):
        raise _coconut.RuntimeError("_namedtuple_of is not available on Python < 3.6 (use anonymous namedtuple literals instead)")
    else:
        return _coconut_mk_anon_namedtuple(kwargs.keys(), of_kwargs=kwargs)
def _coconut_mk_anon_namedtuple(fields, types=None, of_kwargs=None):
    if types is None:
        NT = _coconut.collections.namedtuple("_namedtuple_of", fields)
    else:
        NT = _coconut.typing.NamedTuple("_namedtuple_of", [(f, t) for f, t in _coconut.zip(fields, types)])
    _coconut.copyreg.pickle(NT, lambda nt: (_coconut_mk_anon_namedtuple, (nt._fields, types, nt._asdict())))
    if of_kwargs is None:
        return NT
    return NT(**of_kwargs)
def _coconut_ndim(arr):
    if (arr.__class__.__module__ in _coconut.numpy_modules or _coconut.hasattr(arr.__class__, "__matconcat__")) and _coconut.hasattr(arr, "ndim"):
        return arr.ndim
    if not _coconut.isinstance(arr, _coconut.abc.Sequence):
        return 0
    if _coconut.len(arr) == 0:
        return 1
    arr_dim = 1
    inner_arr = arr[0]
    while _coconut.isinstance(inner_arr, _coconut.abc.Sequence):
        arr_dim += 1
        if _coconut.len(inner_arr) < 1:
            break
        inner_arr = inner_arr[0]
    return arr_dim
def _coconut_expand_arr(arr, new_dims):
    if (arr.__class__.__module__ in _coconut.numpy_modules or _coconut.hasattr(arr.__class__, "__matconcat__")) and _coconut.hasattr(arr, "reshape"):
        return arr.reshape((1,) * new_dims + arr.shape)
    for _ in _coconut.range(new_dims):
        arr = [arr]
    return arr
def _coconut_concatenate(arrs, axis):
    matconcat = None
    for a in arrs:
        if a.__class__.__module__ in _coconut.jax_numpy_modules:
            from jax.numpy import concatenate as matconcat
            break
        if a.__class__.__module__ in _coconut.numpy_modules:
            matconcat = _coconut.numpy.concatenate
            break
        if _coconut.hasattr(a.__class__, "__matconcat__"):
            matconcat = a.__class__.__matconcat__
            break
    if matconcat is not None:
        return matconcat(arrs, axis)
    if not axis:
        return _coconut.list(_coconut.itertools.chain.from_iterable(arrs))
    return [_coconut_concatenate(rows, axis - 1) for rows in _coconut.zip(*arrs)]
def _coconut_multi_dim_arr(arrs, dim):
    arr_dims = [_coconut_ndim(a) for a in arrs]
    arrs = [_coconut_expand_arr(a, dim - d) if d < dim else a for a, d in _coconut.zip(arrs, arr_dims)]
    arr_dims.append(dim)
    max_arr_dim = _coconut.max(arr_dims)
    return _coconut_concatenate(arrs, max_arr_dim - dim)
def _coconut_call_or_coefficient(func, *args):
    if _coconut.callable(func):
        return func(*args)
    if not _coconut.isinstance(func, (_coconut.int, _coconut.float, _coconut.complex)) and func.__class__.__module__ not in _coconut.numpy_modules:
        raise _coconut.TypeError("implicit function application and coefficient syntax only supported for Callable, int, float, complex, and numpy objects")
    func = func
    for x in args:
        func = func * x
    return func
class _coconut_SupportsAdd(_coconut.typing.Protocol):
    def __add__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((+) in a typing context is a Protocol)")
class _coconut_SupportsMinus(_coconut.typing.Protocol):
    def __sub__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((-) in a typing context is a Protocol)")
    def __neg__(self):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((-) in a typing context is a Protocol)")
class _coconut_SupportsMul(_coconut.typing.Protocol):
    def __mul__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((*) in a typing context is a Protocol)")
class _coconut_SupportsPow(_coconut.typing.Protocol):
    def __pow__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((**) in a typing context is a Protocol)")
class _coconut_SupportsTruediv(_coconut.typing.Protocol):
    def __truediv__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((/) in a typing context is a Protocol)")
class _coconut_SupportsFloordiv(_coconut.typing.Protocol):
    def __floordiv__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((//) in a typing context is a Protocol)")
class _coconut_SupportsMod(_coconut.typing.Protocol):
    def __mod__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((%) in a typing context is a Protocol)")
class _coconut_SupportsAnd(_coconut.typing.Protocol):
    def __and__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((&) in a typing context is a Protocol)")
class _coconut_SupportsXor(_coconut.typing.Protocol):
    def __xor__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((^) in a typing context is a Protocol)")
class _coconut_SupportsOr(_coconut.typing.Protocol):
    def __or__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((|) in a typing context is a Protocol)")
class _coconut_SupportsLshift(_coconut.typing.Protocol):
    def __lshift__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((<<) in a typing context is a Protocol)")
class _coconut_SupportsRshift(_coconut.typing.Protocol):
    def __rshift__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((>>) in a typing context is a Protocol)")
class _coconut_SupportsMatmul(_coconut.typing.Protocol):
    def __matmul__(self, other):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((@) in a typing context is a Protocol)")
class _coconut_SupportsInv(_coconut.typing.Protocol):
    def __invert__(self):
        raise NotImplementedError("Protocol methods cannot be called at runtime ((~) in a typing context is a Protocol)")
_coconut_self_match_types = (bool, bytearray, bytes, dict, float, frozenset, int, py_int, list, set, str, py_str, tuple)
_coconut_Expected, _coconut_MatchError, _coconut_count, _coconut_enumerate, _coconut_flatten, _coconut_filter, _coconut_ident, _coconut_map, _coconut_multiset, _coconut_range, _coconut_reiterable, _coconut_reversed, _coconut_starmap, _coconut_tee, _coconut_zip, TYPE_CHECKING, reduce, takewhile, dropwhile = Expected, MatchError, count, enumerate, flatten, filter, ident, map, multiset, range, reiterable, reversed, starmap, tee, zip, False, _coconut.functools.reduce, _coconut.itertools.takewhile, _coconut.itertools.dropwhile

# Compiled Coconut: -----------------------------------------------------------

import setuptools  #1 (line in Coconut source)

sys = _coconut_sys  #3 (line in Coconut source)
import os.path  #4 (line in Coconut source)
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "bbopt"))  #5 (line in Coconut source)

import constants  #7 (line in Coconut source)


@_coconut_mark_as_match  #10 (line in Coconut source)
@_coconut_mark_as_match  #10 (line in Coconut source)
def _coconut_lambda_0(_coconut_match_first_arg=_coconut_sentinel, *_coconut_match_args, **_coconut_match_kwargs):  #10 (line in Coconut source)
    _coconut_match_check_0 = False  #10 (line in Coconut source)
    _coconut_match_set_name_k = _coconut_sentinel  #10 (line in Coconut source)
    _coconut_match_set_name_v = _coconut_sentinel  #10 (line in Coconut source)
    _coconut_FunctionMatchError = _coconut_get_function_match_error()  #10 (line in Coconut source)
    if _coconut_match_first_arg is not _coconut_sentinel:  #10 (line in Coconut source)
        _coconut_match_args = (_coconut_match_first_arg,) + _coconut_match_args  #10 (line in Coconut source)
    if _coconut.len(_coconut_match_args) == 1:  #10 (line in Coconut source)
        if (_coconut.isinstance(_coconut_match_args[0], _coconut.abc.Sequence)) and (_coconut.len(_coconut_match_args[0]) == 2):  #10 (line in Coconut source)
            _coconut_match_set_name_k = _coconut_match_args[0][0]  #10 (line in Coconut source)
            _coconut_match_set_name_v = _coconut_match_args[0][1]  #10 (line in Coconut source)
            if not _coconut_match_kwargs:  #10 (line in Coconut source)
                _coconut_match_check_0 = True  #10 (line in Coconut source)
    if _coconut_match_check_0:  #10 (line in Coconut source)
        if _coconut_match_set_name_k is not _coconut_sentinel:  #10 (line in Coconut source)
            k = _coconut_match_set_name_k  #10 (line in Coconut source)
        if _coconut_match_set_name_v is not _coconut_sentinel:  #10 (line in Coconut source)
            v = _coconut_match_set_name_v  #10 (line in Coconut source)
    if not _coconut_match_check_0:  #10 (line in Coconut source)
        raise _coconut_FunctionMatchError('extras_require=constants.extra_requirements |> fmap$(def ((k, v)) -> (k, list(v))),', _coconut_match_args)  #10 (line in Coconut source)
    return (k, list(v))  #10 (line in Coconut source)

setuptools.setup(name=constants.name, version=constants.version, description=constants.description, long_description=constants.long_description, url=constants.github_url, author=constants.author, author_email=constants.author_email, classifiers=(list)(constants.classifiers), packages=setuptools.find_packages(), install_requires=(list)(constants.requirements), extras_require=(fmap)(_coconut_lambda_0, constants.extra_requirements), entry_points=_coconut.dict((("console_scripts", ["bbopt = bbopt.cli:main",]),)))  #10 (line in Coconut source)