o
    ƒôj¸²  ã                   @   sH  d Z ddlZddlmZmZ ddlmZ ddlmZ ddl	m
Z
 ddlmZmZ ddlmZmZ dd	lmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z" dd
l#m$Z$m%Z%m&Z&m'Z' ddl(m)Z)m*Z*m+Z,m-Z-m.Z.m/Z/ ddlm0Z0m1Z1m2Z2m3Z3 ddl4m5Z5 g d¢Z6e7ƒ Z8z
ddlm9Z9m:Z: W n e;yž   dZ<Y nw dZ<dd„ Z=d§dd„Z>dd„ Z?d¨dd„Z@d¨dd„ZAd¨dd„ZBeCfdd„ZDd d!„ ZEeEZFd"d#„ ZGd$d%„ ZHzdd&l#mIZJ W n e;yä   eHZJY nw d'd(„ ZKd¨d)d*„ZLd+d,„ Zd©d.d/„ZMd0d1„ ZNd2d3„ ZOd4d5„ ZPd¨d6d7„ZQd¨d8d9„ZRdªd:d;„ZSd¨d<d=„ZTd«d>d?„ZUd@dAœdBdC„ZVd¨dDdE„ZWdFdG„ ZXdHdI„ ZYdJdK„ ZZdLdM„ Z[dNdO„ Z\dPdQ„ Z]dRdS„ Z^dTdU„ Z_dVdW„ Z`dXdY„ ZadZd[„ Zbd\d]„ Zcd¬d^d_„Zdd`da„ Zeddbœdcdd„Zfe5dek�rddflmgZh ddbœdgdh„Zgefj eg_ nefZgdidj„ Ziejekffdkdl„Zldmdn„ Zmdodp„ Zndqdr„ Zodsdt„ ZpeqeeduƒƒZrdvdw„ Zsdxdy„ Ztdzd{„ Zud|d}„ Zvd~d„ Zwg d€¢Zxed�d‚„ ƒZydƒd„„ Zze {¡ j0Z|d…d†„ Z}d‡dˆ„ Z~d‰dŠ„ Zd‹dŒ„ Z€d�dŽ„ Z�d�d�„ Z‚dd‘œd’d“„Zƒd”d•„ Z„dd‘œd–d—„Z…d˜d™„ Z†dd‘œdšd›„Z‡dœd�„ Zˆdd‘œdždŸ„Z‰e
ddd �G d¡d¢„ d¢ƒƒZŠdd‘œd£d¤„Z‹d¥d¦„ ZŒdS )­a  Imported from the recipes section of the itertools documentation.

All functions taken from the recipes section of the itertools library docs
[1]_.
Some backward-compatible usability improvements have been made.

.. [1] http://docs.python.org/library/itertools.html#recipes

é    N)Úbisect_leftÚinsort)Údeque©Úsuppress)Ú	dataclass)Ú	lru_cacheÚreduce)ÚheappushÚheappushpop)Ú
accumulateÚchainÚcombinationsÚcompressÚcountÚcycleÚfilterfalseÚgroupbyÚisliceÚpairwiseÚproductÚrepeatÚstarmapÚ	takewhileÚteeÚzip_longest)ÚprodÚcombÚisqrtÚgcd)ÚmulÚgetitemÚindexÚis_Ú
itemgetterÚtruediv)Ú	randrangeÚsampleÚchoiceÚshuffle)Ú
hexversion)8ÚStatsÚ	all_equalÚbatchedÚbefore_and_afterÚconsumeÚconvolveÚ
dotproductÚ
first_trueÚfactorÚflattenÚgrouperÚis_primeÚiter_exceptÚ
iter_indexÚloopsÚmatmulÚmultinomialÚncyclesÚnthÚnth_combinationÚpadnoneÚpad_noner   Ú	partitionÚpolynomial_evalÚpolynomial_from_rootsÚpolynomial_derivativeÚpowersetÚprependÚquantifyÚreshapeÚ#random_combination_with_replacementÚrandom_combinationÚrandom_derangementÚrandom_permutationÚrandom_productÚ
repeatfuncÚ
roundrobinÚrunning_maxÚrunning_meanÚrunning_medianÚrunning_minÚrunning_statisticsÚsieveÚsliding_windowÚ	subslicesÚsum_of_squaresÚtabulateÚtailÚtakeÚtotientÚ	transposeÚ
triplewiseÚuniqueÚunique_everseenÚunique_justseen)Úheappush_maxÚheappushpop_maxFTc                 C   ó   t t|| ƒƒS )zóReturn first *n* items of the *iterable* as a list.

        >>> take(3, range(10))
        [0, 1, 2]

    If there are fewer than *n* items in the iterable, all of them are
    returned.

        >>> take(10, range(3))
        [0, 1, 2]

    )Úlistr   )ÚnÚiterable© rh   úi/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/more_itertools/recipes.pyr[   q   s   r[   c                 C   s   t | t|ƒƒS )a©  Return an iterator over the results of ``func(start)``,
    ``func(start + 1)``, ``func(start + 2)``...

    *func* should be a function that accepts one integer argument.

    If *start* is not specified it defaults to 0. It will be incremented each
    time the iterator is advanced.

        >>> square = lambda x: x ** 2
        >>> iterator = tabulate(square, -3)
        >>> take(4, iterator)
        [9, 4, 1, 0]

    )Úmapr   )ÚfunctionÚstartrh   rh   ri   rY   �   s   rY   c                 C   sF   zt |ƒ}W n ty   tt|| d�ƒ Y S w t|td||  ƒdƒS )zƒReturn an iterator over the last *n* items of *iterable*.

    >>> t = tail(3, 'ABCDEFG')
    >>> list(t)
    ['E', 'F', 'G']

    ©Úmaxlenr   N)ÚlenÚ	TypeErrorÚiterr   r   Úmax)rf   rg   Úsizerh   rh   ri   rZ   “   s   ÿrZ   c                 C   s.   |du rt | dd� dS tt| ||ƒdƒ dS )aX  Advance *iterable* by *n* steps. If *n* is ``None``, consume it
    entirely.

    Efficiently exhausts an iterator without returning values. Defaults to
    consuming the whole iterator, but an optional second argument may be
    provided to limit consumption.

        >>> i = (x for x in range(10))
        >>> next(i)
        0
        >>> consume(i, 3)
        >>> next(i)
        4
        >>> consume(i)
        >>> next(i)
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        StopIteration

    If the iterator has fewer items remaining than the provided limit, the
    whole iterator will be consumed.

        >>> i = (x for x in range(3))
        >>> consume(i, 5)
        >>> next(i)
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        StopIteration

    Nr   rm   )r   Únextr   )Úiteratorrf   rh   rh   ri   r/   £   s    r/   c                 C   s   t t| |dƒ|ƒS )z…Returns the nth item or a default value.

    >>> l = range(10)
    >>> nth(l, 3)
    3
    >>> nth(l, 20, "zebra")
    'zebra'

    N)rt   r   )rg   rf   Údefaultrh   rh   ri   r=   Ë   s   
