
    Ki                     <   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Z6 e7       Z8	 ddlm9Z9m:Z: dZ;d Z=dbdZ>d Z?dcdZ@dcdZAdcdZBeCfdZDd ZEeEZFd ZGd ZH	 ddl#mIZJ d ZKdcdZLd Zddd ZMd! ZNd" ZOd# ZPdcd$ZQdcd%ZRded&ZSdcd'ZTdfd(ZUd)d*d+ZVdcd,ZWd- ZXd. ZYd/ ZZd0 Z[d1 Z\d2 Z]d3 Z^d4 Z_d5 Z`d6 Zad7 Zbd8 Zcdgd9Zdd: Zedd;d<Zfe5d=k\  rdd>lmgZh dd;d?Zgefj                   eg_         nefZgd@ ZiejekffdAZldB ZmdC ZndD ZodE Zp eq eedF            ZrdG ZsdH ZtdI ZudJ ZvdK Zwg dLZxedM        ZydN Zz ej                         j`                  Z|dO Z}dP Z~dQ ZdR ZdS ZdT ZddUdVZdW ZddUdXZdY ZddUdZZd[ ZddUd\Z e
dd]       G d^ d_             ZddUd`Zda Zy# e<$ r dZ;Y sw xY w# e<$ r eHZJY Tw xY w)ha  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_maxTFc                 ,    t        t        ||             S )zReturn 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iterables     b/home/jay/workspace/scripts/.codegraph-venv/lib/python3.12/site-packages/more_itertools/recipes.pyr\   r\   q   s     x#$$    c                 ,    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starts     ri   rZ   rZ      s     xu&&rj   c                     	 t        |      }t        |t        d|| z
        d      S # t        $ r t	        t        ||             cY S w xY w)zReturn an iterator over the last *n* items of *iterable*.

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

    r   Nmaxlen)lenr   max	TypeErroriterr   )rg   rh   sizes      ri   r[   r[      sO    88} hAtax 0$77  /E(1-../s   ' A	A	c                 R    |t        | d       yt        t        | ||      d       y)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   rp   )r   nextr   )iteratorrg   s     ri   r0   r0      s)    @ 	yhq! 	VHa#T*rj   c                 0    t        t        | |d      |      S )zReturns the nth item or a default value.

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

    N)rx   r   )rh   rg   defaults      ri   r>   r>      s     xD)733rj   c                 >    t        | |      }|D ]  }|D ]  }  y  y y)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   )rh   keyry   firstseconds        ri   r-   r-      s9    $ x%H  	F	 rj   c                 ,    t        t        ||             S )zcReturn the how many times the predicate is true.

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

    )sumrl   )rh   preds     ri   rH   rH      s     s4"##rj   c                 ,    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   rh   s    ri   rA   rA      s     6$<((rj   c                 R    t        j                  t        t        |       |            S )zvReturns the sequence elements *n* times

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

    )r   from_iterabler   tuplerh   rg   s     ri   r=   r=     s      veHoq9::rj   c                 6    t        t        t        | |            S )zReturns 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.
    )r   rl   r!   )vec1vec2s     ri   r2   r2     s     s3d#$$rj   )sumprodc                 ,    t        j                  |       S )zReturn 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   )list_of_listss    ri   r5   r5   +  s     }--rj   c                 \    |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]

    )r   r   )rm   timesargss      ri   rO   rO   7  s.    , }x..8VD%011rj   c                     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   s    ri   r   r   R  s     h''rj   c                     t        |       g|z  }|xdk(  r t        |d|iS x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

    fill	fillvaluestrictTignorez Expected fill, strict, or ignore)ru   r   zip
ValueError)rh   rg   
incompleter   	iteratorss        ri   r6   r6   ^  sZ    : h 1$I
	?Y??	/$//	?"?@@rj   c               '      K   t        t        |       }t        t        |       dd      D ]/  }t	        t        ||            }t        t        |      E d{    1 y7 w)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)rl   ru   rangerr   r   r   rx   )	iterablesr   
num_actives      ri   rP   rP     sT      D)$IC	NAr2 (
&J78	tY'''('s   AAAAc                       t          t        |      t               t                f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, ' '])

    c              3      K   	 | r| j                          | rD ]  } |      rnj                  |        n y <wN)popleftappend)queuevaluefalse_queuery   r   
true_queues     ri   genzpartition.<locals>.gen  sP     mmo% ! #E{CCEJ  s
   A%A)boolru   r   )r   rh   r   r   ry   r   s   `  @@@ri   rB   rB     sA    ( |H~H'KJ {S_,,rj   c                     t        |       t        j                  fdt        t	              dz         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   6   K   | ]  }t        |        y wr   )r   ).0rss     ri   	<genexpr>zpowerset.<locals>.<genexpr>  s     Ma|Aq1M      )rf   r   r   r   rr   )rh   r   s    @ri   rF   rF     s2    " 	XAM5Q!;LMMMrj   c              #      K   t               }|1t        |j                  |       D ]  }|j                  |       |  y| D ]$  } ||      }||vs|j                  |       | & yw)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)rh   r}   seenelementks        ri   ra   ra     sr     . 5D
{"4#4#4h? 	GHHWM	   	GGA}		s   AA*A*c           
          |t        t        d      t        |             S t        t        t        t        d      t        | |                  S )zYields 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']

    r   r   )rl   r%   r   rx   )rh   r}   s     ri   rb   rb     s>     {:a='("344tSA#(>?@@rj   c                 8    t        | ||      }t        ||      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.
    )r}   reverse)r}   )sortedrb   )rh   r}   r   	sequenceds       ri   r`   r`   	  s      xS':I9#..rj   c              #   f   K   t        |      5  |	 |        	  |         
