`+*dZddlmZddlZddlZddlmZmZmZddl m Z m Z m Z ddl mZddlmZmZmZmZmZmZmZmZddlmZ dd lmZmZdd lm Z dd lm!Z!e!d krdd l m"Z#ddl m$Z% ddl&m'Z'n ddlm)Z) ddl*m'Z'ddZ,GddeZ-dZ.Gdde-Z/e/Z0y#e$r dd lmZmZYawxYw#e$r ddl(m'Z'Y@wxYw#e$r ddl+m'Z'YQwxYw)abSorted List ============== :doc:`Sorted Containers` is an Apache2 licensed Python sorted collections library, written in pure-Python, and fast as C-extensions. The :doc:`introduction` is the best way to get started. Sorted list implementations: .. currentmodule:: sortedcontainers * :class:`SortedList` * :class:`SortedKeyList` )print_functionN) bisect_left bisect_rightinsort)chainrepeatstarmap)log)addeqnegtgeltleiadd)dedent)SequenceMutableSequence)wraps) hexversioni)imap)izip) get_ident)reducecfd}|S)zHDecorator to make a repr function return fillvalue for a recursive call.cJttfd}|S)Nct|tf}|vrSj| |}j||S#j|wxYwN)idrr discard)selfkeyresult fillvalue repr_running user_functions =/usr/lib/python3/dist-packages/sortedcontainers/sortedlist.pywrapperz.decorating_function..wrapper@scT(IK'Cl"    S ! *&t,$$S)M$$S)s A A)setr)r'r)r&r%s` @r(decorating_functionz+recursive_repr..decorating_function=s(u }    )r%r+s` r(recursive_reprr.7s " r,ceZdZdZdZd:dZd:dZedZdZ dZ e Z d Z d Z d ZeZd Zd ZdZdZdZdZdZdZdZeZdZdZdZdZd;dZdZ de4e?d5d6Z@eAe4Z4d7ZBeCd8ZDd9ZEy)> SortedListaSorted list is a sorted mutable sequence. Sorted list values are maintained in sorted order. Sorted list values must be comparable. The total ordering of values must not change while they are stored in the sorted list. Methods for adding values: * :func:`SortedList.add` * :func:`SortedList.update` * :func:`SortedList.__add__` * :func:`SortedList.__iadd__` * :func:`SortedList.__mul__` * :func:`SortedList.__imul__` Methods for removing values: * :func:`SortedList.clear` * :func:`SortedList.discard` * :func:`SortedList.remove` * :func:`SortedList.pop` * :func:`SortedList.__delitem__` Methods for looking up values: * :func:`SortedList.bisect_left` * :func:`SortedList.bisect_right` * :func:`SortedList.count` * :func:`SortedList.index` * :func:`SortedList.__contains__` * :func:`SortedList.__getitem__` Methods for iterating values: * :func:`SortedList.irange` * :func:`SortedList.islice` * :func:`SortedList.__iter__` * :func:`SortedList.__reversed__` Methods for miscellany: * :func:`SortedList.copy` * :func:`SortedList.__len__` * :func:`SortedList.__repr__` * :func:`SortedList._check` * :func:`SortedList._reset` Sorted lists use lexicographical ordering semantics when compared to other sequences. Some methods of mutable sequences are not supported and will raise not-implemented error. iNc|Jd|_|j|_g|_g|_g|_d|_||j|yy)aInitialize sorted list instance. Optional `iterable` argument provides an initial iterable of values to initialize the sorted list. Runtime complexity: `O(n*log(n))` >>> sl = SortedList() >>> sl SortedList([]) >>> sl = SortedList([3, 1, 2, 5, 4]) >>> sl SortedList([1, 2, 3, 4, 5]) :param iterable: initial values (optional) Nr)_lenDEFAULT_LOAD_FACTOR_load_lists_maxes_index_offset_updater"iterabler#s r(__init__zSortedList.__init__sU${{ --       LL " r,c|tj|S|turtjtSt d)aJCreate new sorted list or sorted-key list instance. Optional `key`-function argument will return an instance of subtype :class:`SortedKeyList`. >>> sl = SortedList() >>> isinstance(sl, SortedList) True >>> sl = SortedList(key=lambda x: -x) >>> isinstance(sl, SortedList) True >>> isinstance(sl, SortedKeyList) True :param iterable: initial values (optional) :param key: function used to extract comparison key (optional) :return: sorted list or sorted-key list instance z&inherit SortedKeyList for key argument)object__new__r0 SortedKeyList TypeErrorclsr;r#s r(r?zSortedList.__new__s;* ;>>#& &j ~~m44 HIIr,cy)zFunction used to extract comparison key from values. Sorted list compares values directly so the key function is none. Nr-r"s r(r#zSortedList.keysr,ctt|jg}|j||_|j |y)aReset sorted list load factor. The `load` specifies the load-factor of the list. The default load factor of 1000 works well for lists from tens to tens-of-millions of values. Good practice is to use a value that is the cube root of the list size. With billions of elements, the best load factor depends on your usage. It's best to leave the load factor at the default until you start benchmarking. See :doc:`implementation` and :doc:`performance-scale` for more information. Runtime complexity: `O(n)` :param int load: load-factor for sorted list sublists N)rrr5_clearr4r9)r"loadvaluess r(_resetzSortedList._resets2$dkk2.   Vr,czd|_|jdd=|jdd=|jdd=d|_y)zQRemove all values from sorted list. Runtime complexity: `O(n)` rN)r2r5r6r7r8rEs r(clearzSortedList.clears3  KKN KKN KKN r,c\|j}|j}|rZt||}|t|k(r|dz}||j ||||<nt ||||j |n#|j |g|j ||xjdz c_y)aAdd `value` to sorted list. Runtime complexity: `O(log(n))` -- approximate. >>> sl = SortedList() >>> sl.add(3) >>> sl.add(1) >>> sl.add(2) >>> sl SortedList([1, 2, 3]) :param value: value to add to sorted list N)r5r6rlenappendr_expandr2)r"valuer5r6poss r(r zSortedList.adds vu-Cc&k!qs ""5)#s vc{E* LL  MM5' " MM%  Q r,c|j}|j}|j}t|||dzkDrV|j}||}||d}||d=|d||<|j |dz||j |dz|d|dd=y|r7|j |z}|r||xxdz cc<|dz dz }|r|dxxdz cc<yya>Split sublists with length greater than double the load-factor. Updates the index when the sublist length is less than double the load level. This requires incrementing the nodes in a traversal from the leaf node to the root. For an example traversal see ``SortedList._loc``. rNNr)r4r5r7rOr6insertr8) r"rSr4r5r7r6 _lists_poshalfchilds r(rQzSortedList._expand!s  vc{ uz *[[FJef%D56"$R.F3K MM#'4 ( MM#'48 ,q  s*5MQ&M"QY1,Eq Q r,c *|j}|j}t||rztdz|jk\rC|j t t|gj|jn|j}D] }|| y|j|jfdtdtD|jd|Dt|_|jdd=y)aUpdate sorted list by adding all values from `iterable`. Runtime complexity: `O(k*log(n))` -- approximate. >>> sl = SortedList() >>> sl.update([3, 1, 2]) >>> sl SortedList([1, 2, 3]) :param iterable: iterable of values to add Nc3.K|] }||zywrr-.0rSr4rIs r( z$SortedList.update..a$?S#+/?rc3&K|] }|d ywrVNr-r_sublists r(r`z$SortedList.update..cs8ggbk8)r5r6sortedrOr2rPrrsortrGr r4extendranger7)r"r;r5r6_addvalr4rIs @@r(updatezSortedList.updateCs! 6{Q$))+ f%fb1  xx!CI  ?!&q#f+u!=? ? 888K KKNr,c|j}|syt||}|t|k(ry|j}t|||}||||k(S)aZReturn true if `value` is an element of the sorted list. ``sl.__contains__(value)`` <==> ``value in sl`` Runtime complexity: `O(log(n))` >>> sl = SortedList([1, 2, 3, 4, 5]) >>> 3 in sl True :param value: search for value in sorted list :return: true if `value` in sorted list F)r6rrOr5r"rRr6rSr5idxs r( __contains__zSortedList.__contains__js[&%( #f+ &+u-c{35((r,c|j}|syt||}|t|k(ry|j}t|||}||||k(r|j ||yy)aoRemove `value` from sorted list if it is a member. If `value` is not a member, do nothing. Runtime complexity: `O(log(n))` -- approximate. >>> sl = SortedList([1, 2, 3, 4, 5]) >>> sl.discard(5) >>> sl.discard(0) >>> sl == [1, 2, 3, 4] True :param value: `value` to discard from sorted list N)r6rrOr5_deleterps r(r!zSortedList.discardsk  &%( #f+  &+u- #;s u $ LLc " %r,c`|j}|stdj|t||}|t |k(rtdj||j }t|||}||||k(r|j ||ytdj|)aRemove `value` from sorted list; `value` must be a member. If `value` is not a member, raise ValueError. Runtime complexity: `O(log(n))` -- approximate. >>> sl = SortedList([1, 2, 3, 4, 5]) >>> sl.remove(5) >>> sl == [1, 2, 3, 4] True >>> sl.remove(0) Traceback (most recent call last): ... ValueError: 0 not in list :param value: `value` to remove from sorted list :raises ValueError: if `value` is not in sorted list {0!r} not in listN)r6 ValueErrorformatrrOr5rtrps r(removezSortedList.removes(077>? ?&%( #f+ 077>? ?&+u- #;s u $ LLc "077>? ?r,c.|j}|j}|j}||}||=|xjdzc_t |}||j dz kDrH|d||<|r=|j |z}|dkDr||xxdzcc<|dz dz }|dkDr|dxxdzcc<yyt |dkDrK|s|dz }|dz } || j|||| d|| <||=||=|dd=|j| y|r |d||<y||=||=|dd=yaDelete value at the given `(pos, idx)`. Combines lists that are less than half the load level. Updates the index when the sublist length is more than half the load level. This requires decrementing the nodes in a traversal from the leaf node to the root. For an example traversal see ``SortedList._loc``. :param int pos: lists index :param int idx: sublist index rNrVrN) r5r6r7r2rOr4r8rjrQ) r"rSrqr5r6r7rX len_lists_posrZprevs r(rtzSortedList._deletesCC[ sO Q J DJJ!O ,$R.F3K s*ai5MQ&M"QY1,Eaiq Q  [1_q7D 4L  s ,!$<+F4Ls s q LL  $R.F3Ks s q r,c|s|S|j}|s|jd}||jz }|r|dzs |||dz z }|dz dz }|r||zS)aConvert an index pair (lists index, sublist index) into a single index number that corresponds to the position of the value in the sorted list. Many queries require the index be built. Details of the index are described in ``SortedList._build_index``. Indexing requires traversing the tree from a leaf node to the root. The parent of each node is easily computable at ``(pos - 1) // 2``. Left-child nodes are always at odd indices and right-child nodes are always at even indices. When traversing up from a right-child node, increment the total by the left-child node. The final index is the sum from traversal and the index in the sublist. For example, using the index from ``SortedList._build_index``:: _index = 14 5 9 3 2 4 5 _offset = 3 Tree:: 14 5 9 3 2 4 5 Converting an index pair (2, 3) into a single index involves iterating like so: 1. Starting at the leaf node: offset + alpha = 3 + 2 = 5. We identify the node as a left-child node. At such nodes, we simply traverse to the parent. 2. At node 9, position 2, we recognize the node as a right-child node and accumulate the left-child in our total. Total is now 5 and we traverse to the parent at position 0. 3. Iteration ends at the root. The index is then the sum of the total and sublist index: 5 + 3 = 8. :param int pos: lists index :param int idx: sublist index :return: index in sorted list rrN)r7 _build_indexr8)r"rSrqr7totals r(_loczSortedList._locszdJ     t|| 7a(7q.Cs{r,c|dkrZt|jd}| |krt|jdz ||zfS||jz }|dkr%td||jk\r td|t|jdkrd|fS|j}|s|j d}d}t|}||kr%||}||kr|}n ||z}|dz}|dzdz}||kr%||j z |fS)aiConvert an index into an index pair (lists index, sublist index) that can be used to access the corresponding lists position. Many queries require the index be built. Details of the index are described in ``SortedList._build_index``. Indexing requires traversing the tree to a leaf node. Each node has two children which are easily computable. Given an index, pos, the left-child is at ``pos * 2 + 1`` and the right-child is at ``pos * 2 + 2``. When the index is less than the left-child, traversal moves to the left sub-tree. Otherwise, the index is decremented by the left-child and traversal moves to the right sub-tree. At a child node, the indexing pair is computed from the relative position of the child node as compared with the offset and the remaining index. For example, using the index from ``SortedList._build_index``:: _index = 14 5 9 3 2 4 5 _offset = 3 Tree:: 14 5 9 3 2 4 5 Indexing position 8 involves iterating like so: 1. Starting at the root, position 0, 8 is compared with the left-child node (5) which it is greater than. When greater the index is decremented and the position is updated to the right child node. 2. At node 9 with index 3, we again compare the index to the left-child node with value 4. Because the index is the less than the left-child node, we simply traverse to the left. 3. At node 4 with index 3, we recognize that we are at a leaf node and stop iterating. 4. To compute the sublist index, we subtract the offset from the index of the leaf node: 5 - 3 = 2. To compute the index in the sublist, we simply use the index remaining from iteration. In this case, 3. The final index pair from our example is (2, 3) which corresponds to index 8 in the sorted list. :param int idx: index in sorted list :return: (lists index, sublist index) pair rrVrNlist index out of range)rOr5r2 IndexErrorr7rr8)r"rqlast_lenr7rSrZ len_index index_childs r(_poszSortedList._posYs%n 74;;r?+H!4;;'!+X^;; 499 CQw !:;; DII 67 7 T[[^$ $c6M    K i -K[ {"aiAXNEidll"C((r,c ttt|j}t|dk(r||jddd|_yt |}t |}tttt||}t|dzr|j|dt|dk(r||z|jddd|_ydttt|dz ddzz}|jtd|t|z ||g}t|ddkDr_t |d}t |}tttt||}|j|t|ddkDr_tt t#||j|dzdz |_y)aBuild a positional index for indexing the sorted list. Indexes are represented as binary trees in a dense array notation similar to a binary heap. For example, given a lists representation storing integers:: 0: [1, 2, 3] 1: [4, 5] 2: [6, 7, 8, 9] 3: [10, 11, 12, 13, 14] The first transformation maps the sub-lists by their length. The first row of the index is the length of the sub-lists:: 0: [3, 2, 4, 5] Each row after that is the sum of consecutive pairs of the previous row:: 1: [5, 9] 2: [14] Finally, the index is built by concatenating these lists together:: _index = [14, 5, 9, 3, 2, 4, 5] An offset storing the start of the first row is also stored:: _offset = 3 When built, the index can be used for efficient indexing into the list. See the comment and notes on ``SortedList._pos`` for details. rNNrrV)listmaprOr5r7r8iterr r ziprPintr rjrrrreversed)r"row0headtailrow1sizetreerows r(rzSortedList._build_indexsnHCT[[)* t9>!DKKNDL DzDzGCT412 t9q= KKR ! t9>!D[DKKNDL SSY]A./!34 F1dSY./0d|$r(maR>D:DwsCdO45C KK  $r(ma tXd^T[[1ax!| r,ct|tr|j|j\}}}|dk(r||kr|dk(r||jk(r|j S|jd||z zkri|j td|}||jkr||j t|dz }|j |j |St|||}|dkDr t|}|j|j}}|D]}||\} } || | y|j|\} } |j| | y)aRemove value at `index` from sorted list. ``sl.__delitem__(index)`` <==> ``del sl[index]`` Supports slicing. Runtime complexity: `O(log(n))` -- approximate. >>> sl = SortedList('abcde') >>> del sl[2] >>> sl SortedList(['a', 'b', 'd', 'e']) >>> del sl[:2] >>> sl SortedList(['d', 'e']) :param index: integer or slice for indexing :raises IndexError: if index out of range rNrN) isinstancesliceindicesr2rG_getitemr9rkrrrt) r"indexstartstopsteprIrrrtrSrqs r( __delitem__zSortedList.__delitem__s4* eU # % dii 8 E4qyUT\A:$$))"3;;=(YY!te|"44!]]5u+=>Fdii'$--dD0A"BBKKM<<//E4.G ax"7+ IIt||'D  ";SS! "yy'HC LLc "r,cj}t|trX|jj\}}}|dk(r||kr|dk(r*|jk(rt t jgSj|\}}||}||z|z } t|| k\r||| S|jk(rt|dz } t|| } nj|\} } |||d} ||dz| } t t | | } | || d| z } | S|dk(r8||kDr3jt|dz|dz} | j| St|||}tfd|DSjr|dk(r|ddS|dk(r|ddStdd|cxkrt|dkr nn|d|St|d}| |cxkrdkrnn |d||zSj|\}}|||S)aLookup value at `index` in sorted list. ``sl.__getitem__(index)`` <==> ``sl[index]`` Supports slicing. Runtime complexity: `O(log(n))` -- approximate. >>> sl = SortedList('abcde') >>> sl[1] 'b' >>> sl[-1] 'e' >>> sl[2:5] ['c', 'd', 'e'] :param index: integer or slice for indexing :return: value or list of values :raises IndexError: if index out of range rNrNrVc3@K|]}j|ywr)r)r_rr"s r(r`z)SortedList.__getitem__..ssB e,Bsr)r5rrrr2rrrrOrreverserkrr)r"rr5rrr start_pos start_idx start_liststop_idxstop_posprefixmiddler$rlen_lastrSrqs` r( __getitem__zSortedList.__getitem__0s<, eU # % dii 8 E4qyUT\A:$$))"3!$ R88'+yy'7$ 9#I. $t+e3 z?h.%i99499$"6{QH"6(#34H)-4&Hh *9:6Q9ff5&*9H55 rzedluTAXuqy'AB  E4.GB'BB ByyA:!!9Q<'b[!":b>) !:;;E*Cq N*ay''6":Hy5$1$bz(U"233yy'HC#;s# #r,cd}t|)zRaise not-implemented error. ``sl.__setitem__(index, value)`` <==> ``sl[index] = value`` :raises NotImplementedError: use ``del sl[index]`` and ``sl.add(value)`` instead z3use ``del sl[index]`` and ``sl.add(value)`` insteadNotImplementedError)r"rrRmessages r( __setitem__zSortedList.__setitem__sH!'**r,c@tj|jS)zReturn an iterator over the sorted list. ``sl.__iter__()`` <==> ``iter(sl)`` Iterating the sorted list while adding or deleting values may raise a :exc:`RuntimeError` or fail to iterate over all values. )r from_iterabler5rEs r(__iter__zSortedList.__iter__s""4;;//r,cntjttt|jS)zReturn a reverse iterator over the sorted list. ``sl.__reversed__()`` <==> ``reversed(sl)`` Iterating the sorted list while adding or deleting values may raise a :exc:`RuntimeError` or fail to iterate over all values. )rrrrr5rEs r( __reversed__zSortedList.__reversed__s%""3x$++1F#GHHr,ctd)aRaise not-implemented error. Sorted list maintains values in ascending sort order. Values may not be reversed in-place. Use ``reversed(sl)`` for an iterator over values in descending sort order. Implemented to override `MutableSequence.reverse` which provides an erroneous default implementation. :raises NotImplementedError: use ``reversed(sl)`` instead zuse ``reversed(sl)`` insteadrrEs r(rzSortedList.reverses""@AAr,c|j}|s tdSt||j|j\}}}||k\r tdS|j}||\}}||k(r1t |j dz } t |j d} n ||\} } |j||| | |S)aReturn an iterator that slices sorted list from `start` to `stop`. The `start` and `stop` index are treated inclusive and exclusive, respectively. Both `start` and `stop` default to `None` which is automatically inclusive of the beginning and end of the sorted list. When `reverse` is `True` the values are yielded from the iterator in reverse order; `reverse` defaults to `False`. >>> sl = SortedList('abcdefghij') >>> it = sl.islice(2, 6) >>> list(it) ['c', 'd', 'e', 'f'] :param int start: start index (inclusive) :param int stop: stop index (exclusive) :param bool reverse: yield values in reverse order :return: iterator r-rNrV)r2rrrrrOr5_islice) r"rrrr2_rmin_posmin_idxmax_posmax_idxs r(islicezSortedList.islices.yy8Oud+33DII>tQ D=8Oyy; 4<$++&*G$++b/*G#Dz GW||GWgwHHr,c @|j}||kDr tdS||k(rU|r.tt||}t ||j |St||}t ||j |S|dz}||k(r|rot|t ||} t|} tt ||j t| t ||j t| St|t ||} t|} tt ||j | t ||j | S|rt|t ||} t||} t |j t| } t|} tt ||j t| tjt t| t ||j t| St|t ||} t||} t |j | } t|} tt ||j | tj| t ||j | S)ayReturn an iterator that slices sorted list using two index pairs. The index pairs are (min_pos, min_idx) and (max_pos, max_idx), the first inclusive and the latter exclusive. See `_pos` for details on how an index is converted to an index pair. When `reverse` is `True`, values are yielded from the iterator in reverse order. r-rN) r5rrrkrrrOrr) r"rrrrrr5rnext_pos min_indices max_indicessublist_indicessublistss r(rzSortedList._islicesU W 8O g "5'#:;6'?66@@GW-Gvg22G< <Q; w #GS-AB #Gn w33Xk5JKw33Xk5JK  VG_)=>K.KF7O//=F7O//=  VG_)=>K#Hg6O6--x/HIH.KF7O//+1FG##C($;<F7O//+1FG  GS%9: '2v))?;Gn  w++[ 9    ) w++[ 9  r,c|j}|s tdS|j}|d}d}nn|dr5t||}|t |k(r tdSt|||}n4t ||}|t |k(r tdSt |||}|t |dz } t || } n|dr>t ||} | t |k(r| dz} t || } nMt || |} n=t||} | t |k(r| dz} t || } nt|| |} |j ||| | |S)aCreate an iterator of values between `minimum` and `maximum`. Both `minimum` and `maximum` default to `None` which is automatically inclusive of the beginning and end of the sorted list. The argument `inclusive` is a pair of booleans that indicates whether the minimum and maximum ought to be included in the range, respectively. The default is ``(True, True)`` such that the range is inclusive of both minimum and maximum. When `reverse` is `True` the values are yielded from the iterator in reverse order; `reverse` defaults to `False`. >>> sl = SortedList('abcdefghij') >>> it = sl.irange('c', 'f') >>> list(it) ['c', 'd', 'e', 'f'] :param minimum: minimum value to start iterating :param maximum: maximum value to stop iterating :param inclusive: pair of booleans :param bool reverse: yield values in reverse order :return: iterator r-rrN)r6rr5rrOrr) r"minimummaximum inclusiverr6r5rrrrs r(irangezSortedList.irange0sZ68O ?GG|%fg6c&k)8O%fWow?&vw7c&k)8O&vg@ ?&kAoG&/*G|&vw7c&k)qLG!&/2G*6'?GDG%fg6c&k)qLG!&/2G)&/7CG||GWgwHHr,c|jS)z~Return the size of the sorted list. ``sl.__len__()`` <==> ``len(sl)`` :return: size of sorted list )r2rEs r(__len__zSortedList.__len__syyr,c|j}|syt||}|t|k(r |jSt|j||}|j ||S)aReturn an index to insert `value` in the sorted list. If the `value` is already present, the insertion point will be before (to the left of) any existing values. Similar to the `bisect` module in the standard library. Runtime complexity: `O(log(n))` -- approximate. >>> sl = SortedList([10, 11, 12, 13, 14]) >>> sl.bisect_left(12) 2 :param value: insertion index of value in sorted list :return: index r)r6rrOr2r5rr"rRr6rSrqs r(rzSortedList.bisect_lefts[$&%( #f+ 99 $++c*E2yyc""r,c|j}|syt||}|t|k(r |jSt|j||}|j ||S)aReturn an index to insert `value` in the sorted list. Similar to `bisect_left`, but if `value` is already present, the insertion point will be after (to the right of) any existing values. Similar to the `bisect` module in the standard library. Runtime complexity: `O(log(n))` -- approximate. >>> sl = SortedList([10, 11, 12, 13, 14]) >>> sl.bisect_right(12) 3 :param value: insertion index of value in sorted list :return: index r)r6rrOr2r5rrs r(rzSortedList.bisect_rights[$65) #f+ 99 4;;s+U3yyc""r,c|j}|syt||}|t|k(ry|j}t|||}t ||}|t|k(r|j |j ||z St |||}||k(r||z S|j ||}|j ||} || z S)a)Return number of occurrences of `value` in the sorted list. Runtime complexity: `O(log(n))` -- approximate. >>> sl = SortedList([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]) >>> sl.count(3) 3 :param value: value to count in sorted list :return: count r)r6rrOr5rr2r) r"rRr6pos_leftr5idx_left pos_right idx_rightrightlefts r(countzSortedList.countsvu- s6{ "vh/7 / F #99tyy8<< <  !2E: y x' ' )Y/yy8,t|r,c$|j|S)zyReturn a shallow copy of the sorted list. Runtime complexity: `O(n)` :return: new sorted list ) __class__rEs r(copyzSortedList.copys~~d##r,ctd)zRaise not-implemented error. Implemented to override `MutableSequence.append` which provides an erroneous default implementation. :raises NotImplementedError: use ``sl.add(value)`` instead use ``sl.add(value)`` insteadrr"rRs r(rPzSortedList.appends""ABBr,ctd)zRaise not-implemented error. Implemented to override `MutableSequence.extend` which provides an erroneous default implementation. :raises NotImplementedError: use ``sl.update(values)`` instead z!use ``sl.update(values)`` insteadrr"rIs r(rjzSortedList.extends""EFFr,ctd)zjRaise not-implemented error. :raises NotImplementedError: use ``sl.add(value)`` instead rr)r"rrRs r(rWzSortedList.inserts ""ABBr,cn|js td|j}|dk(r|dd}|jdd|S|dk(r;t |dz }t ||dz }|||}|j|||Sd|cxkrt |dkrnn|d|}|jd||St |d}| |cxkrdkr2nn/t |dz }||z}|||}|j|||S|j |\}}|||}|j|||S)aRemove and return value at `index` in sorted list. Raise :exc:`IndexError` if the sorted list is empty or index is out of range. Negative indices are supported. Runtime complexity: `O(log(n))` -- approximate. >>> sl = SortedList('abcde') >>> sl.pop() 'e' >>> sl.pop(2) 'c' >>> sl SortedList(['a', 'b', 'd']) :param int index: index of value (default -1) :return: value :raises IndexError: if index is out of range zpop index out of rangerrVrN)r2rr5rtrOr)r"rr5rmrSlocrrqs r(popzSortedList.pop'sL.yy56 6 A:)A,C LLA J B;f+/CfSk"Q&C+c"C LLc "J  &F1I &)E"C LLE "Jvbz? 9u q f+/CU"C+c"C LLc "J99U#SSk# S# r,c|j}|stdj||d}|dkr||z }|dkrd}||}|dkr||z }||kDr|}||krtdj||j}t ||}|t |k(rtdj||j }t |||}||||k7rtdj||dz}|j||} || kr| |kr| S|j|dz } || kr|Stdj|)aqReturn first index of value in sorted list. Raise ValueError if `value` is not present. Index must be between `start` and `stop` for the `value` to be considered present. The default value, None, for `start` and `stop` indicate the beginning and end of the sorted list. Negative indices are supported. Runtime complexity: `O(log(n))` -- approximate. >>> sl = SortedList('abcde') >>> sl.index('d') 3 >>> sl.index('z') Traceback (most recent call last): ... ValueError: 'z' is not in list :param value: value in sorted list :param int start: start index (default None, start of sorted list) :param int stop: stop index (default None, end of sorted list) :return: index of value :raises ValueError: if value is not present {0!r} is not in listrrN) r2rwrxr6rrOr5r _bisect_right) r"rRrrr2r6rr5rrrs r(rzSortedList.indexcsp8yy3::5AB B =E 19 TME 19E <D !8 DLD $;D 5=3::5AB Bvu- s6{ "3::5AB Bvh/7 ( H % .3::5AB B  yy8, D=t| &&u-1E~ /66u=>>r,c|tt|jg}|j||j |S)aReturn new sorted list containing all values in both sequences. ``sl.__add__(other)`` <==> ``sl + other`` Values in `other` do not need to be in sorted order. Runtime complexity: `O(n*log(n))` >>> sl1 = SortedList('bat') >>> sl2 = SortedList('cat') >>> sl1 + sl2 SortedList(['a', 'a', 'b', 'c', 't', 't']) :param other: other iterable :return: new sorted list )rrr5rjrr"otherrIs r(__add__zSortedList.__add__s1$dkk2. e~~f%%r,c(|j||S)aUpdate sorted list with values from `other`. ``sl.__iadd__(other)`` <==> ``sl += other`` Values in `other` do not need to be in sorted order. Runtime complexity: `O(k*log(n))` -- approximate. >>> sl = SortedList('bat') >>> sl += 'cat' >>> sl SortedList(['a', 'a', 'b', 'c', 't', 't']) :param other: other iterable :return: existing sorted list )r9)r"rs r(__iadd__zSortedList.__iadd__s$ U r,c`tt|jg|z}|j|S)ajReturn new sorted list with `num` shallow copies of values. ``sl.__mul__(num)`` <==> ``sl * num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl * 3 SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: new sorted list )rrr5rr"numrIs r(__mul__zSortedList.__mul__s*dkk2.4~~f%%r,ctt|jg|z}|j|j ||S)aUpdate the sorted list with `num` shallow copies of values. ``sl.__imul__(num)`` <==> ``sl *= num`` Runtime complexity: `O(n*log(n))` >>> sl = SortedList('abc') >>> sl *= 3 >>> sl SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']) :param int num: count of shallow copies :return: existing sorted list )rrr5rGr9rs r(__imul__zSortedList.__imul__s5 dkk2.4  V r,cfd}j}dj||_d}t|j||||_|S)zMake comparator method.ct|tstS|j}t |}||k7rt uryt uryt||D]\}}||k7s ||cS||S)z,Compare method for sorted list and sequence.FT)rrNotImplementedr2rOr r r)r"rself_len len_otheralphabetaseq_ops r(comparerz'SortedList.__make_cmp..comparer s~eX.%%yyHE I9$R< R<"4/ / tD=!%.. /(I. .r,z__{0}__a7Return true if and only if sorted list is {0} `other`. ``sl.__{1}__(other)`` <==> ``sl {2} other`` Comparisons use lexicographical order as with sequences. Runtime complexity: `O(n)` :param other: `other` sequence :return: true if sorted list is {0} `other` )__name__rxr__doc__)rsymboldocr seq_op_namedoc_strs` r( __make_cmpzSortedList.__make_cmp sN /(oo %,,[9  "'..k6"JKr,z==zequal toz!=z not equal toz greater thanz<=zless than or equal toz>=zgreater than or equal tocTtt|jg}t||ffSr)rrr5typers r( __reduce__zSortedList.__reduce__;s%dkk2.T VI&&r,c^djt|jt|S)zReturn string representation of sorted list. ``sl.__repr__()`` <==> ``repr(sl)`` :return: string representation z {0}({1!r}))rxrrrrEs r(__repr__zSortedList.__repr__@s%""4:#6#6T CCr,c |jdk\sJt|jt|jk(sJ|jt d|jDk(sJ|jD],}t dt|D]}||dz ||krJ.t dt|jD],}|j|dz d|j|dkr,Jt t|jD]&}|j||j|dk(r&J|jdztfd|jDsJ|jdz }t dt|jdz D]}t|j||k\rJ|jrw|j|jdk(sJt|j|jt|jzk(sJt t|jD];}|j|j|z}|t|j|k(r;Jt |jD]}|dzdz}|t|jk\r|j|dk(r6J|dzt|jk(r"|j||j|k(rsJ|j||j|dzz}||j|k(rJyy#tjtjtd|jtd |jtd |jtd t|jtd |jtd t|jtd|jtdt|jtd|jxYw)zNCheck invariants of sorted list. Runtime complexity: `O(n)` r\c32K|]}t|ywrrOres r(r`z$SortedList._check..U#LWCL#LrNrVrc3:K|]}t|kywrrr_rfdoubles r(r`z$SortedList._check..jI's7|v-IfilerOrHoffsetrr len_maxesmaxes len_listslistsN)r4rOr6r5r2sumrkallr7r8 traceback print_excsysstdoutprint)r"rfrSrYleafrZ child_sumrs @r(_checkzSortedList._checkLs A ::? "?t{{#s4;;'77 7799#L #L LL LL ;; < CL1MDQ NN)NNFNN)TTF)rV)Fr __module__ __qualname__rr3r<r?propertyr#rJrLrGr rQrnr9rrr!ryrtrrrrrrrrrrrrrrrrbisectrrr__copy__rPrjrWrrr__radd__rr__rmul__r_SortedList__make_cmpr __eq__r __ne__r__lt__r__gt__r__le__r__ge__ staticmethodr r.r r&r-r,r(r0r0Us6n#<J<0 F!HD"HG)>#B$@N4nNb[)|B$J1#hV$pH + 0 IB$+I\= @F M%P$H C GC9xJ?Z&,H,&$H,%PD* -F D. 1F C -F C 0F D"9 :F D"< =Fj)J' DDGr,r0c|S)zIdentity function.r-)rRs r(identityr9s Lr,ceZdZdZdefdZdefdZedZdZ e Z dZ dZ d Z e Zd Zd Zd Zd Z ddZ ddZeZdZdZeZdZeZdZeZeZdZdZeZ ddZ!dZ"e"Z#dZ$dZ%e&dZ'dZ(y)r@aiSorted-key list is a subtype of sorted list. The sorted-key list maintains values in comparison order based on the result of a key function applied to every value. All the same methods that are available in :class:`SortedList` are also available in :class:`SortedKeyList`. Additional methods provided: * :attr:`SortedKeyList.key` * :func:`SortedKeyList.bisect_key_left` * :func:`SortedKeyList.bisect_key_right` * :func:`SortedKeyList.irange_key` Some examples below use: >>> from operator import neg >>> neg >>> neg(1) -1 Nc||_d|_|j|_g|_g|_g|_g|_d|_||j|yy)a6Initialize sorted-key list instance. Optional `iterable` argument provides an initial iterable of values to initialize the sorted-key list. Optional `key` argument defines a callable that, like the `key` argument to Python's `sorted` function, extracts a comparison key from each value. The default is the identity function. Runtime complexity: `O(n*log(n))` >>> from operator import neg >>> skl = SortedKeyList(key=neg) >>> skl SortedKeyList([], key=) >>> skl = SortedKeyList([3, 1, 2], key=neg) >>> skl SortedKeyList([3, 2, 1], key=) :param iterable: initial values (optional) :param key: function used to extract comparison key (optional) rN) _keyr2r3r4r5_keysr6r7r8r9r:s r(r<zSortedKeyList.__init__sY0  --        LL " r,c,tj|Sr)r>r?rBs r(r?zSortedKeyList.__new__s~~c""r,c|jS)z4Function used to extract comparison key from values.)r<rEs r(r#zSortedKeyList.keysyyr,cd|_|jdd=|jdd=|jdd=|jdd=y)zURemove all values from sorted-key list. Runtime complexity: `O(n)` rN)r2r5r=r6r7rEs r(rLzSortedKeyList.clears7  KKN JJqM KKN KKNr,c6|j}|j}|j}|j|}|rt ||}|t |k(r3|dz}||j |||j ||||<n9t |||}||j||||j|||j|n5|j |g|j |g|j ||xjdz c_ y)a{Add `value` to sorted-key list. Runtime complexity: `O(log(n))` -- approximate. >>> from operator import neg >>> skl = SortedKeyList(key=neg) >>> skl.add(3) >>> skl.add(1) >>> skl.add(2) >>> skl SortedKeyList([3, 2, 1], key=) :param value: value to add to sorted-key list rNN) r5r=r6r<rrOrPrWrQr2)r"rRr5r=r6r#rSrqs r(r zSortedKeyList.adds  ii vs+Cc&k!qs ""5)c !!#&!s "5:s3s ""3.c !!#s+ LL  MM5' " LL#  MM#  Q r,c|j}|j}|j}t|||jdzkDr|j }|j}||}||}||d} ||d} ||d=||d=|d||<|j |dz| |j |dz| |j |dz| d|dd=y|r7|j|z} | r|| xxdz cc<| dz dz } | r|dxxdz cc<yyrU)r5r=r7rOr4r6rWr8) r"rSr5r=r7r6r4rX _keys_posrY half_keysrZs r(rQzSortedKeyList._expands  uSz?djjAo .[[FJJEJc Ief%D!%&)I56"%&!#B-F3K MM#'4 ( LLq) , MM#'9R= 1q  s*5MQ&M"QY1,Eq Q r,c j}j}j}t|j|rt dzj k\rO|jtt|gjjjnj}D] }|| yj|jfdtdt D|jfd|D|jd|Dt _j dd=y)atUpdate sorted-key list by adding all values from `iterable`. Runtime complexity: `O(k*log(n))` -- approximate. >>> from operator import neg >>> skl = SortedKeyList(key=neg) >>> skl.update([3, 1, 2]) >>> skl SortedKeyList([3, 2, 1], key=) :param iterable: iterable of values to add r#r\Nc3.K|] }||zywrr-r^s r(r`z'SortedKeyList.update..erarbrc3\K|]#}ttj|%ywr)rrr<)r__listr"s r(r`z'SortedKeyList.update..gs!EUT#dii/0Es),c3&K|] }|d ywrdr-res r(r`z'SortedKeyList.update..hs7ggbk7rg)r5r=r6rhr<rOr2rPrrrirGr r4rjrkr7) r"r;r5r=r6rlrmr4rIs ` @@r(rnzSortedKeyList.updateEs dii0 6{Q$))+ f%fb1  * xx!CI  ?!&q#f+u!=? ? EfEE 777K KKNr,cv|j}|sy|j|}t||}|t|k(ry|j}|j }t|||}t|}t||} ||||k7ry||||k(ry|dz }|| k(r|dz }||k(ryt||} d}>)aReturn true if `value` is an element of the sorted-key list. ``skl.__contains__(value)`` <==> ``value in skl`` Runtime complexity: `O(log(n))` >>> from operator import neg >>> skl = SortedKeyList([1, 2, 3, 4, 5], key=neg) >>> 3 in skl True :param value: search for value in sorted-key list :return: true if `value` in sorted-key list FTrNrr6r<rrOr5r= r"rRr6r#rSr5r=rqlen_keys len_sublists r(rrzSortedKeyList.__contains__os ii&#& #f+  %*c*u:%*o Sz##%c{35( 1HCk!q(? !%*o r,c|j}|sy|j|}t||}|t|k(ry|j}|j }t|||}t|}t||} ||||k7ry||||k(r|j ||y|dz }|| k(r|dz }||k(ryt||} d}P)aRemove `value` from sorted-key list if it is a member. If `value` is not a member, do nothing. Runtime complexity: `O(log(n))` -- approximate. >>> from operator import neg >>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg) >>> skl.discard(1) >>> skl.discard(0) >>> skl == [5, 4, 3, 2] True :param value: `value` to discard from sorted-key list NrNr)r6r<rrOr5r=rtrMs r(r!zSortedKeyList.discards" ii&#& #f+   %*c*u:%*o Sz##%c{35( S#& 1HCk!q(?!%*o r,cb|j}|stdj||j|}t ||}|t |k(rtdj||j }|j}t |||}t |}t ||} ||||k7rtdj|||||k(r|j||y|dz }|| k(r4|dz }||k(rtdj|t ||} d})aSRemove `value` from sorted-key list; `value` must be a member. If `value` is not a member, raise ValueError. Runtime complexity: `O(log(n))` -- approximate. >>> from operator import neg >>> skl = SortedKeyList([1, 2, 3, 4, 5], key=neg) >>> skl.remove(5) >>> skl == [4, 3, 2, 1] True >>> skl.remove(0) Traceback (most recent call last): ... ValueError: 0 not in list :param value: `value` to remove from sorted-key list :raises ValueError: if `value` is not in sorted-key list rvNrNr) r6rwrxr<rrOr5r=rtrMs r(ryzSortedKeyList.removes7*077>? ?ii&#& #f+ 077>? ? %*c*u:%*o Sz##% !4!;!;E!BCCc{35( S#& 1HCk!q(?$%8%?%?%FGG!%*o r,c|j}|j}|j}|j}||}||}||=||=|xjdzc_t |} | |j dz kDrH|d||<|r=|j|z} | dkDr|| xxdzcc<| dz dz } | dkDr|dxxdzcc<yyt |dkDre|s|dz }|dz } || j|||| j|||| d|| <||=||=||=|dd=|j| y| r |d||<y||=||=||=|dd=yr{) r5r=r6r7r2rOr4r8rjrQ) r"rSrqr5r=r6r7keys_pos lists_pos len_keys_posrZr}s r(rtzSortedKeyList._deletes :3K SM cN Q 8} 4::? +"2,F3K s*ai5MQ&M"QY1,Eaiq Q  Z!^q7D $K  uSz * 4L  s , ;r?F4Ls c s q LL  "2,F3Ks c s q r,c||j|nd}||j|nd}|j||||S)aCreate an iterator of values between `minimum` and `maximum`. Both `minimum` and `maximum` default to `None` which is automatically inclusive of the beginning and end of the sorted-key list. The argument `inclusive` is a pair of booleans that indicates whether the minimum and maximum ought to be included in the range, respectively. The default is ``(True, True)`` such that the range is inclusive of both minimum and maximum. When `reverse` is `True` the values are yielded from the iterator in reverse order; `reverse` defaults to `False`. >>> from operator import neg >>> skl = SortedKeyList([11, 12, 13, 14, 15], key=neg) >>> it = skl.irange(14.5, 11.5) >>> list(it) [14, 13, 12] :param minimum: minimum value to start iterating :param maximum: maximum value to stop iterating :param inclusive: pair of booleans :param bool reverse: yield values in reverse order :return: iterator N)min_keymax_keyrr)r< _irange_key)r"rrrrrWrXs r(rzSortedKeyList.irangeBsP8)0(;$))G$(/(;$))G$W   r,c|j}|s tdS|j}|d}d}nn|dr5t||}|t |k(r tdSt|||}n4t ||}|t |k(r tdSt |||}|t |dz } t || } n|dr>t ||} | t |k(r| dz} t || } nMt || |} n=t||} | t |k(r| dz} t || } nt|| |} |j ||| | |S)aCreate an iterator of values between `min_key` and `max_key`. Both `min_key` and `max_key` default to `None` which is automatically inclusive of the beginning and end of the sorted-key list. The argument `inclusive` is a pair of booleans that indicates whether the minimum and maximum ought to be included in the range, respectively. The default is ``(True, True)`` such that the range is inclusive of both minimum and maximum. When `reverse` is `True` the values are yielded from the iterator in reverse order; `reverse` defaults to `False`. >>> from operator import neg >>> skl = SortedKeyList([11, 12, 13, 14, 15], key=neg) >>> it = skl.irange_key(-14, -12) >>> list(it) [14, 13, 12] :param min_key: minimum key to start iterating :param max_key: maximum key to stop iterating :param inclusive: pair of booleans :param bool reverse: yield values in reverse order :return: iterator r-rrN)r6rr=rrOrr) r"rWrXrrr6r=rrrrs r( irange_keyzSortedKeyList.irange_keyfsZ88O  ?GG|%fg6c&k)8O%eGng>&vw7c&k)8O&uW~w? ?&kAoG%.)G|&vw7c&k)qLG!%.1G*5>7CG%fg6c&k)qLG!%.1G)%.'BG||GWgwHHr,cB|j|j|S)aReturn an index to insert `value` in the sorted-key list. If the `value` is already present, the insertion point will be before (to the left of) any existing values. Similar to the `bisect` module in the standard library. Runtime complexity: `O(log(n))` -- approximate. >>> from operator import neg >>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg) >>> skl.bisect_left(1) 4 :param value: insertion index of value in sorted-key list :return: index )_bisect_key_leftr<rs r(rzSortedKeyList.bisect_lefts&$$TYYu%566r,cB|j|j|S)a5Return an index to insert `value` in the sorted-key list. Similar to `bisect_left`, but if `value` is already present, the insertion point will be after (to the right of) any existing values. Similar to the `bisect` module in the standard library. Runtime complexity: `O(log(n))` -- approximate. >>> from operator import neg >>> skl = SortedList([5, 4, 3, 2, 1], key=neg) >>> skl.bisect_right(1) 5 :param value: insertion index of value in sorted-key list :return: index )_bisect_key_rightr<rs r(rzSortedKeyList.bisect_rights&%%dii&677r,c|j}|syt||}|t|k(r |jSt|j||}|j ||S)aReturn an index to insert `key` in the sorted-key list. If the `key` is already present, the insertion point will be before (to the left of) any existing keys. Similar to the `bisect` module in the standard library. Runtime complexity: `O(log(n))` -- approximate. >>> from operator import neg >>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg) >>> skl.bisect_key_left(-1) 4 :param key: insertion index of key in sorted-key list :return: index r)r6rrOr2r=rr"r#r6rSrqs r(bisect_key_leftzSortedKeyList.bisect_key_leftsZ&&#& #f+ 99 $**S/3/yyc""r,c|j}|syt||}|t|k(r |jSt|j||}|j ||S)a4Return an index to insert `key` in the sorted-key list. Similar to `bisect_key_left`, but if `key` is already present, the insertion point will be after (to the right of) any existing keys. Similar to the `bisect` module in the standard library. Runtime complexity: `O(log(n))` -- approximate. >>> from operator import neg >>> skl = SortedList([5, 4, 3, 2, 1], key=neg) >>> skl.bisect_key_right(-1) 5 :param key: insertion index of key in sorted-key list :return: index r)r6rrOr2r=rras r(bisect_key_rightzSortedKeyList.bisect_key_right sZ&63' #f+ 99 4::c?C0yyc""r,c|j}|sy|j|}t||}|t|k(ry|j}|j }t|||}d}t|} t||} ||||k7r|S||||k(r|dz }|dz }|| k(r|dz }|| k(r|St||} d}D)adReturn number of occurrences of `value` in the sorted-key list. Runtime complexity: `O(log(n))` -- approximate. >>> from operator import neg >>> skl = SortedKeyList([4, 4, 4, 4, 3, 3, 3, 2, 2, 1], key=neg) >>> skl.count(2) 2 :param value: value to count in sorted-key list :return: count rrNrL) r"rRr6r#rSr5r=rqrrNrOs r(rzSortedKeyList.count3 sii&#& #f+  %*c*u:%*o Sz##% c{35(  1HCk!q(? L!%*o r,c<|j||jS)zReturn a shallow copy of the sorted-key list. Runtime complexity: `O(n)` :return: new sorted-key list rF)rr<rEs r(rzSortedKeyList.copya s~~d ~22r,cp|j}|stdj||d}|dkr||z }|dkrd}||}|dkr||z }||kDr|}||krtdj||j}|j |}t ||}|t |k(rtdj||dz}|j}|j} t | ||} t | } t | |} | || |k7rtdj|||| |k(r&|j|| } || cxkr|kr| S| |kDrn?| dz } | | k(r4|dz }|| k(rtdj|t | |} d} tdj|)aReturn first index of value in sorted-key list. Raise ValueError if `value` is not present. Index must be between `start` and `stop` for the `value` to be considered present. The default value, None, for `start` and `stop` indicate the beginning and end of the sorted-key list. Negative indices are supported. Runtime complexity: `O(log(n))` -- approximate. >>> from operator import neg >>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg) >>> skl.index(2) 3 >>> skl.index(0) Traceback (most recent call last): ... ValueError: 0 is not in list :param value: value in sorted-key list :param int start: start index (default None, start of sorted-key list) :param int stop: stop index (default None, end of sorted-key list) :return: index of value :raises ValueError: if value is not present rrrN) r2rwrxr6r<rrOr5r=r)r"rRrrr2r6r#rSr5r=rqrNrOrs r(rzSortedKeyList.indexn s:yy3::5AB B =E 19 TME 19E <D !8 DLD $;D 5=3::5AB Bii&#& #f+ 3::5AB B   %*c*u:%*o Sz##% !7!>!>u!EFFc{35(iiS)C'4'J(4Z 1HCk!q(?$%;%B%B5%IJJ!%*o "/66u=>>r,ctt|jg}|j||j ||j S)a)Return new sorted-key list containing all values in both sequences. ``skl.__add__(other)`` <==> ``skl + other`` Values in `other` do not need to be in sorted-key order. Runtime complexity: `O(n*log(n))` >>> from operator import neg >>> skl1 = SortedKeyList([5, 4, 3], key=neg) >>> skl2 = SortedKeyList([2, 1, 0], key=neg) >>> skl1 + skl2 SortedKeyList([5, 4, 3, 2, 1, 0], key=) :param other: other iterable :return: new sorted-key list rF)rrr5rjrr<rs r(rzSortedKeyList.__add__ s9&dkk2. e~~f$))~44r,cxtt|jg|z}|j||jS)aReturn new sorted-key list with `num` shallow copies of values. ``skl.__mul__(num)`` <==> ``skl * num`` Runtime complexity: `O(n*log(n))` >>> from operator import neg >>> skl = SortedKeyList([3, 2, 1], key=neg) >>> skl * 2 SortedKeyList([3, 3, 2, 2, 1, 1], key=) :param int num: count of shallow copies :return: new sorted-key list rF)rrr5rr<rs r(rzSortedKeyList.__mul__ s2 dkk2.4~~f$))~44r,cjtt|jg}t|||jffSr)rrr5rr#rs r(r zSortedKeyList.__reduce__ s,dkk2.T VTXX.//r,cxt|j}dj|t||jS)zReturn string representation of sorted-key list. ``skl.__repr__()`` <==> ``repr(skl)`` :return: string representation z{0}({1!r}, key={2!r}))rrrxrr<)r" type_names r(r zSortedKeyList.__repr__ s0J'' &--idTYYOOr,c |jdk\sJt|jt|jcxk(rt|jk(sJJ|j t d|jDk(sJ|jD],}tdt|D]}||dz ||krJ.tdt|jD],}|j|dz d|j|dkr,Jt|j|jD]H\}}t|t|k(sJt||D]\}}|j||k(rJJtt|jD]&}|j||j|dk(r&J|jdz t fd|jDsJ|jdz }tdt|jdz D]}t|j||k\rJ|jrw|j |jdk(sJt|j|jt|jzk(sJtt|jD];}|j|j|z}|t|j|k(r;Jt|jD]}|dzdz} | t|jk\r|j|dk(r6J| dzt|jk(r"|j||j| k(rsJ|j| |j| dzz} | |j|k(rJyy#tjtj t#d|j t#d |jt#d |jt#d t|jt#d |jt#d t|jt#d|jt#dt|jt#d|jt#dt|jt#d|jxYw)zRCheck invariants of sorted-key list. Runtime complexity: `O(n)` r\c32K|]}t|ywrrres r(r`z'SortedKeyList._check.. rrrNrVrc3:K|]}t|kywrrrs r(r`z'SortedKeyList._check..( rrrrOrHrrrrrrNkeysrrN)r4rOr6r5r=r2rrkrr<rr7r8rr r!r"r#) r"rfrS val_sublist key_sublistrmr#rYr$rZr%rs @r(r&zSortedKeyList._check sS J ::? "?t{{#s4;;'7J3tzz?J JJ JJ99#L #L LL LL :: < CL1S0001 1S-. ?{{3'4::c?2+>>>> ? ZZ1_FIT[[II II ::?DQDKK 01 45 54;;s+,444 5{{yyDKKN2224;;'4<<#dkk:J+JJJJ!T[[!129C;;t||c'9:D3t{{3'7#88889 !.=C AXNEDKK 00#{{3/1444c$++&66#{{3/4;;u3EEEE$(KK$6UQY9O$O (DKK,<<<<=*    SZZ 0 % # &$** % (DLL ) +s4;;/ 0 '4;; ' +s4;;/ 0 '4;; ' *c$**o . &$** % +s4;;/ 0 '4;; ' sIB:O >AO A(O 7AO BO CO A O rs & 44,,666 69 %%+$!,% <~~B2 xJxv"iQ6556 +*+ ,+,s6B ,B3:C B0/B03 CC CC