r=   c                 C   s,   t | |ƒ}|D ]}|D ]}  dS  dS dS )a§  
    Returns ``True`` if all the elements are equal to each other.

        >>> all_equal('aaaa')
        True
        >>> all_equal('aaab')
        False

    A function that accepts a single argument and returns a transformed version
    of each input item can be specified with *key*:

        >>> all_equal('AaaA', key=str.casefold)
        True
        >>> all_equal([1, 2, 3], key=lambda x: x < 10)
        True

    FT)r   )rg   Úkeyru   ÚfirstÚsecondrh   rh   ri   r,   Ø   s   
r,   c                 C   rd   )zcReturn the how many times the predicate is true.

    >>> quantify([True, False, True])
    2

    )Úsumrj   )rg   Úpredrh   rh   ri   rG   ò   s   rG   c                 C   s   t | tdƒƒS )a   Returns the sequence of elements and then returns ``None`` indefinitely.

        >>> take(5, pad_none(range(3)))
        [0, 1, 2, None, None]

    Useful for emulating the behavior of the built-in :func:`map` function.

    See also :func:`padded`.

    N)r   r   ©rg   rh   rh   ri   r@   ü   s   r@   c                 C   s   t  tt| ƒ|ƒ¡S )zvReturns the sequence elements *n* times

    >>> list(ncycles(["a", "b"], 3))
    ['a', 'b', 'a', 'b', 'a', 'b']

    )r   Úfrom_iterabler   Útuple©rg   rf   rh   rh   ri   r<     s   r<   c                 C   s   t tt| |ƒƒS )zãReturns the dot product of the two iterables.

    >>> dotproduct([10, 15, 12], [0.65, 0.80, 1.25])
    33.5
    >>> 10 * 0.65 + 15 * 0.80 + 12 * 1.25
    33.5

    In Python 3.12 and later, use ``math.sumprod()`` instead.
    )rz   rj   r    )Úvec1Úvec2rh   rh   ri   r1     s   
r1   )Úsumprodc                 C   s
   t  | ¡S )zÜReturn an iterator flattening one level of nesting in a list of lists.

        >>> list(flatten([[0, 1], [2, 3]]))
        [0, 1, 2, 3]

    See also :func:`collapse`, which can flatten multiple levels of nesting.

    )r   r}   )Zlist_of_listsrh   rh   ri   r4   +  s   
	r4   c                 G   s&   |du rt | t|ƒƒS t | t||ƒƒS )aK  Call *function* with *args* repeatedly, returning an iterable over the
    results.

    If *times* is specified, the iterable will terminate after that many
    repetitions:

        >>> from operator import add
        >>> times = 4
        >>> args = 3, 5
        >>> list(repeatfunc(add, times, *args))
        [8, 8, 8, 8]

    If *times* is ``None`` the iterable will not terminate:

        >>> from random import randrange
        >>> times = None
        >>> args = 1, 11
        >>> take(6, repeatfunc(randrange, times, *args))  # doctest:+SKIP
        [2, 4, 8, 1, 8, 4]

    N)r   r   )rk   ÚtimesÚargsrh   rh   ri   rN   7  s   rN   c                 C   s   t | ƒS )z²
    Wrapper for :func:`itertools.pairwise`.

    .. warning::

       This function is deprecated as of version 11.0.0. It will be removed in a future
       major release.
    )Úitertools_pairwiser|   rh   rh   ri   r   R  s   	r   Úfillc                 C   sX   t | ƒg| }| dkr t|d|iŽS  dkr  t|ddiŽS dkr't|Ž S 	 tdƒ‚)a²  Group elements from *iterable* into fixed-length groups of length *n*.

    >>> list(grouper('ABCDEF', 3))
    [('A', 'B', 'C'), ('D', 'E', 'F')]

    The keyword arguments *incomplete* and *fillvalue* control what happens for
    iterables whose length is not a multiple of *n*.

    When *incomplete* is `'fill'`, the last group will contain instances of
    *fillvalue*.

    >>> list(grouper('ABCDEFG', 3, incomplete='fill', fillvalue='x'))
    [('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')]

    When *incomplete* is `'ignore'`, the last group will not be emitted.

    >>> list(grouper('ABCDEFG', 3, incomplete='ignore', fillvalue='x'))
    [('A', 'B', 'C'), ('D', 'E', 'F')]

    When *incomplete* is `'strict'`, a `ValueError` will be raised.

    >>> iterator = grouper('ABCDEFG', 3, incomplete='strict')
    >>> list(iterator)  # doctest: +IGNORE_EXCEPTION_DETAIL
    Traceback (most recent call last):
    ...
    ValueError

    r†   Ú	fillvalueÚstrictTÚignorez Expected fill, strict, or ignore)rq   r   ÚzipÚ
ValueError)rg   rf   Ú
incompleter‡   Ú	iteratorsrh   rh   ri   r5   ^  s   

r5   c                  g   sD   � t t| ƒ}tt| ƒddƒD ]}tt||ƒƒ}t t|ƒE dH  qdS )aG  Visit input iterables in a cycle until each is exhausted.

        >>> list(roundrobin('ABC', 'D', 'EF'))
        ['A', 'D', 'E', 'B', 'F', 'C']

    This function produces the same output as :func:`interleave_longest`, but
    may perform better for some inputs (in particular when the number of
    iterables is small).

    r   éÿÿÿÿN)rj   rq   Úrangero   r   r   rt   )Ú	iterablesr�   Z