# 1 sw Y   yxY ww)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   )rm   	exceptionr~   s      ri   r8   r8     s<     , 
)	 'M*  s   1%.1c                 .    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'

    )rx   filter)rh   r{   r   s      ri   r3   r3   :  s    " tX&00rj   r   r   c                 l    t        t        t         |            | z  }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   rl   r)   )r   r   poolss      ri   rN   rN   N  s,      #eY'(61EVU#$$rj   c                 `    t        |       }|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)``.

    )r   rr   r(   )rh   r   pools      ri   rM   rM   b  s-     ?DYD	AAa!!rj   c                     t        |       }t        |      }t        t        t	        |      |            }t        |D cg c]  }||   	 c}      S c c}w )zReturn 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)``.

    )r   rr   r   r(   r   )rh   r   r   rg   indicesis         ri   rK   rK   t  sH     ?DD	AVE!Ha()G7+a$q'+,,+   Ac                     t        |       }t        |      t        fdt        |      D              }t        |D cg c]  }||   	 c}      S c c}w )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   4   K   | ]  }t                y wr   )r'   r   r   rg   s     ri   r   z6random_combination_with_replacement.<locals>.<genexpr>  s     4aYq\4s   )r   rr   r   r   )rh   r   r   r   r   rg   s        @ri   rJ   rJ     sH     ?DD	A45844G7+a$q'+,,+r   c                 @   t        |       }t        |      }t        ||      }|dk  r||z  }d|cxk  r
|k  st         t        g }|rL||z  |z  |dz
  |dz
  }}}||k\  r||z  }|||z
  z  |z  |dz
  }}||k\  r|j	                  |d|z
            |rLt        |      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   rr   r   
IndexErrorr   )rh   r   r#   r   rg   cresults          ri   r?   r?     s     ?DD	AQ
Aqy
>> F
a%1*a!eQUa1qjQJEA;!#QUqA qj 	d26l#  =rj   c                     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   rh   s     ri   rG   rG     s     %(##rj   c              #      K   t        |      ddd   }t        |      }t        dg|      |z  }t        | t	        d|dz
              D ]!  }|j                  |       t        ||       # yw)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   rp   r   )r   rr   r   r   r   r   _sumprod)signalkernelrg   windowxs        ri   r1   r1     sq     F 6]4R4 FFAA3q!A%F66!QU+, 'avv&&'s   A,A.c                 d    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afters       ri   r/   r/     s2     r7LE5Yy%0#e*=E%<rj   c                     t        | d      \  }}}t        |d       t        |d       t        |d       t        |||      S )zReturn overlapping triplets from *iterable*.

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

       N)r   rx   r   )rh   t1t2t3s       ri   r_   r_     s?     Xq!JBBTNTNTNr2r?rj   c                 ~    t        | |      }t        |      D ]  \  }}t        t        |||      d         t	        | S r   )r   	enumeraterx   r   r   )rh   rg   r   r   ry   s        ri   _sliding_window_islicer     sC    Ha I + +8VHa#T*+	?rj   c              #      K   t        |       }t        t        ||dz
        |      }|D ]   }|j                  |       t	        |       " y w)Nr   rp   )ru   r   r   r   r   )rh   rg   ry   r   r   s        ri   _sliding_window_dequer     sK     H~H6(AE*15F aFms   AAc                     |dkD  rt        | |      S |dkD  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   s     ri   rW   rW   %  sb     	2v$Xq11	
