# Source code for sortedcontainers.sorteddict

    """Sorted Dict
    ==============

    :doc:`Sorted Containers<index>` is an Apache2 licensed Python sorted
    collections library, written in pure-Python, and fast as C-extensions. The
    :doc:`introduction<introduction>` is the best way to get started.

    Sorted dict implementations:

    .. currentmodule:: sortedcontainers

    * :class:`SortedDict`
    * :class:`SortedKeysView`
    * :class:`SortedItemsView`
    * :class:`SortedValuesView`

    """

    import sys
    import warnings

    from .sortedlist import SortedList, recursive_repr
    from .sortedset import SortedSet

    ###############################################################################
    # BEGIN Python 2/3 Shims
    ###############################################################################

    try:
        from collections.abc import ItemsView, KeysView, ValuesView, Sequence
    except ImportError:
        from collections import ItemsView, KeysView, ValuesView, Sequence

    ###############################################################################
    # END Python 2/3 Shims
    ###############################################################################

    class SortedDict(dict):
        """Sorted dict is a sorted mutable mapping.

        Sorted dict keys are maintained in sorted order. The design of sorted dict
        is simple: sorted dict inherits from dict to store items and maintains a
        sorted list of keys.

        Sorted dict keys must be hashable and comparable. The hash and total
        ordering of keys must not change while they are stored in the sorted dict.

        Mutable mapping methods:

        * :func:`SortedDict.__getitem__` (inherited from dict)
        * :func:`SortedDict.__setitem__`
        * :func:`SortedDict.__delitem__`
        * :func:`SortedDict.__iter__`
        * :func:`SortedDict.__len__` (inherited from dict)

        Methods for adding items:

        * :func:`SortedDict.setdefault`
        * :func:`SortedDict.update`

        Methods for removing items:

        * :func:`SortedDict.clear`
        * :func:`SortedDict.pop`
        * :func:`SortedDict.popitem`

        Methods for looking up items:

        * :func:`SortedDict.__contains__` (inherited from dict)
        * :func:`SortedDict.get` (inherited from dict)
        * :func:`SortedDict.peekitem`

        Methods for views:

        * :func:`SortedDict.keys`
        * :func:`SortedDict.items`
        * :func:`SortedDict.values`

        Methods for miscellany:

        * :func:`SortedDict.copy`
        * :func:`SortedDict.fromkeys`
        * :func:`SortedDict.__reversed__`
        * :func:`SortedDict.__eq__` (inherited from dict)
        * :func:`SortedDict.__ne__` (inherited from dict)
        * :func:`SortedDict.__repr__`
        * :func:`SortedDict._check`

        Sorted list methods available (applies to keys):

        * :func:`SortedList.bisect_left`
        * :func:`SortedList.bisect_right`
        * :func:`SortedList.count`
        * :func:`SortedList.index`
        * :func:`SortedList.irange`
        * :func:`SortedList.islice`
        * :func:`SortedList._reset`

        Additional sorted list methods available, if key-function used:

        * :func:`SortedKeyList.bisect_key_left`
        * :func:`SortedKeyList.bisect_key_right`
        * :func:`SortedKeyList.irange_key`

        Sorted dicts may only be compared for equality and inequality.

        """
        def __init__(self, *args, **kwargs):
            """Initialize sorted dict instance.

            Optional key-function argument defines a callable that, like the `key`
            argument to the built-in `sorted` function, extracts a comparison key
            from each dictionary key. If no function is specified, the default
            compares the dictionary keys directly. The key-function argument must
            be provided as a positional argument and must come before all other
            arguments.

            Optional iterable argument provides an initial sequence of pairs to
            initialize the sorted dict. Each pair in the sequence defines the key
            and corresponding value. If a key is seen more than once, the last
            value associated with it is stored in the new sorted dict.

            Optional mapping argument provides an initial mapping of items to
            initialize the sorted dict.

            If keyword arguments are given, the keywords themselves, with their
            associated values, are added as items to the dictionary. If a key is
            specified both in the positional argument and as a keyword argument,
            the value associated with the keyword is stored in the
            sorted dict.

            Sorted dict keys must be hashable, per the requirement for Python's
            dictionaries. Keys (or the result of the key-function) must also be
            comparable, per the requirement for sorted lists.

            >>> d = {'alpha': 1, 'beta': 2}
            >>> SortedDict([('alpha', 1), ('beta', 2)]) == d
            True
            >>> SortedDict({'alpha': 1, 'beta': 2}) == d
            True
            >>> SortedDict(alpha=1, beta=2) == d
            True

            """
            if args and (args[0] is None or callable(args[0])):
                _key = self._key = args[0]
                args = args[1:]
            else:
                _key = self._key = None

            self._list = SortedList(key=_key)

            # Calls to super() are expensive so cache references to dict methods on
            # sorted dict instances.

            _dict = super(SortedDict, self)
            self._dict_clear = _dict.clear
            self._dict_delitem = _dict.__delitem__
            self._dict_iter = _dict.__iter__
            self._dict_pop = _dict.pop
            self._dict_setitem = _dict.__setitem__
            self._dict_update = _dict.update

            # Reaching through ``self._list`` repeatedly adds unnecessary overhead
            # so cache references to sorted list methods.

            _list = self._list
            self._list_add = _list.add
            self._list_clear = _list.clear
            self._list_iter = _list.__iter__
            self._list_reversed = _list.__reversed__
            self._list_pop = _list.pop
            self._list_remove = _list.remove
            self._list_update = _list.update

            # Expose some sorted list methods publicly.

            self.bisect_left = _list.bisect_left
            self.bisect = _list.bisect_right
            self.bisect_right = _list.bisect_right
            self.index = _list.index
            self.irange = _list.irange
            self.islice = _list.islice
            self._reset = _list._reset

            if _key is not None:
                self.bisect_key_left = _list.bisect_key_left
                self.bisect_key_right = _list.bisect_key_right
                self.bisect_key = _list.bisect_key
                self.irange_key = _list.irange_key

            self._update(*args, **kwargs)

        @property
        def key(self):
            """Function used to extract comparison key from keys.

            Sorted dict compares keys directly when the key function is none.

            """
            return self._key

        @property
        def iloc(self):
            """Cached reference of sorted keys view.

            Deprecated in version 2 of Sorted Containers. Use
            :func:`SortedDict.keys` instead.

            """
            # pylint: disable=attribute-defined-outside-init
            try:
                return self._iloc
            except AttributeError:
                warnings.warn(
                    'sorted_dict.iloc is deprecated.'
                    ' Use SortedDict.keys() instead.',
                    DeprecationWarning,
                    stacklevel=2,
                )
                _iloc = self._iloc = SortedKeysView(self)
                return _iloc

        def clear(self):

            """Remove all items from sorted dict.

            Runtime complexity: `O(n)`

            """
            self._dict_clear()
            self._list_clear()

        def __delitem__(self, key):
            """Remove item from sorted dict identified by `key`.

            ``sd.__delitem__(key)`` <==> ``del sd[key]``

            Runtime complexity: `O(log(n))` -- approximate.

            >>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
            >>> del sd['b']
            >>> sd
            SortedDict({'a': 1, 'c': 3})
            >>> del sd['z']
            Traceback (most recent call last):
              ...
            KeyError: 'z'

            :param key: `key` for item lookup
            :raises KeyError: if key not found

            """
            self._dict_delitem(key)
            self._list_remove(key)

        def __iter__(self):
            """Return an iterator over the keys of the sorted dict.

            ``sd.__iter__()`` <==> ``iter(sd)``

            Iterating the sorted dict while adding or deleting items may raise a
            :exc:`RuntimeError` or fail to iterate over all keys.

            """
            return self._list_iter()

        def __reversed__(self):
            """Return a reverse iterator over the keys of the sorted dict.

            ``sd.__reversed__()`` <==> ``reversed(sd)``

            Iterating the sorted dict while adding or deleting items may raise a
            :exc:`RuntimeError` or fail to iterate over all keys.

            """
            return self._list_reversed()

        def __setitem__(self, key, value):
            """Store item in sorted dict with `key` and corresponding `value`.

            ``sd.__setitem__(key, value)`` <==> ``sd[key] = value``

            Runtime complexity: `O(log(n))` -- approximate.

            >>> sd = SortedDict()
            >>> sd['c'] = 3
            >>> sd['a'] = 1
            >>> sd['b'] = 2
            >>> sd
            SortedDict({'a': 1, 'b': 2, 'c': 3})

            :param key: key for item
            :param value: value for item

            """
            if key not in self:
                self._list_add(key)
            self._dict_setitem(key, value)

        _setitem = __setitem__

        def copy(self):
            """Return a shallow copy of the sorted dict.

            Runtime complexity: `O(n)`

            :return: new sorted dict

            """
            return self.__class__(self._key, self.items())

        __copy__ = copy

        @classmethod
        def fromkeys(cls, iterable, value=None):
            """Return a new sorted dict initailized from `iterable` and `value`.

            Items in the sorted dict have keys from `iterable` and values equal to
            `value`.

            Runtime complexity: `O(n*log(n))`

            :return: new sorted dict

            """
            return cls((key, value) for key in iterable)

        def keys(self):
            """Return new sorted keys view of the sorted dict's keys.

            See :class:`SortedKeysView` for details.

            :return: new sorted keys view

            """
            return SortedKeysView(self)

        def items(self):
            """Return new sorted items view of the sorted dict's items.

            See :class:`SortedItemsView` for details.

            :return: new sorted items view

            """
            return SortedItemsView(self)

        def values(self):
            """Return new sorted values view of the sorted dict's values.

            See :class:`SortedValuesView` for details.

            :return: new sorted values view

            """
            return SortedValuesView(self)

        if sys.hexversion < 0x03000000:
            def __make_raise_attributeerror(original, alternate):
                # pylint: disable=no-self-argument
                message = (
                    'SortedDict.{original}() is not implemented.'
                    ' Use SortedDict.{alternate}() instead.'
                ).format(original=original, alternate=alternate)
                def method(self):
                    # pylint: disable=missing-docstring,unused-argument
                    raise AttributeError(message)
                method.__name__ = original
                method.__doc__ = message
                return property(method)

            iteritems = __make_raise_attributeerror('iteritems', 'items')
            iterkeys = __make_raise_attributeerror('iterkeys', 'keys')
            itervalues = __make_raise_attributeerror('itervalues', 'values')
            viewitems = __make_raise_attributeerror('viewitems', 'items')
            viewkeys = __make_raise_attributeerror('viewkeys', 'keys')
            viewvalues = __make_raise_attributeerror('viewvalues', 'values')

        class _NotGiven(object):
            # pylint: disable=too-few-public-methods
            def __repr__(self):
                return '<not-given>'

        __not_given = _NotGiven()

        def pop(self, key, default=__not_given):
            """Remove and return value for item identified by `key`.

            If the `key` is not found then return `default` if given. If `default`
            is not given then raise :exc:`KeyError`.

            Runtime complexity: `O(log(n))` -- approximate.

            >>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
            >>> sd.pop('c')
            3
            >>> sd.pop('z', 26)
            26
            >>> sd.pop('y')
            Traceback (most recent call last):
              ...
            KeyError: 'y'

            :param key: `key` for item
            :param default: `default` value if key not found (optional)
            :return: value for item
            :raises KeyError: if `key` not found and `default` not given

            """
            if key in self:
                self._list_remove(key)
                return self._dict_pop(key)
            else:
                if default is self.__not_given:
                    raise KeyError(key)
                else:
                    return default

        def popitem(self, index=-1):
            """Remove and return ``(key, value)`` pair at `index` from sorted dict.

            Optional argument `index` defaults to -1, the last item in the sorted
            dict. Specify ``index=0`` for the first item in the sorted dict.

            If the sorted dict is empty, raises :exc:`KeyError`.

            If the `index` is out of range, raises :exc:`IndexError`.

            Runtime complexity: `O(log(n))`

            >>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
            >>> sd.popitem()
            ('c', 3)
            >>> sd.popitem(0)
            ('a', 1)
            >>> sd.popitem(100)
            Traceback (most recent call last):
              ...
            IndexError: list index out of range

            :param int index: `index` of item (default -1)
            :return: key and value pair
            :raises KeyError: if sorted dict is empty
            :raises IndexError: if `index` out of range

            """
            if not self:
                raise KeyError('popitem(): dictionary is empty')

            key = self._list_pop(index)
            value = self._dict_pop(key)
            return (key, value)

        def peekitem(self, index=-1):
            """Return ``(key, value)`` pair at `index` in sorted dict.

            Optional argument `index` defaults to -1, the last item in the sorted
            dict. Specify ``index=0`` for the first item in the sorted dict.

            Unlike :func:`SortedDict.popitem`, the sorted dict is not modified.

            If the `index` is out of range, raises :exc:`IndexError`.

            Runtime complexity: `O(log(n))`

            >>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
            >>> sd.peekitem()
            ('c', 3)
            >>> sd.peekitem(0)
            ('a', 1)
            >>> sd.peekitem(100)
            Traceback (most recent call last):
              ...
            IndexError: list index out of range

            :param int index: index of item (default -1)
            :return: key and value pair
            :raises IndexError: if `index` out of range

            """
            key = self._list[index]
            return key, self[key]

        def setdefault(self, key, default=None):
            """Return value for item identified by `key` in sorted dict.

            If `key` is in the sorted dict then return its value. If `key` is not
            in the sorted dict then insert `key` with value `default` and return
            `default`.

            Optional argument `default` defaults to none.

            Runtime complexity: `O(log(n))` -- approximate.

            >>> sd = SortedDict()
            >>> sd.setdefault('a', 1)
            1
            >>> sd.setdefault('a', 10)
            1
            >>> sd
            SortedDict({'a': 1})

            :param key: key for item
            :param default: value for item (default None)
            :return: value for item identified by `key`

            """
            if key in self:
                return self[key]
            self._dict_setitem(key, default)
            self._list_add(key)
            return default

        def update(self, *args, **kwargs):
            """Update sorted dict with items from `args` and `kwargs`.

            Overwrites existing items.

            Optional arguments `args` and `kwargs` may be a mapping, an iterable of
            pairs or keyword arguments. See :func:`SortedDict.__init__` for
            details.

            :param args: mapping or iterable of pairs
            :param kwargs: keyword arguments mapping

            """
            if not self:
                self._dict_update(*args, **kwargs)
                self._list_update(self._dict_iter())
                return

            if not kwargs and len(args) == 1 and isinstance(args[0], dict):
                pairs = args[0]
            else:
                pairs = dict(*args, **kwargs)

            if (10 * len(pairs)) > len(self):
                self._dict_update(pairs)
                self._list_clear()
                self._list_update(self._dict_iter())
            else:
                for key in pairs:
                    self._setitem(key, pairs[key])

        _update = update

        def __reduce__(self):
            """Support for pickle.

            The tricks played with caching references in
            :func:`SortedDict.__init__` confuse pickle so customize the reducer.

            """
            return (self.__class__, (self._key, list(self.items())))

        @recursive_repr()
        def __repr__(self):
            """Return string representation of sorted dict.

            ``sd.__repr__()`` <==> ``repr(sd)``

            :return: string representation

            """
            _key = self._key
            type_name = type(self).__name__
            key_arg = '' if _key is None else '{0!r}, '.format(_key)
            item_format = '{0!r}: {1!r}'.format
            items = ', '.join(item_format(key, self[key]) for key in self._list)
            return '{0}({1}{{{2}}})'.format(type_name, key_arg, items)

        def _check(self):
            """Check invariants of sorted dict.

            Runtime complexity: `O(n)`

            """
            _list = self._list
            _list._check()
            assert len(self) == len(_list)
            assert all(key in self for key in _list)

    def _view_delitem(self, index):
        """Remove item at `index` from sorted dict.

        ``view.__delitem__(index)`` <==> ``del view[index]``

        Supports slicing.

        Runtime complexity: `O(log(n))` -- approximate.

        >>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
        >>> view = sd.keys()
        >>> del view[0]
        >>> sd
        SortedDict({'b': 2, 'c': 3})
        >>> del view[-1]
        >>> sd
        SortedDict({'b': 2})
        >>> del view[:]
        >>> sd
        SortedDict({})

        :param index: integer or slice for indexing
        :raises IndexError: if index out of range

        """
        _mapping = self._mapping
        _list = _mapping._list
        _dict_delitem = _mapping._dict_delitem
        if isinstance(index, slice):
            keys = _list[index]
            del _list[index]
            for key in keys:
                _dict_delitem(key)
        else:
            key = _list.pop(index)
            _dict_delitem(key)

    class SortedKeysView(KeysView, Sequence):
        """Sorted keys view is a dynamic view of the sorted dict's keys.

        When the sorted dict's keys change, the view reflects those changes.

        The keys view implements the set and sequence abstract base classes.

        """
        __slots__ = ()

        @classmethod
        def _from_iterable(cls, it):
            return SortedSet(it)

        def __getitem__(self, index):
            """Lookup key at `index` in sorted keys views.

            ``skv.__getitem__(index)`` <==> ``skv[index]``

            Supports slicing.

            Runtime complexity: `O(log(n))` -- approximate.

            >>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
            >>> skv = sd.keys()
            >>> skv[0]
            'a'
            >>> skv[-1]
            'c'
            >>> skv[:]
            ['a', 'b', 'c']
            >>> skv[100]
            Traceback (most recent call last):
              ...
            IndexError: list index out of range

            :param index: integer or slice for indexing
            :return: key or list of keys
            :raises IndexError: if index out of range

            """
            return self._mapping._list[index]

        __delitem__ = _view_delitem

    class SortedItemsView(ItemsView, Sequence):
        """Sorted items view is a dynamic view of the sorted dict's items.

        When the sorted dict's items change, the view reflects those changes.

        The items view implements the set and sequence abstract base classes.

        """
        __slots__ = ()

        @classmethod
        def _from_iterable(cls, it):
            return SortedSet(it)

        def __getitem__(self, index):
            """Lookup item at `index` in sorted items view.

            ``siv.__getitem__(index)`` <==> ``siv[index]``

            Supports slicing.

            Runtime complexity: `O(log(n))` -- approximate.

            >>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
            >>> siv = sd.items()
            >>> siv[0]
            ('a', 1)
            >>> siv[-1]
            ('c', 3)
            >>> siv[:]
            [('a', 1), ('b', 2), ('c', 3)]
            >>> siv[100]
            Traceback (most recent call last):
              ...
            IndexError: list index out of range

            :param index: integer or slice for indexing
            :return: item or list of items
            :raises IndexError: if index out of range

            """
            _mapping = self._mapping
            _mapping_list = _mapping._list

            if isinstance(index, slice):
                keys = _mapping_list[index]
                return [(key, _mapping[key]) for key in keys]

            key = _mapping_list[index]
            return key, _mapping[key]

        __delitem__ = _view_delitem

    class SortedValuesView(ValuesView, Sequence):
        """Sorted values view is a dynamic view of the sorted dict's values.

        When the sorted dict's values change, the view reflects those changes.

        The values view implements the sequence abstract base class.

        """
        __slots__ = ()

        def __getitem__(self, index):
            """Lookup value at `index` in sorted values view.

            ``siv.__getitem__(index)`` <==> ``siv[index]``

            Supports slicing.

            Runtime complexity: `O(log(n))` -- approximate.

            >>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
            >>> svv = sd.values()
            >>> svv[0]
            1
            >>> svv[-1]
            3
            >>> svv[:]
            [1, 2, 3]
            >>> svv[100]
            Traceback (most recent call last):
              ...
            IndexError: list index out of range

            :param index: integer or slice for indexing
            :return: value or list of values
            :raises IndexError: if index out of range

            """
            _mapping = self._mapping
            _mapping_list = _mapping._list

            if isinstance(index, slice):
                keys = _mapping_list[index]
                return [_mapping[key] for key in keys]

            key = _mapping_list[index]
            return _mapping[key]

        __delitem__ = _view_delitem