num_activerh   rh   ri   rO   ‡  s   €
þrO   c                    sB   ˆdu rt ‰t|ƒ‰tƒ ‰ tƒ ‰‡ ‡‡‡fdd„}|ˆ ƒ|ˆƒfS )a¯  
    Returns a 2-tuple of iterables derived from the input iterable.
    The first yields the items that have ``pred(item) == False``.
    The second yields the items that have ``pred(item) == True``.

        >>> is_odd = lambda x: x % 2 != 0
        >>> iterable = range(10)
        >>> even_items, odd_items = partition(is_odd, iterable)
        >>> list(even_items), list(odd_items)
        ([0, 2, 4, 6, 8], [1, 3, 5, 7, 9])

    If *pred* is None, :func:`bool` is used.

        >>> iterable = [0, 1, False, True, '', ' ']
        >>> false_items, true_items = partition(None, iterable)
        >>> list(false_items), list(true_items)
        ([0, False, ''], [1, True, ' '])

    Nc                 3   s>   � 	 | r|   ¡ V  | sˆD ]}ˆ|ƒrˆnˆ  |¡  nd S q©N)ÚpopleftÚappend)ÚqueueÚvalue©Zfalse_queueru   r{   Z
true_queuerh   ri   Úgen´  s   €
ÿùzpartition.<locals>.gen)Úboolrq   r   )r{   rg   r—   rh   r–   ri   rA   ™  s   
rA   c                    s,   t | ƒ‰ t ‡ fdd„ttˆ ƒd ƒD ƒ¡S )a1  Yields all possible subsets of the iterable.

        >>> list(powerset([1, 2, 3]))
        [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]

    :func:`powerset` will operate on iterables that aren't :class:`set`
    instances, so repeated elements in the input will produce repeated elements
    in the output.

        >>> seq = [1, 1, 0]
        >>> list(powerset(seq))
        [(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)]

    For a variant that efficiently yields actual :class:`set` instances, see
    :func:`powerset_of_sets`.
    c                 3   ó   � | ]}t ˆ |ƒV  qd S r‘   )r   )Ú.0Úr©Úsrh   ri   Ú	<genexpr>Ó  ó   € zpowerset.<locals>.<genexpr>é   )re   r   r}   r�   ro   r|   rh   rœ   ri   rE   Á  s   $rE   c                 c   sd   � t ƒ }|du rt|j| ƒD ]
}| |¡ |V  qdS | D ]}||ƒ}||vr/| |¡ |V  qdS )a  Yield unique elements, preserving order. Remember all elements ever seen.

        >>> list(unique_everseen('AAAABBBCCDAABBB'))
        ['A', 'B', 'C', 'D']
        >>> list(unique_everseen('ABBCcAD', str.casefold))
        ['A', 'B', 'C', 'D']

    Raises ``TypeError`` for unhashable items.

    Some unhashable objects can be converted to hashable objects
    using the *key* parameter:

    * For ``list`` objects, try ``key=tuple``.
    * For ``set`` objects, try ``key=frozenset``.
    * For ``dict`` objects, try ``key=lambda x: frozenset(x.items())``
      or in Python 3.15 and later, set ``key=frozendict``.

    Alternatively, consider the ``unique()`` itertool recipe.  It sorts
    the data and then uses equality to eliminate duplicates.  Hashability
    is not required.

    N)Úsetr   Ú__contains__Úadd)rg   rw   ÚseenÚelementÚkrh   rh   ri   r`   Ö  s   €
þ
€ür`   c                 C   s4   |du rt tdƒt| ƒƒS t tt tdƒt| |ƒƒƒS )záYields elements in order, ignoring serial duplicates

    >>> list(unique_justseen('AAAABBBCCDAABBB'))
    ['A', 'B', 'C', 'D', 'A', 'B']
    >>> list(unique_justseen('ABBCcAD', str.lower))
    ['A', 'B', 'C', 'A', 'D']

    Nr   r    )rj   r$   r   rt   )rg   rw   rh   rh   ri   ra   ú  s   	ra   c                 C   s   t | ||d�}t||d�S )a°  Yields unique elements in sorted order.

    >>> list(unique([[1, 2], [3, 4], [1, 2]]))
    [[1, 2], [3, 4]]

    *key* and *reverse* are passed to :func:`sorted`.

    >>> list(unique('ABBcCAD', str.casefold))
    ['A', 'B', 'c', 'D']
    >>> list(unique('ABBcCAD', str.casefold, reverse=True))
    ['D', 'c', 'B', 'A']

    The elements in *iterable* need not be hashable, but they must be
    comparable for sorting to work.
    )rw   Úreverse)rw   )Úsortedra   )rg   rw   r§   Z	sequencedrh   rh   ri   r_   	  s   r_   c                 c   s<   � t |ƒ� |dur|ƒ V  	 | ƒ V  q1 sw   Y  dS )aÝ  Yields results from a function repeatedly until an exception is raised.

    Converts a call-until-exception interface to an iterator interface.
    Like ``iter(function, sentinel)``, but uses an exception instead of a sentinel
    to end the loop.

        >>> l = [0, 1, 2]
        >>> list(iter_except(l.pop, IndexError))
        [2, 1, 0]

    Multiple exceptions can be specified as a stopping condition:

        >>> l = [1, 2, 3, '...', 4, 5, 6]
        >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
        [7, 6, 5]
        >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
        [4, 3, 2]
        >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError)))
        []

    Nr   )rk   Ú	exceptionrx   rh   rh   ri   r7     s   €
ÿýr7   c                 C   s   t t|| ƒ|ƒS )a�  
    Returns the first true value in the iterable.

    If no true value is found, returns *default*

    If *pred* is not None, returns the first item for which
    ``pred(item) == True`` .

        >>> first_true(range(10))
        1
        >>> first_true(range(10), pred=lambda x: x > 5)
        6
        >>> first_true(range(10), default='missing', pred=lambda x: x > 9)
        'missing'

    )rt   Úfilter)rg   rv   r{   rh   rh   ri   r2   :  s   r2   r    ©r   c                 G   s    t tt |ƒƒ|  }t tt|ƒƒS )aÍ  Draw an item at random from each of the input iterables.

        >>> random_product('abc', range(4), 'XYZ')  # doctest:+SKIP
        ('c', 3, 'Z')

    If *repeat* is provided as a keyword argument, that many items will be
    drawn from each iterable.

        >>> random_product('abcd', range(4), repeat=2)  # doctest:+SKIP
        ('a', 2, 'd', 3)

    This equivalent to taking a random selection from
    ``itertools.product(*args, repeat=repeat)``.

    )r~   rj   r(   )r   r�   Úpoolsrh   rh   ri   rM   N  s   rM   c                 C   s*   t | ƒ}|du rt|ƒn|}t t||ƒƒS )ab  Return a random *r* length permutation of the elements in *iterable*.

    If *r* is not specified or is ``None``, then *r* defaults to the length of
    *iterable*.

        >>> random_permutation(range(5))  # doctest:+SKIP
        (3, 4, 0, 1, 2)

    This equivalent to taking a random selection from
    ``itertools.permutations(iterable, r)``.

    N)r~   ro   r'   )rg   r›   Úpoolrh   rh   ri   rL   b  s   rL   c                    s8   t | ƒ‰ tˆ ƒ}ttt|ƒ|ƒƒ}t ‡ fdd„|D ƒƒS )zÿReturn a random *r* length subsequence of the elements in *iterable*.

        >>> random_combination(range(5), 3)  # doctest:+SKIP
        (2, 3, 4)

    This equivalent to taking a random selection from
    ``itertools.combinations(iterable, r)``.

    c                    ó   g | ]}ˆ | ‘qS rh   rh   ©rš   Úi©r­   rh   ri   Ú