Q%h22	
a!!	
a8}9!=>>rj   c           
          t        |       }t        t        t        t	        t        |      dz         d            }t        t        t        |      |      S )zReturn 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   )	rf   r   slicer   r   rr   rl   r"   r   )rh   seqslicess      ri   rX   rX   >  s@     x.CULs3x!|)<a@AFwsV,,rj   c                 J    dg}| D ]  }t        t        |d| f            } |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   )rf   r1   )rootspolyroots      ri   rD   rD   L  s6      3D 0HTAu:./0Krj   c              #     K   t        | dd      }|0t        | ||      }t        ||      D ]  \  }}||u s||k(  s|  y|t        |       n|}|dz
  }t	        t
              5  	  |||dz   |      x} # 1 sw Y   yxY ww)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   rr   r   r   )rh   r   rn   stop	seq_indexry   r   r   s           ri   r9   r9   b  s     2 '40I(E40#He4 	JAw%7e#3	
 !%s8}$AIj! 	;%eQUD99q: 	; 	;s   8B*B%A99B>Bc              #   T  K   | dkD  rd d}t        d      | dz  z  }t        |d|t        |       dz         D ]Q  }t        |d|||z        E d{    t        t	        t        ||z  | ||z                     |||z  | ||z   <   ||z  }S t        |d|      E d{    y7 R7 w)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)	bytearrayr9   r   bytesrr   r   )rg   rn   dataps       ri   rV   rV     s      	1uEVQ'DaU1X\: dAua!e444"'E!a%AE,B(C"DQUQQA $5))) 	5 *s%   AB(B$AB(B&B(&B(r   c             #      K   |dk  rt        d      t        |       }t        t        ||            x}r8|rt	        |      |k7  rt        d      | t        t        ||            x}r7yyw)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   ru   r   r   rr   )rh   rg   r   ry   batchs        ri   _batchedr    sr      	1u122H~H!,-
-%
-c%jAo:;; !,-
-%
-s   A)A.,A.i )r.   c                    t        | ||      S )Nr   )itertools_batched)rh   rg   r   s      ri   r.   r.     s     1V<<rj   c                     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   )matrixs    ri   r^   r^     s     $t$$rj   c                 P    	 t        |        t        | |      S # t        $ r Y yw xY w)z.Scalars are bytes, strings, and non-iterables.T)ru   rt   
isinstance)r   
stringlikes     ri   
_is_scalarr
    s1    U eZ((  s    	%%c                     t        |       }	 	 t        |      }t        |f|      }t	        |      r|S t        j
                  |      }<# t        $ r |cY S w xY w)z.Depth-first iterator over scalars in a tensor.)ru   rx   StopIterationr   r
  r   )tensorry   r   s      ri   _flatten_tensorr    sd    F|H
	NE %8,eO&&x0   	O	s   A	 	AAc                     t        |t              rt        t        j                  |       |      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dimsscalar_streamreshapeds         ri   rI   rI     sZ    B %u**62E::I#F+Mgx~}=H(I&&rj   c                 x    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   )rr   r.   r   r   r   r^   )m1m2rg   s      ri   r;   r;     s0     	BqE