<listcomp>�  ó    z&random_combination.<locals>.<listcomp>)r~   ro   r¨   r'   r�   )rg   r›   rf   Úindicesrh   r±   ri   rJ   t  s   
rJ   c                    s@   t | ƒ‰tˆƒ‰ t‡ fdd„t|ƒD ƒƒ}t ‡fdd„|D ƒƒS )aS  Return a random *r* length subsequence of elements in *iterable*,
    allowing individual elements to be repeated.

        >>> random_combination_with_replacement(range(3), 5) # doctest:+SKIP
        (0, 0, 1, 2, 2)

    This equivalent to taking a random selection from
    ``itertools.combinations_with_replacement(iterable, r)``.

    c                 3   s   � | ]}t ˆ ƒV  qd S r‘   )r&   r¯   ©rf   rh   ri   rž   ‘  s   € z6random_combination_with_replacement.<locals>.<genexpr>c                    r®   rh   rh   r¯   r±   rh   ri   r²   ’  r³   z7random_combination_with_replacement.<locals>.<listcomp>)r~   ro   r¨   r�   )rg   r›   r´   rh   )rf   r­   ri   rI   „  s   rI   c                 C   s¾   t | ƒ}t|ƒ}t||ƒ}|dk r||7 }d|  kr |k s#t‚ t‚g }|r[|| | |d |d }}}||krP||8 }|||  | |d }}||ks;| |d|  ¡ |s't |ƒS )aá  Equivalent to ``list(combinations(iterable, r))[index]``.

    The subsequences of *iterable* that are of length *r* can be ordered
    lexicographically. :func:`nth_combination` computes the subsequence at
    sort position *index* directly, without computing the previous
    subsequences.

        >>> nth_combination(range(5), 3, 5)
        (0, 3, 4)

    ``ValueError`` will be raised If *r* is negative.
    ``IndexError`` will be raised if the given *index* is invalid.
    r   r    rŽ   )r~   ro   r   Ú
IndexErrorr“   )rg   r›   r"   r­   rf   ÚcÚresultrh   rh   ri   r>   •  s&   
ÿ þûr>   c                 C   s   t | g|ƒS )a  Yield *value*, followed by the elements in *iterable*.

        >>> value = '0'
        >>> iterable = ['1', '2', '3']
        >>> list(prepend(value, iterable))
        ['0', '1', '2', '3']

    To prepend multiple values, see :func:`itertools.chain`
    or :func:`value_chain`.

    )r   )r•   rg   rh   rh   ri   rF   ·  s   rF   c                 c   sb   � t |ƒddd… }t|ƒ}tdg|d�| }t| td|d ƒƒD ]}| |¡ t||ƒV  q!dS )u}  Discrete linear convolution of two iterables.
    Equivalent to polynomial multiplication.

    For example, multiplying ``(xÂ² -x - 20)`` by ``(x - 3)``
    gives ``(xÂ³ -4xÂ² -17x + 60)``.

        >>> list(convolve([1, -1, -20], [1, -3]))
        [1, -4, -17, 60]

    Examples of popular kinds of kernels:

    * The kernel ``[0.25, 0.25, 0.25, 0.25]`` computes a moving average.
      For image data, this blurs the image and reduces noise.
    * The kernel ``[1/2, 0, -1/2]`` estimates the first derivative of
      a function evaluated at evenly spaced inputs.
    * The kernel ``[1, -2, 1]`` estimates the second derivative of a
      function evaluated at evenly spaced inputs.

    Convolutions are mathematically commutative; however, the inputs are
    evaluated differently.  The signal is consumed lazily and can be
    infinite. The kernel is fully consumed before the calculations begin.

    Supports all numeric types: int, float, complex, Decimal, Fraction.

    References:

    * Article:  https://betterexplained.com/articles/intuitive-convolution/
    * Video by 3Blue1Brown:  https://www.youtube.com/watch?v=KuXjwB4LzSA

    NrŽ   r   rm   r    )r~   ro   r   r   r   r“   Ú_sumprod)ÚsignalÚkernelrf   ÚwindowÚxrh   rh   ri   r0   Æ  s   €#
þr0   c                 C   s(   t |ƒ\}}tt| |ƒt|ƒƒ}||fS )aÆ  A variant of :func:`takewhile` that allows complete access to the
    remainder of the iterator.

         >>> it = iter('ABCdEfGhI')
         >>> all_upper, remainder = before_and_after(str.isupper, it)
         >>> ''.join(all_upper)
         'ABC'
         >>> ''.join(remainder) # takewhile() would lose the 'd'
         'dEfGhI'

    Note that the first iterator must be fully consumed before the second
    iterator can generate valid results.
    )r   r   r   rŠ   )Ú	predicateÚitÚtruesÚafterrh   rh   ri   r.   ñ  s   r.   c                 C   s:   t | dƒ\}}}t|dƒ t|dƒ t|dƒ t|||ƒS )z�Return overlapping triplets from *iterable*.

    >>> list(triplewise('ABCDE'))
    [('A', 'B', 'C'), ('B', 'C', 'D'), ('C', 'D', 'E')]

    é   N)r   rt   rŠ   )rg   Út1Út2Út3rh   rh   ri   r^     s
   	


r^   c                 C   s6   t | |ƒ}t|ƒD ]\}}tt|||ƒd ƒ q	t|Ž S r‘   )r   Ú	enumeratert   r   rŠ   )rg   rf   r�   r°   ru   rh   rh   ri   Ú_sliding_window_islice  s   
rÇ   c                 c   sB   � t | ƒ}tt||d ƒ|d�}|D ]}| |¡ t|ƒV  qd S )Nr    rm   )rq   r   r   r“   r~   )rg   rf   ru   r¼   r½   rh   rh   ri   Ú_sliding_window_deque  s   €
þrÈ   c                 C   sR   |dkr	t | |ƒS |dkrt| |ƒS |dkrt| ƒS |dkr"t| ƒS td|› �ƒ‚)aY  Return a sliding window of width *n* over *iterable*.

        >>> list(sliding_window(range(6), 4))
        [(0, 1, 2, 3), (1, 2, 3, 4), (2, 3, 4, 5)]

    If *iterable* has fewer than *n* items, then nothing is yielded:

        >>> list(sliding_window(range(3), 4))
        []

    For a variant with more features, see :func:`windowed`.
    é   é   r    zn should be at least one, not )rÈ   rÇ   r   rŠ   r‹   r   rh   rh   ri   rV   %  s   

rV   c                 C   s4   t | ƒ}ttttt|ƒd ƒdƒƒ}ttt|ƒ|ƒS )zþReturn all contiguous non-empty subslices of *iterable*.

        >>> list(subslices('ABC'))
        [['A'], ['A', 'B'], ['A', 'B', 'C'], ['B'], ['B', 'C'], ['C']]

    This is similar to :func:`substrings`, but emits items in a different
    order.
    r    rÊ   )	re   r   Úslicer   r�   ro   rj   r!   r   )rg   ÚseqÚslicesrh   rh   ri   rW   >  s   	rW   c                 C   s(   dg}| D ]}t t|d| fƒƒ}q|S )uk  Compute a polynomial's coefficients from its roots.

    >>> roots = [5, -4, 3]            # (x - 5) * (x + 4) * (x - 3)
    >>> polynomial_from_roots(roots)  # xÂ³ - 4 xÂ² - 17 x + 60
    [1, -4, -17, 60]

    Note that polynomial coefficients are specified in descending power order.

    Supports all numeric types: int, float, complex, Decimal, Fraction.
    r    )re   r0   )ÚrootsÚpolyÚrootrh   rh   ri   rC   L  s   rC   c                 c   s¤   � t | ddƒ}|du r(t| ||ƒ}t||ƒD ]\}}||u s"||kr%|V  qdS |du r0t| ƒn|}|d }ttƒ� 	 |||d |ƒ }V  q<1 sKw   Y  dS )aû  Yield the index of each place in *iterable* that *value* occurs,
    beginning with index *start* and ending before index *stop*.


    >>> list(iter_index('AABCADEAF', 'A'))
    [0, 1, 4, 7]
    >>> list(iter_index('AABCADEAF', 'A', 1))  # start index is inclusive
    [1, 4, 7]
    >>> list(iter_index('AABCADEAF', 'A', 1, 7))  # stop index is not inclusive
    [1, 4]

    The behavior for non-scalar *values* matches the built-in Python types.

    >>> list(iter_index('ABCDABCD', 'AB'))
    [0, 4]
    >>> list(iter_index([0, 1, 2, 3, 0, 1, 2, 3], [0, 1]))
    []
    >>> list(iter_index([[0, 1], [2, 3], [0, 1], [2, 3]], [0, 1]))
    [0, 2]

    See :func:`locate` for a more general means of finding the indexes
    associated with particular values.

    r"   Nr    )Úgetattrr   rÆ   ro   r   r‹   )rg   r•   rl   ÚstopÚ	seq_indexru   r°   r¥   rh   rh   ri   r8   b  s    €€þ
ÿÿr8   c                 c   s¦   � | dkrdV  d}t dƒ| d  }t|d|t| ƒd d�D ])}t|d||| ƒE dH  ttt|| | || ƒƒƒ||| | || …< || }qt|d|ƒE dH  dS )zeYield the primes less than n.

    >>> list(sieve(30))
    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

    rÊ   rÂ   )r   r    r    )rÒ   N)Ú	bytearrayr8   r   Úbytesro   r�   )rf   rl   ÚdataÚprh   rh   ri   rU   ‹  s   €
.
rU   ©rˆ   c                c   sd   � |dk r	t dƒ‚t| ƒ}tt||ƒƒ }r0|r"t|ƒ|kr"t dƒ‚|V  tt||ƒƒ }sdS dS )aŽ  Batch data into tuples of length *n*. If the number of items in
    *iterable* is not divisible by *n*:
    * The last batch will be shorter if *strict* is ``False``.
    * :exc:`ValueError` will be raised if *strict* is ``True``.

    >>> list(batched('ABCDEFG', 3))
    [('A', 'B', 'C'), ('D', 'E', 'F'), ('G',)]

    On Python 3.13 and above, this is an alias for :func:`itertools.batched`.
    r    zn must be at least onezbatched(): incomplete batchN)r‹   rq   r~   r   ro   )rg   rf   rˆ   ru   Úbatchrh   rh   ri   Ú_batched   s   €ýrÚ   i¢ )r-   c                C   s   t | ||d�S )NrØ   )Úitertools_batched)rg   rf   rˆ   rh   rh   ri   r-   ·  s   r-   c                 C   s   t | ddiŽS )a  Swap the rows and columns of the input matrix.

    >>> list(transpose([(1, 2, 3), (11, 22, 33)]))
    [(1, 11), (2, 22), (3, 33)]

    The caller should ensure that the dimensions of the input are compatible.
    If the input is empty, no output will be produced.
    rˆ   T)rŠ   )Úmatrixrh   rh   ri   r]   ¿  s   	r]   c                 C   s,   zt | ƒ W n
 ty   Y dS w t| |ƒS )z.Scalars are bytes, strings, and non-iterables.T)rq   rp   Ú
isinstance)r•   Z
stringlikerh   rh   ri   Ú
_is_scalarË  s   ÿ
rÞ   c                 C   sR   t | ƒ}	 zt|ƒ}W n ty   | Y S w t|f|ƒ}t|ƒr#|S t |¡}q)z.Depth-first iterator over scalars in a tensor.)rq   rt   ÚStopIterationr   rÞ   r}   )Útensorru   r•   rh   rh   ri   Ú_flatten_tensorÔ  s   ÿ
ørá   c                 C   sD   t |tƒrtt | ¡|ƒS |^}}t| ƒ}ttt|ƒ|ƒ}t||ƒS )aó  Change the shape of a *matrix*.

    If *shape* is an integer, the matrix must be two dimensional
    and the shape is interpreted as the desired number of columns:

        >>> matrix = [(0, 1), (2, 3), (4, 5)]
        >>> cols = 3
        >>> list(reshape(matrix, cols))
        [(0, 1, 2), (3, 4, 5)]

    If *shape* is a tuple (or other iterable), the input matrix can have
    any number of dimensions. It will first be flattened and then rebuilt
    to the desired shape which can also be multidimensional:

        >>> matrix = [(0, 1), (2, 3), (4, 5)]    # Start with a 3 x 2 matrix

        >>> list(reshape(matrix, (2, 3)))        # Make a 2 x 3 matrix
        [(0, 1, 2), (3, 4, 5)]

        >>> list(reshape(matrix, (6,)))          # Make a vector of length six
        [0, 1, 2, 3, 4, 5]

        >>> list(reshape(matrix, (2, 1, 3, 1)))  # Make 2 x 1 x 3 x 1 tensor
        [(((0,), (1,), (2,)),), (((3,), (4,), (5,)),)]

    Each dimension is assumed to be uniform, either all arrays or all scalars.
    Flattening stops when the first value in a dimension is a scalar.
    Scalars are bytes, strings, and non-iterables.
    The reshape iterator stops when the requested shape is complete
    or when the input is exhausted, whichever comes first.

    )	rÝ   Úintr-   r   r}   rá   r	   Úreversedr   )rÜ   ÚshapeÚ	first_dimÚdimsZscalar_streamZreshapedrh   rh   ri   rH   â  s   