A78WR2%?@!DDrj   c                     t        d|       D ]L  }dx}}d}|dk(  r6||z  |z   | z  }||z  |z   | z  }||z  |z   | z  }t        ||z
  |       }|dk(  r6|| k7  sJ|c S  t        d      )Nr   r   zprime or under 5)r   r    r   )rg   br   yds        ri   _factor_pollardr    s     1a[ 		A1fQaAQaAQaAAE1A	 1f
 6H	 '
((rj      c              #     K   | dk  ryt         D ]  }| |z  r	| | |z  } | |z  s g }| dkD  r| gng }|D ]9  } | dk  st        |       r|j                  |        %t        |       }||| |z  fz  }; t	        |      E d{    y7 w)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_211r7   r   r  r   )rg   primeprimestodofacts        ri   r4   r4   -  s      	1u # e)K%KA e) Fa%A3RD &v:!MM!"1%DT19%%D& f~s   B	B	AB	BB	c           	          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   )rr   typerl   powr   r  r   r   )coefficientsr   rg   powerss       ri   rC   rC   N  sM      	LAAvtAwqzfQi%(!34FL&))rj   c                 $    t        t        |        S )zReturn 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   s    ri   rY   rY   e  s     S]##rj   c                 v    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   )rr   r  r   rf   rl   r!   )r)  rg   r*  s      ri   rE   rE   p  s2     	LAeAqk"FCv.//rj   c                 H    t        t        |             D ]
  }| | |z  z  }  | 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   r4   )rg   r"  s     ri   r]   r]     s-    & VAY 	Q%ZHrj   ))i  )r   )i )   I   )l   tT7 )r      =   )l   ay)r         iS_ )l   ;n>)r   r      r0     )l   p)r   r   r4  r0  r5  r2  )l            )r   iE  i$  in  i i= ik)l   %!HnfW )r   r   r4  r0  r5  r2        r3     r.  %   )   c                 t    | dz
  | z  j                         dz
  }| |z	  }d|z  |z  | k(  r
|dz  r|dk\  sJ ||fS )z#Return s, d such that 2**s * d == nr   r   )
bit_length)rg   r   r  s      ri   _shift_to_oddr=    sS     a%1  "Q&A	QAFa<1Q1611a4Krj   c                     | dkD  r| dz  rd|cxk  r| k  sJ  J t        | dz
        \  }}t        |||       }|dk(  s|| dz
  k(  ryt        |dz
        D ]  }||z  | z  }|| dz
  k(  s y y)Nr   r   TF)r=  r(  r   )rg   baser   r  r   _s         ri   _strong_probable_primerA    s    EAAMM22M22QDAqD!QAAva!e1q5\ EAIA:
 rj   c                       dk  r dv S  dz  r dz  r dz  r dz  r
 dz  r dz  sy	t         D ]  \  }} |k  s n  fd
t        d      D        }t         f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.
    r6  >   r   r   r4  r0  r5  r2  r   r   r4  r0  r5  r2  Fc              3   <   K   | ]  }t        d dz
          yw)r   r   N)_private_randranger   s     ri   r   zis_prime.<locals>.<genexpr>  s     A!#Aq1u-As   @   c              3   6   K   | ]  }t        |        y wr   )rA  )r   r?  rg   s     ri   r   zis_prime.<locals>.<genexpr>  s     A4%a.Ar   )_perfect_testsr   all)rg   limitbasess   `  ri   r7   r7     s    B 	2v(((Ea!eA!a%AFq2v& Buu9B BuRyAA5AAArj   c                     t        d|       S )zReturns 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   )rg   s    ri   r:   r:     s     $?rj   c                  H    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   rl   r   r   )countss    ri   r<   r<     s    T D*V,f566rj   c           	   #      K   | j                   }g }g }t        t              5  	 t        |t	        | |                    |d    t        |t        | |                    |d   |d   z   dz   N# 1 sw Y   yxY ww)z.Non-windowed running_median() for Python 3.14+r   r   N)__next__r   r  rc   r   r   rd   ry   readlohis       ri   #_running_median_minheap_and_maxheaprT  5  s      D	B	B	-	  &[TV45Q%KRTV45a52a5=A%% & &s    A>AA22A;7A>c           	   #     K   | j                   }g }g }t        t              5  	 t        |t	        | |                     |d     t        |t	        | |                      |d   |d   z
  dz   R# 1 sw Y   yxY ww)zDBackport of non-windowed running_median() for Python 3.13 and prior.r   r   N)rO  r   r  r   r   rP  s       ri   _running_median_minheap_onlyrV  E  s      D	B	B	-	  &R+b$&112a5&LR+b46'223a52a5=A%% & &s    BAA66A?;Bc              #     K   t               }g }| D ]w  }|j                  |       t        ||       t        |      |kD  rt	        ||j                               }||= t        |      }|dz  }|dz  r||   n||dz
     ||   z   dz   y yw)z+Yield median of values in a sliding window.r   r   N)r   r   r   rr   r   r   )ry   rq   r   orderedr   r   rg   ms           ri   _running_median_windowedrZ  U  s      WFG 