!
rH   c                 C   s&   t |d ƒ}tttt| t|ƒƒƒ|ƒS )a#  Multiply two matrices.

    >>> list(matmul([(7, 5), (3, 5)], [(2, 5), (7, 9)]))
    [(49, 80), (41, 60)]

    The caller should ensure that the dimensions of the input matrices are
    compatible with each other.

    Supports all numeric types: int, float, complex, Decimal, Fraction.
    r   )ro   r-   r   r¹   r   r]   )Úm1Úm2rf   rh   rh   ri   r:     s   r:   c                 C   s‚   t d| ƒD ]7}d }}d}|dkr4|| | |  }|| | |  }|| | |  }t|| | ƒ}|dks|| kr<|  S qtdƒ‚)Nr    rÊ   zprime or under 5)r�   r   r‹   )rf   Úbr½   ÚyÚdrh   rh   ri   Ú_factor_pollard  s   üÿrì   éÓ   c                 c   sœ   � | dk rdS t D ]}| | s|V  | | } | | rq	g }| dkr$| gng }|D ]} | dk s2t| ƒr8| | ¡ q(t| ƒ}||| | f7 }q(t|ƒE dH  dS )a  Yield the prime factors of n.

    >>> list(factor(360))
    [2, 2, 2, 3, 3, 5]

    Finds small factors with trial division.  Larger factors are
    either verified as prime with ``is_prime`` or split into
    smaller factors with Pollard's rho algorithm.
    rÊ   Nr    ié­  )Ú_primes_below_211r6   r“   rì   r¨   )rf   ÚprimeÚprimesÚtodoÚfactrh   rh   ri   r3   -  s"   €þ€r3   c                 C   s>   t | ƒ}|dkrt|ƒdƒS ttt|ƒtt|ƒƒƒ}t| |ƒS )a´  Evaluate a polynomial at a specific value.

    Computes with better numeric stability than Horner's method.

    Evaluate ``x^3 - 4 * x^2 - 17 * x + 60`` at ``x = 2.5``:

    >>> coefficients = [1, -4, -17, 60]
    >>> x = 2.5
    >>> polynomial_eval(coefficients, x)
    8.125

    Note that polynomial coefficients are specified in descending power order.

    Supports all numeric types: int, float, complex, Decimal, Fraction.
    r   )ro   Útyperj   Úpowr   rã   r�   r¹   )Úcoefficientsr½   rf   Úpowersrh   rh   ri   rB   N  s
   
rB   c                 C   s   t t| ƒŽ S )z¯Return the sum of the squares of the input values.

    >>> sum_of_squares([10, 20, 30])
    1400

    Supports all numeric types: int, float, complex, Decimal, Fraction.
    )r¹   r   r|   rh   rh   ri   rX   e  s   rX   c                 C   s&   t | ƒ}ttd|ƒƒ}ttt| |ƒƒS )u¨  Compute the first derivative of a polynomial.

    Evaluate the derivative of ``xÂ³ - 4 xÂ² - 17 x + 60``:

    >>> coefficients = [1, -4, -17, 60]
    >>> derivative_coefficients = polynomial_derivative(coefficients)
    >>> derivative_coefficients
    [3, -8, -17]

    Note that polynomial coefficients are specified in descending power order.

    Supports all numeric types: int, float, complex, Decimal, Fraction.
    r    )ro   rã   r�   re   rj   r    )rõ   rf   rö   rh   rh   ri   rD   p  s   rD   c                 C   s"   t t| ƒƒD ]}| | | 8 } q| S )uÙ  Return the count of natural numbers up to *n* that are coprime with *n*.

    Euler's totient function Ï†(n) gives the number of totatives.
    Totative are integers k in the range 1 â‰¤ k â‰¤ n such that gcd(n, k) = 1.

    >>> n = 9
    >>> totient(n)
    6

    >>> totatives = [x for x in range(1, n) if gcd(n, x) == 1]
    >>> totatives
    [1, 2, 4, 5, 7, 8]
    >>> len(totatives)
    6

    Reference:  https://en.wikipedia.org/wiki/Euler%27s_totient_function

    )r¡   r3   )rf   rï   rh   rh   ri   r\   ƒ  s   r\   ))iÿ  )rÊ   )i�Š )é   éI   )l   ÅtT7 )rÊ   é   é=   )l   Áay)rÊ   é   é   iS_ )l   ;n>Ô)rÊ   rÂ   é   rù   é   )l   ßp¤)rÊ   rÂ   rý   rù   rþ   rû   )l            )rÊ   iE  iŸ$  in  i×à i=• iþ‘k)l   ý%!HÈn•fW )rÊ   rÂ   rý   rù   rþ   rû   é   é   rü   é   r÷   é%   é)   c                 C   sH   | d | A   ¡ d }| |? }d|> | | kr|d@ r|dks J ‚||fS )z#Return s, d such that 2**s * d == nr    r   )Ú
bit_length)rf   r�   rë   rh   rh   ri   Ú_shift_to_odd«  s   $r  c                 C   s”   | dkr| d@ rd|  kr| k sJ ‚ J ‚t | d ƒ\}}t||| ƒ}|dks.|| d kr0dS t|d ƒD ]}|| |  }|| d krG dS q6dS )NrÊ   r    TF)r  rô   r�   )rf   Úbaser�   rë   r½   Ú_rh   rh   ri   Ú_strong_probable_prime´  s   ,ÿr  c                    sŠ   ˆ dk rˆ dv S ˆ d@ r ˆ d r ˆ d r ˆ d r ˆ d r ˆ d s"d	S t D ]
\}}ˆ |k r. nq$‡ fd
d„tdƒD ƒ}t‡ fdd„|D ƒƒS )aÁ  Return ``True`` if *n* is prime and ``False`` otherwise.

    Basic examples:

        >>> is_prime(37)
        True
        >>> is_prime(3 * 13)
        False
        >>> is_prime(18_446_744_073_709_551_557)
        True

    Find the next prime over one billion:

        >>> next(filter(is_prime, count(10**9)))
        1000000007

    Generate random primes up to 200 bits and up to 60 decimal digits:

        >>> from random import seed, randrange, getrandbits
        >>> seed(18675309)

        >>> next(filter(is_prime, map(getrandbits, repeat(200))))
        893303929355758292373272075469392561129886005037663238028407

        >>> next(filter(is_prime, map(randrange, repeat(10**60))))
        269638077304026462407872868003560484232362454342414618963649

    This function is exact for values of *n* below 10**24.  For larger inputs,
    the probabilistic Miller-Rabin primality test has a less than 1 in 2**128
    chance of a false positive.
    rÿ   >   rÊ   rÂ   rý   rù   rþ   rû   r    rÂ   rý   rù   rþ   rû   Fc                 3   s   � | ]
}t d ˆ d ƒV  qdS )rÊ   r    N)Ú_private_randranger¯   rµ   rh   ri   rž   õ  s   € zis_prime.<locals>.<genexpr>é@   c                 3   r™   r‘   )r  )rš   r  rµ   rh   ri   rž   ÷  rŸ   )Ú_perfect_testsr�   Úall)rf   ÚlimitÚbasesrh   rµ   ri   r6   Ê  s   !0ÿr6   c                 C   s
   t d| ƒS )zÂReturns an iterable with *n* elements for efficient looping.
    Like ``range(n)`` but doesn't create integers.

    >>> i = 0
    >>> for _ in loops(5):
    ...     i += 1
    >>> i
    5

    Nr«   rµ   rh   rh   ri   r9   ú  s   
r9   c                  G   s   t ttt| ƒ| ƒƒS )uÕ  Number of distinct arrangements of a multiset.

    The expression ``multinomial(3, 4, 2)`` has several equivalent
    interpretations:

    * In the expansion of ``(a + b + c)â�¹``, the coefficient of the
      ``aÂ³bâ�´cÂ²`` term is 1260.

    * There are 1260 distinct ways to arrange 9 balls consisting of 3 reds, 4
      greens, and 2 blues.

    * There are 1260 unique ways to place 9 distinct objects into three bins
      with sizes 3, 4, and 2.

    The :func:`multinomial` function computes the length of
    :func:`distinct_permutations`.  For example, there are 83,160 distinct
    anagrams of the word "abracadabra":

        >>> from more_itertools import distinct_permutations, ilen
        >>> ilen(distinct_permutations('abracadabra'))
        83160

    This can be computed directly from the letter counts, 5a 2b 2r 1c 1d:

        >>> from collections import Counter
        >>> list(Counter('abracadabra').values())
        [5, 2, 2, 1, 1]
        >>> multinomial(5, 2, 2, 1, 1)
        83160

    A binomial coefficient is a special case of multinomial where there are
    only two categories.  For example, the number of ways to arrange 12 balls
    with 5 reds and 7 blues is ``multinomial(5, 7)`` or ``math.comb(12, 5)``.

    Likewise, factorial is a special case of multinomial where
    the multiplicities are all just 1 so that
    ``multinomial(1, 1, 1, 1, 1, 1, 1) == math.factorial(7)``.

    Reference:  https://en.wikipedia.org/wiki/Multinomial_theorem

    )r   rj   r   r   )Úcountsrh   rh   ri   r;     s   *r;   c                 c   sv   � | j }g }g }ttƒ�% 	 t|t||ƒ ƒƒ |d V  t|t||ƒ ƒƒ |d |d  d V  q1 s4w   Y  dS )z.Non-windowed running_median() for Python 3.14+Tr   rÊ   N)Ú__next__r   rß   rb   r   r
   rc   ©ru   ÚreadÚloÚhirh   rh   ri   Ú#_running_median_minheap_and_maxheap5  s   €

ûÿr  c                 c   s~   � | j }g }g }ttƒ�) 	 t|t||ƒ ƒ ƒ |d  V  t|t||ƒ  ƒ ƒ |d |d  d V  q1 s8w   Y  dS )zDBackport of non-windowed running_median() for Python 3.13 and prior.Tr   rÊ   N)r  r   rß   r
   r   r  rh   rh   ri   Ú_running_median_minheap_onlyE  s   €
ûÿr  c                 c   sˆ   � t ƒ }g }| D ]9}| |¡ t||ƒ t|ƒ|kr$t|| ¡ ƒ}||= t|ƒ}|d }|d@ r4|| n||d  ||  d V  qdS )z+Yield median of values in a sliding window.rÊ   r    N)r   r“   r   ro   r   r’   )ru   rn   r¼   Úorderedr½   r°   rf   Úmrh   rh   ri   Ú_running_median_windowedU  s   €

,ör  rm   c                C   sF   t | ƒ}|durt|ƒ}|dkrtdƒ‚t||ƒS tst|ƒS t|ƒS )aD  Cumulative median of values seen so far or values in a sliding window.

    Set *maxlen* to a positive integer to specify the maximum size
    of the sliding window.  The default of *None* is equivalent to
    an unbounded window.

    For example:

        >>> list(running_median([5.0, 9.0, 4.0, 12.0, 8.0, 9.0]))
        [5.0, 7.0, 5.0, 7.0, 8.0, 8.5]
        >>> list(running_median([5.0, 9.0, 4.0, 12.0, 8.0, 9.0], maxlen=3))
        [5.0, 7.0, 5.0, 9.0, 8.0, 9.0]

    Supports numeric types such as int, float, Decimal, and Fraction,
    but not complex numbers which are unorderable.

    On version Python 3.13 and prior, max-heaps are simulated with
    negative values. The negation causes Decimal inputs to apply context
    rounding, making the results slightly different than that obtained
    by statistics.median().
    Nr   úWindow size should be positive)rq   Ú_indexr‹   r  Ú_max_heap_availabler  r  ©rg   rn   ru   rh   rh   ri   rR   h  s   