Iaww<& GV^^%56A
LFEgajA(Cq'HH
Is   B
Brp   c                    t        |       }|'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().
    r   Window size should be positive)ru   _indexr   rZ  _max_heap_availablerV  rT  rh   rq   ry   s      ri   rS   rS   h  sU    . H~HQ;=>>'&99+H55.x88rj   c              #      K   t               }d}| D ]I  }|j                  |       ||z  }t        |      |kD  r||j                         z  }|t        |      z   K y w)Nr   )r   r   rr   r   )ry   rg   r   running_sumr   s        ri   _windowed_running_meanrb    sb     WFK (euv;?6>>++KCK''(s   AAc                    t        |       }|#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`.

    r   r   r\  )ru   rl   r&   r   r   r   rb  r_  s      ri   rR   rR     sJ    , H~H~7Jx0%(;;{9::!(F33rj   c              #     K   t               }t        |       D ]m  \  }}|r|d   d   ||z
  k(  r|j                          |r)|d   d   |k  s|j                          |r|d   d   |k  s|j	                  ||f       |d   d    o y wNr   r   r   r   r   r   popr   )ry   rq   sisr#   r   s        ri   _windowed_running_minri         
'C!(+ u3q6!9.KKM#b'!*u,GGI #b'!*u,

E5>"!fQi   A&B	) B	c                v    t        |       }|t        |t              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.
    funcr   r\  )ru   r   minr   ri  r_  s      ri   rT   rT     ?    & H~H~(--{9:: 622rj   c              #     K   t               }t        |       D ]m  \  }}|r|d   d   ||z
  k(  r|j                          |r)|d   d   |kD  s|j                          |r|d   d   |kD  s|j	                  ||f       |d   d    o y wre  rf  )ry   rq   sdsr#   r   s        ri   _windowed_running_maxrs    rj  rk  c                v    t        |       }|t        |t              S |dk  rt        d      t	        ||      S )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.
    rm  r   r\  )ru   r   rs   r   rs  r_  s      ri   rQ   rQ     rp  rj   )frozenslotsc                   @    e Zd ZU eed<   eed<   eed<   eed<   eed<   y)r,   rv   minimummedianmaximummeanN)__name__
__module____qualname__r  __annotations__float rj   ri   r,   r,     s    
INMN
Krj   r,   c                    t        | d      \  }}}}t        t        |t        d      nt	        t        d|      t        |            t        ||      t        ||      t        ||      t        ||            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.
       r   rp   )r   rl   r,   r   r   r   r   rT   rS   rQ   rR   )rh   rq   t0r   r   r   s         ri   rU   rU     so     1%NBBNaeAv.>v(OBv&r&)Bv&R' rj   c                 "   t        |       }t        |      dk  rt        |      dk(  ryt        d      t        t	        t        |                  }t        |      }	 t        |       t        t        t        ||            s t        | |      S 4)zReturn a random derangement of elements in the iterable.

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

    r   r   r  zNo derangments to choose from)
r   rr   r   rf   r   r*   anyrl   r$   r%   )rh   r   permrn   s       ri   rL   rL   /  s     /C
3x!|s8q=899c#h D$KE
3sE4()$:t$S)) rj   )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_markerrc   rd   r^  ImportErrorr\   rZ   r[   r0   r>   r-   r   rH   rA   r@   r=   r2   r   r   r5   rO   r6   rP   rB   rF   ra   rb   r`   r8   r3   rN   rM   rK   rJ   r?   rG   r1   r/   r_   r   r   rW   rX   rD   r9   rV   r  r.   r  r^   strr   r
  r  rI   r;   r  r   r!  r4   rC   rY   rE   r]   rG  r=  rA  RandomrD  r7   r:   r<   rT  rV  rZ  rS   rb  rR   ri  rT   rs  rQ   r,   rU   rL   r  rj   ri   <module>r     s    &   ! ' '    $ ( ' L L 5 5 9v (3 % '$8 %+P
44 ! $) ;
%(
	.26	(&AR($%-PN*!HA/(:1( '( %("$- -"D$('V& ?2-,&;R** %* ( 6', = &&GOG	% #&u )1&'RE)  %*% B*.$0&2  & #V]]_.. -B`*7Z& & I& (, "9J( &* 4B %) 3< %) 3< $d#  $ ,0 6*I.    x  Hs$   H  H HHHH