rR   c                 c   sR   � t ƒ }d}| D ]}| |¡ ||7 }t|ƒ|kr|| ¡ 8 }|t|ƒ V  qd S )Nr   )r   r“   ro   r’   )ru   rf   r¼   Zrunning_sumr•   rh   rh   ri   Ú_windowed_running_mean�  s   €
ûr  c                C   s>   t | ƒ}|du rttt|ƒtdƒƒS |dkrtdƒ‚t||ƒS )a³  Cumulative mean of values seen so far or values in a sliding window.

    Set *maxlen* to a positive integer to specify the maximum size
    of the sliding window.  The default of *None* is equivalent to
    an unbounded window.

    For example:

        >>> list(running_mean([40, 30, 50, 46, 39, 44]))
        [40.0, 35.0, 40.0, 41.5, 41.0, 41.5]

        >>> list(running_mean([40, 30, 50, 46, 39, 44], maxlen=3))
        [40.0, 35.0, 40.0, 42.0, 45.0, 43.0]

    Supports numeric types such as int, float, complex, Decimal, and Fraction.

    No extra effort is made to reduce round-off errors for float inputs.
    So the results may be slightly different from `statistics.mean`.

    Nr    r   r  )rq   rj   r%   r   r   r‹   r  r  rh   rh   ri   rQ   ˜  s   
rQ   c                 c   sŠ   � t ƒ }t| ƒD ]:\}}|r|d d || kr| ¡  |r4|d d |k s4| ¡  |r4|d d |k r&| ||f¡ |d d V  qd S ©Nr   rŽ   r    ©r   rÆ   r’   Úpopr“   )ru   rn   Úsisr"   r•   rh   rh   ri   Ú_windowed_running_min¹  ó   €ÿúr#  c                C   ó6   t | ƒ}|du rt|td�S |dkrtdƒ‚t||ƒS )aD  Smallest of values seen so far or values in a sliding window.

    Set *maxlen* to a positive integer to specify the maximum size
    of the sliding window.  The default of *None* is equivalent to
    an unbounded window.

    For example:

        >>> list(running_min([4, 3, 7, 0, 8, 1, 6, 2, 9, 5]))
        [4, 3, 3, 0, 0, 0, 0, 0, 0, 0]

        >>> list(running_min([4, 3, 7, 0, 8, 1, 6, 2, 9, 5], maxlen=3))
        [4, 3, 3, 0, 0, 0, 1, 1, 2, 2]

    Supports numeric types such as int, float, Decimal, and Fraction,
    but not complex numbers which are unorderable.
    N©Úfuncr   r  )rq   r   Úminr‹   r#  r  rh   rh   ri   rS   Ä  ó   
rS   c                 c   sŠ   � t ƒ }t| ƒD ]:\}}|r|d d || kr| ¡  |r4|d d |ks4| ¡  |r4|d d |kr&| ||f¡ |d d V  qd S r  r   )ru   rn   Zsdsr"   r•   rh   rh   ri   Ú_windowed_running_maxâ  r$  r*  c                C   r%  )aC  Largest of values seen so far or values in a sliding window.

    Set *maxlen* to a positive integer to specify the maximum size
    of the sliding window.  The default of *None* is equivalent to
    an unbounded window.

    For example:

        >>> list(running_max([4, 3, 7, 0, 8, 1, 6, 2, 9, 5]))
        [4, 4, 7, 7, 8, 8, 8, 8, 9, 9]

        >>> list(running_max([4, 3, 7, 0, 8, 1, 6, 2, 9, 5], maxlen=3))
        [4, 4, 7, 7, 8, 8, 8, 6, 9, 9]

    Supports numeric types such as int, float, Decimal, and Fraction,
    but not complex numbers which are unorderable.
    Nr&  r   r  )rq   r   rr   r‹   r*  r  rh   rh   ri   rP   í  r)  rP   )ÚfrozenÚslotsc                   @   s6   e Zd ZU eed< eed< eed< eed< eed< dS )r+   rs   ÚminimumÚmedianÚmaximumÚmeanN)Ú__name__Ú
__module__Ú__qualname__râ   Ú__annotations__Úfloatrh   rh   rh   ri   r+     s   
 r+   c             
   C   sd   t | dƒ\}}}}tt|du rtdƒn	ttd|ƒt|ƒƒt||d�t||d�t	||d�t
||d�ƒS )a  Statistics for values seen so far or values in a sliding window.

    Set *maxlen* to a positive integer to specify the maximum size
    of the sliding window.  The default of *None* is equivalent to
    an unbounded window.

    Yields instances of a ``Stats`` dataclass with fields for the dataset *size*,
    *minimum* value, *median* value, *maximum* value, and the arithmetic *mean*.

    Supports numeric types such as int, float, Decimal, and Fraction,
    but not complex numbers which are unorderable.
    é   Nr    rm   )r   rj   r+   r   r   r�   r   rS   rR   rP   rQ   )rg   rn   Út0rÃ   rÄ   rÅ   rh   rh   ri   rT     s   "



úrT   c                 C   sl   t | ƒ}t|ƒdk rt|ƒdkrdS tdƒ‚ttt|ƒƒƒ}t |ƒ}	 t|ƒ ttt||ƒƒs5t	|Ž |ƒS q#)z�Return a random derangement of elements in the iterable.

    Equivalent to but much faster than ``choice(list(derangements(iterable)))``.

    rÊ   r   rh   zNo derangments to choose from)
r~   ro   r¶   re   r�   r)   Úanyrj   r#   r$   )rg   rÌ   Úpermrl   rh   rh   ri   rK   /  s   ýrK   )r   r‘   )r†   N)NF)NN)r   N)�Ú__doc__ÚrandomÚbisectr   r   Úcollectionsr   Ú
contextlibr   Údataclassesr   Ú	functoolsr   r	   Úheapqr
   r   Ú	itertoolsr   r   r   r   r   r   r   r   r   r   r…   r   r   r   r   r   r   Úmathr   r   r   r   Úoperatorr    r!   r"   r  r#   r$   r%   r&   r'   r(   r)   Úsysr*   Ú__all__ÚobjectÚ_markerrb   rc   ÚImportErrorr  r[   rY   rZ   r/   r=   r,   r˜   rG   r@   r?   r<   r1   r‚   r¹   r4   rN   r5   rO   rA   rE   r`   ra   r_   r7   r2   rM   rL   rJ   rI   r>   rF   r0   r.   r^   rÇ   rÈ   rV   rW   rC   r8   rU   rÚ   r-   rÛ   r]   ÚstrrÕ   rÞ   rá   rH   r:   rì   r~   rî   r3   rB   rX   rD   r\   r  r  r  ÚRandomr	  r6   r9   r;   r  r  r  rR   r  rQ   r#  rS   r*  rP   r+   rT   rK   rh   rh   rh   ri   Ú<module>   sÒ    
H ;ÿ


(


ÿ

)(

$



"+	
)

	)!

0-%!
