| Server IP : 178.105.222.151 / Your IP : 216.73.216.38 Web Server : nginx/1.28.3 System : Linux MNK 7.0.0-15-generic #15-Ubuntu SMP PREEMPT_DYNAMIC Wed Apr 22 16:06:43 UTC 2026 x86_64 User : www-data ( 33) PHP Version : 8.5.4 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/more_itertools/__pycache__/ |
Upload File : |
+
�CiS� � �h � R t ^ RIt^ RIHtHt ^ RIHt ^ RIHt ^ RI H
t
H t H t ^ RI
HtHt ^ RIHtHtHtHtHtHtHtHtHtHtHtH t H t H t ^ RI H t H!t!H"t"H#t# ^ R I$H%t%H&t&H't'H(t(H)t) ^ R
IH*t*H+t+H,t, ^ R I-H.t. . R NR
NRNRNRNRNRNRNRNRNRNRNRNRNRNRNR NR NR NR NR NR!NR"NR#NR$NR%NR&NR'NR(NR)NR*NR+NR,NR-NR.NR/NR0NR1NR2NR3NR4NR5NR6NR7NR8NR9NR:NR;NR<NR=Nt/]0! 4 t1 ]2! R>R?7 ] ! ]2R>R?7 t3 ^ R@I H5t6 ^ RBI
H8t8H9t9 R>t:RD t;R�RE lt<RF t=R�RG lt>R�RH lt?R�RI lt@]A3RJ ltBRK tC]CtDRL tERM tFRN tGR�RO ltHRP tI ^ RQIHJtK RR tJ]IP ]Jn ! RS RT]L4 tMRU tNRV tOR�RW ltPRX tQRY tRRZ tSR�R[ ltTR�R\ ltUR�R] ltVR�R^ ltWR�R_ ltXR`^/Ra ltYR�Rb ltZRc t[Rd t\Re t]Rf t^Rg t_Rh t`Ri taRj tbRk tcRl tdRm teRn tfR�Ro ltgRp thRqRC/Rr lti].Rs8� d ^ RtIHjtk RqRC/Ru ltj]iP ]jn M]itjRv tl]m]n33Rw ltoRx tpRy tqRz trR{ ts]t! ]h! ^�4 4 tuR| tvR} twR~ txR tyR� tz. R�Ot{]
R� 4 t|R� t}]P� ! 4 PT tR� t�R� t�R� t�R� t�R� t�R� t�R�R/R� lt�R# ]4 d ]2t3 EL�i ; i ]7 d RA t6 EL�i ; i ]7 d RCt: EL�i ; i ]7 d ]ItJ ELUi ; i)�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)� lru_cache�partial�reduce)�heappush� heappushpop)�
accumulate�chain� combinations�compress�count�cycle�groupby�islice�product�repeat�starmap� takewhile�tee� zip_longest)�prod�comb�isqrt�gcd)�mul�not_�
itemgetter�getitem�index)� randrange�sample�choice)�
hexversion� 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_none�pairwise� partition�polynomial_eval�polynomial_from_roots�polynomial_derivative�powerset�prepend�quantify�reshape�#random_combination_with_replacement�random_combination�random_permutation�random_product�
repeatfunc�
roundrobin�running_median�sieve�sliding_window� subslices�sum_of_squares�tabulate�tail�take�totient� transpose�
triplewise�unique�unique_everseen�unique_justseenT��strict)�sumprodc � � \ W4 # �N)r, )�x�ys &&�8/usr/lib/python3/dist-packages/more_itertools/recipes.py�<lambda>ra l s � �J�q� ,� )� heappush_max�heappushpop_maxFc �* � \ \ W4 4 # )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�iterables &&r` rR rR x s � � ��x�#� $�$rb c �, � \ V \ V4 4 # )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 &&r` rP rP � s � � �x��u� � &�&rb c � � \ V4 p\ V\ ^ W ,
4 R4 # \ d \ \ YR7 4 u # i ; i)zsReturn an iterator over the last *n* items of *iterable*.
>>> t = tail(3, 'ABCDEFG')
>>> list(t)
['E', 'F', 'G']
N��maxlen)�lenr �max� TypeError�iterr )rg rh �sizes && r` rQ rQ � sK � �8��8�}�� �h��A�t�x� 0�$�7�7�� � /��E�(�-�.�.�/�s � * � A
� A
c �X � Vf \ V ^ R7 R# \ \ WV4 R4 R# )a� 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
Nrn )r �nextr )�iteratorrg s &&r` r* r* � s' � �@ �y�
�h�q�!�
�V�H��
#�T�*rb c �. � \ \ WR4 V4 # )zmReturns the nth item or a default value.
>>> l = range(10)
>>> nth(l, 3)
3
>>> nth(l, 20, "zebra")
'zebra'
N)rv r )rh rg �defaults &&&r` r8 r8 � s � � ��x�D�)�7� 3�3rb c �F � \ W4 pV F pV F p R# R# R# )aw
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 �keyrw �first�seconds && r` r' r' � s- � �$ �x�%�H��� �F�� �� � rb c �* � \ \ W4 4 # )zWReturn the how many times the predicate is true.
>>> quantify([True, False, True])
2
)�sumrj )rh �preds &&r` rC rC � s � � �s�4�"� #�#rb c �, � \ V \ R4 4 # )z�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 &r` r; r; s � � ��6�$�<� (�(rb c �T � \ P ! \ \ V 4 V4 4 # )zjReturns the sequence elements *n* times
>>> list(ncycles(["a", "b"], 3))
['a', 'b', 'a', 'b', 'a', 'b']
)r
�
from_iterabler �tuple�rh rg s &&r` r7 r7 s � � � � �v�e�H�o�q� 9� :�:rb c �4 � \ \ \ W4 4 # )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.
)r rj r )�vec1�vec2s &&r` r, r, s � � �s�3��#� $�$rb c �. � \ P ! V 4 # )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� )� listOfListss &r` r/ r/ + s � � � � �{� +�+rb c �^ � Vf \ V \ V4 4 # \ V \ W!4 4 # )a Call *func* 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 )�func�times�argss &&*r` rI rI 7 s, � �,
�}��t�V�D�\�*�*� �4���,� -�-rb c �J � \ V 4 w r\ VR4 \ W4 # )z�Returns an iterator of paired items, overlapping, from the original
>>> take(4, pairwise(count()))
[(0, 1), (1, 2), (2, 3), (3, 4)]
On Python 3.10 and above, this is an alias for :func:`itertools.pairwise`.
N�r rv �zip)rh �a�bs & r` � _pairwiser� R s" � � �x�=�D�A���D�M� �q�9�rb )r< c � � \ V 4 # r] )�itertools_pairwiser� s &r` r< r< f s
� �!�(�+�+rb c �6 a a� ] tR tRt oRV 3R lltRtVtV ;t# )�UnequalIterablesErroril c �` <� R pVe VRP ! V! ,
p\ SV ` V4 R# )z Iterables have different lengthsNz/: index 0 has length {}; index {} has length {})�format�super�__init__)�self�details�msg� __class__s && �r` r� � UnequalIterablesError.__init__m s8 �� �0�� � � �E�M�M���
�C� ���� rb � r] )�__name__�
__module__� __qualname__�__firstlineno__r� �__static_attributes__�__classdictcell__�
__classcell__)r� �
__classdict__s @@r` r� r� l s �� � � � rb r� c # �| " � \ V R \ / F$ pV F pV\ J g K \ 4 h Vx � K& R# 5i)� fillvalueN)r �_markerr� )� iterables�combo�vals & r` �_zip_equal_generatorr� w s: � � � �i�;�7�;���C��g�~�+�-�-� � � � <�s � <�<c �� � \ V ^ , 4 p\ V R, ^4 F$ w r#\ V4 pWA8w g K \ WV3R7 h \ V ! # \ d \ T 4 u # i ; i)� :� NN)r� )rp � enumerater� r� rr r� )r� �
first_size�i�itrt s * r` �
_zip_equalr� ss � � /���1� �&�
� �y��}�a�0�E�A��r�7�D��!�+�Z�D�4I�J�J� 1�
�I�� �� � /�#�I�.�.�/�s �8A �A �A1�0A1c � � \ V 4 .V, pVR8X d \ VRV/ # VR8X d
\ V! # VR8X d
\ V! # \ R4 h)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 subclass of `ValueError` will be raised.
>>> iterator = grouper('ABCDEFG', 3, incomplete='strict')
>>> list(iterator) # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
UnequalIterablesError
�fillr� rZ �ignorez Expected fill, strict, or ignore)rs r r� r� �
ValueError)rh rg �
incompleter� � iteratorss &&&& r` r0 r0 � s^ � �: �h� � �1�$�I��V���I�;��;�;��X� ��9�%�%��X� ��I�� ��;�<�<rb c ' �� " � \ \ V 4 p\ \ V 4 ^ R4 F/ p\ \ W4 4 p\ \ V4 Rj x�L
K1 R# L
5i)a/ 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).
N���)rj rs �rangerp r r rv )r� r� �
num_actives * r` rJ rJ � sL � � � �D�)�$�I��C� �N�A�r�2�
��&��7�8� ��t�Y�'�'�'� 3�'�s �AA �A � A c � � V f \ p \ V^4 w r#p\ \ W4 4 w rV\ V\ \ V4 4 \ W64 3# )aw
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, ' '])
)�boolr rj r r )r� rh �t1�t2�p�p1�p2s && r` r= r= � sK � �( �|����H�a� �I�B�A�
��T� �
�F�B� �R��T�2� � '��"�)9� :�:rb c � a� \ V 4 o\ P ! V3R l\ \ S4 ^, 4 4 4 # )a 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 F p\ SV4 x � K R # 5ir] )r )�.0�r�ss & �r` � <genexpr>�powerset.<locals>.<genexpr>� s �� � � M�;L�a�|�A�q� 1� 1�;L�� � )rf r
r� r� rp )rh r� s &@r` rA rA � s2 �� �"
�X��A� � � � M�5��Q��!��;L� M� M�Mrb c # � " � \ 4 pVP p. pVP pVRJpV F* pV' d V! V4 MTp W�9 d V! V4 Vx � K* K, R# \ d Y�9 d T! T4 Tx � KP KS i ; i5i)aJ
Yield unique elements, preserving order.
>>> list(unique_everseen('AAAABBBCCDAABBB'))
['A', 'B', 'C', 'D']
>>> list(unique_everseen('ABBCcAD', str.lower))
['A', 'B', 'C', 'D']
Sequences with a mix of hashable and unhashable items can be used.
The function will be slower (i.e., `O(n^2)`) for unhashable items.
Remember that ``list`` objects are unhashable - you can use the *key*
parameter to transform the list to a tuple (which is hashable) to
avoid a slowdown.
>>> iterable = ([1, 2], [2, 3], [1, 2])
>>> list(unique_everseen(iterable)) # Slow
[[1, 2], [2, 3]]
>>> list(unique_everseen(iterable, key=tuple)) # Faster
[[1, 2], [2, 3]]
Similarly, you may want to convert unhashable ``set`` objects with
``key=frozenset``. For ``dict`` objects,
``key=lambda x: frozenset(x.items())`` can be used.
N)�set�add�appendrr ) rh r{ �seenset� seenset_add�seenlist� seenlist_add�use_key�element�ks && r` rW rW � s� � � �6 �e�G��+�+�K��H��?�?�L���o�G��� #�C��L��� �� ��A�� �
� � �� � �� � �Q�� �
� !� �s* �A B�A �B� B�:B� B�Bc
� � Vf \ \ ^ 4 \ V 4 4 # \ \ \ \ ^4 \ W4 4 4 # )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']
)rj r r rv )rh r{ s &&r` rX rX ' s< � � �{��:�a�=�'�(�"3�4�4� �t�S��A� ���(>�?� @�@rb c �4 � \ WVR7 p\ W1R7 # )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{ )�sortedrX )rh r{ r� � sequenceds &&& r` rV rV 6 s � � �x�'�:�I� �9� .�.rb c # � " � \ V4 ;_uu_ 4 Ve
V! 4 x � V ! 4 x � K + ' g i R# ; i5i)a� Yields results from a function repeatedly until an exception is raised.
Converts a call-until-exception interface to an iterator interface.
Like ``iter(func, 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 )r� � exceptionr| s &&&r` r2 r2 J s4 � � �,
�)� � � � ��'�M���&�L�
� � �s �A�0� A � Ac �, � \ \ W 4 V4 # )ad
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'
)rv �filter)rh ry r� s &&&r` r- r- g s � �" ��t�&�� 0�0rb r c � � V Uu. uF p\ V4 NK upV , p\ ;QJ d . R V 4 F NK 5# ! R V 4 4 # u upi )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)``.
c 3 �8 " � T F p\ V4 x � K R # 5ir] )r% )r� �pools & r` r� �!random_product.<locals>.<genexpr>� s � � �0�%�$��� � �%�s �)r� )r r� r� �poolss $* r` rH rH { sH � � &*� *�T�T�U�4�[�T� *�V� 3�E� �5�0�%�0�5�0�5�0�%�0� 0�0��
+s �Ac �b � \ V 4 pVf \ V4 MTp\ \ W!4 4 # )aF 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� rp r$ )rh r� r� s && r` rG rG � s+ � � ��?�D��Y��D� �A�A� ��� � !�!rb c �� a� \ V 4 o\ S4 p\ \ \ V4 V4 4 p\ ;QJ d . V3R lV 4 F NK 5# ! V3R lV 4 4 # )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 3 �6 <" � T F pSV, x � K R # 5ir] r� �r� r� r� s & �r` r� �%random_combination.<locals>.<genexpr>� � �� � �*�'�Q��a���'�� �)r� rp r� r$ r� )rh r� rg �indicesr� s && @r` rF rF � sN �� � ��?�D� �D� �A��V�E�!�H�a�(�)�G� �5�*�'�*�5�*�5�*�'�*� *�*rb c �� aa� \ V 4 o\ S4 o\ V3R l\ V4 4 4 p\ ;QJ d . V3R lV 4 F NK 5# ! V3R lV 4 4 # )a; 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 �: <" � T F p\ S4 x � K R # 5ir] )r# �r� r� rg s & �r` r� �6random_combination_with_replacement.<locals>.<genexpr>� s �� � �4�8�a�Y�q�\�\�8�s �c 3 �6 <" � T F pSV, x � K R # 5ir] r� r� s & �r` r� r� � r� r� )r� rp r� r� )rh r� r� rg r� s && @@r` rE rE � sM �� � ��?�D� �D� �A��4�5��8�4�4�G� �5�*�'�*�5�*�5�*�'�*� *�*rb c �6 � \ V 4 p\ V4 pV^ 8 g W8� d \ h^p\ WV,
4 p\ ^V^, 4 F pWTV,
V, , V, pK" V^ 8 d W%,
pV^ 8 g W%8� d \
h. pV' dp WQ, V, V^,
V^,
rpW%8� d) W%, pWTV,
, V, V^,
rEK. VP
VRV,
, 4 Kw \ V4 # )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 or greater than the length
of *iterable*.
``IndexError`` will be raised if the given *index* is invalid.
r� )r� rp r� �minr� �
IndexErrorr� ) rh r� r" r� rg �cr� r� �results &&& r` r9 r9 � s� � � ��?�D� �D� �A� �A��1�5��� �A� �A�1�u�
�A�
�1�a�!�e�_��
�Q����O�q� �� �
�q�y�
�
��
�� �u�z���
�F�
��%�1�*�a�!�e�Q��U�a���j� �J�E��A��;�!�#�Q��U�q��
�
�d�2��6�l�#� ��=�rb c � � \ V .V4 # )a Yield *value*, followed by the elements in *iterator*.
>>> value = '0'
>>> iterator = ['1', '2', '3']
>>> list(prepend(value, iterator))
['0', '1', '2', '3']
To prepend multiple values, see :func:`itertools.chain`
or :func:`value_chain`.
)r
)�valuerw s &&r` rB rB � s � � �%��(� #�#rb c # � " � \ V4 RRR1, p\ V4 p\ ^ .VR7 V, p\ V \ ^ V^,
4 4 F! pVP V4 \
W4 x � K# R# 5i)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
Nrn r� )r� rp r r
r r� �_sumprod)�signal�kernelrg �windowr^ s && r` r+ r+ � si � � �F �6�]�4�R�4�
�F� �F� �A�
�A�3�q�
!�A�
%�F�
�6�6�!�Q��U�+�
,���
�
�a���v�&�&� -�s �A:A<c �^ � \ V4 w r#\ \ W4 \ V4 4 pW#3# )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� )� predicater� �trues�afters && r` r) r) & s, � � �r�7�L�E� �Y�y�0�#�e�*� =�E� �<�rb c � � \ V ^4 w rp\ VR4 \ VR4 \ VR4 \ WV4 # )z�Return overlapping triplets from *iterable*.
>>> list(triplewise('ABCDE'))
[('A', 'B', 'C'), ('B', 'C', 'D'), ('C', 'D', 'E')]
Nr� )rh r� r� �t3s & r` rU rU 9 s; � � �X�q�!�J�B�B���T�N���T�N���T�N� �r�r�?�rb c �~ � \ W4 p\ V4 F w r4\ \ WCV4 R 4 K \ V! # r] )r r� rv r r� )rh rg r� r� rw s && r` �_sliding_window_islicer
I s8 � ��H� �I� ��+� �� �V�H��
#�T�*� ,� � �?�rb c # � " � \ V 4 p\ \ W!^,
4 VR7 pV F! pVP V4 \ V4 x � K# R# 5i)r� rn N)rs r r r� r� )rh rg rw r r^ s && r` �_sliding_window_dequer Q sC � � ��H�~�H�
�6�(��E�*�1�
5�F�
���
�
�a���F�m�� �s �AAc � � V^8� d \ W4 # V^8� d \ W4 # V^8X d \ V 4 # V^8X d \ V 4 # \ RV 24 h)a= 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`.
z n should be at least one, not )r r
r< r� r� r� s &&r` rM rM Z s^ � � �2�v�$�X�1�1�
�Q��%�h�2�2�
�a����!�!�
�a���8�}� ��9�!��=�>�>rb c
� � \ V 4 p\ \ \ \ \ V4 ^, 4 ^4 4 p\
\ \ V4 V4 # )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.
) rf r �slicer r� rp rj r! r )rh �seq�slicess & r` rN rN s s@ � � �x�.�C�
�U�L��s�3�x�!�|�)<�a� @�
A�F� �w��s� �V� ,�,rb c �N � ^.pV F p\ \ V^V) 34 4 pK V# )uS 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.
)rf r+ )�roots�poly�roots & r` r? r? � s1 � �
�3�D����H�T�A��u�:�.�/�� � �Krb c # �L " � \ V RR4 pVf4 \ WV4 p\ WR4 F w rgWqJ g Wq8X g K Vx � K R# Vf \ V 4 MTpV^,
p\ \
4 ;_uu_ 4 V! W^, V4 ;px � K + ' g i R# ; i5i)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" N)�getattrr r� rp r r� )rh r rl �stop� seq_indexrw r� r� s &&&& r` r3 r3 � s� � � �2 ��'�4�0�I����(�4�0��#�H�4�J�A�� �7�#3��� 5�
!%� �s�8�}�$�� �A�I��
�j�
!�
!�� %�e��U�D� 9�9�q�:� "�
!�
!�s �6B$�;B$�8B� B! � B$c # � " � V ^8� d ^x � ^p\ R4 V ^, , p\ V^V\ V 4 ^, R7 Fd p\ V^WV, 4 Rj x�L
\ \ \ W3, WV, 4 4 4 W#V, WV, 1& W3, pKf \ V^V4 Rj x�L
R# Ld L5i)zYYield the primes less than n.
>>> list(sieve(30))
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
)r N)r� r� )� bytearrayr3 r �bytesrp r� )rg rl �datar� s & r` rL rL � s� � � � �1�u���
�E� �V� ��Q�� '�D�
��a��U�1�X��\�
:�� �d�A�u�!�e�4�4�4�"'��E�!�%���E�,B�(C�"D���U�Q�Q��
� ���� ;� �$��5�)�)�)� 5� *�s% �A C �"C�#A C � C �C � C rZ c # �� " � V^8 d \ R4 h\ V 4 p\ \ W14 4 ;p' d* V' d \ V4 V8w d \ R4 hVx � KE R# 5i)ar 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`.
zn must be at least onezbatched(): incomplete batchN)r� rs r� r rp )rh rg rZ rw �batchs &&$ r` �_batchedr# � s[ � � � �1�u��1�2�2��H�~�H����,�-�
-�%�
-� �c�%�j�A�o� � :�;� ;�� � .�s �AA'�#A'i�
)r( c � � \ WVR 7 # )rY )�itertools_batched)rh rg rZ s &&$r` r( r( � s � � ��V�<�<rb c � � \ V ! # )z�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.
)� _zip_strict�r� s &r` rT rT � s � � �� �rb c �T � \ V 4 \ Y4 # \ d R# i ; i)z.Scalars are bytes, strings, and non-iterables.T)rs rr �
isinstance)r �
stringlikes &&r` �
_is_scalarr, s/ � �� �U� � �e� (�(�� � ���s � � '�'c �� � \ V 4 p \ V4 p\ T3T4 p\ T4 ' d T# \ P
! T4 pKE \ d Tu # i ; i)z.Depth-first iterator over scalars in a tensor.)rs rv �
StopIterationr
r, r� )�tensorrw r s & r` �_flatten_tensorr0 sb � ��F�|�H�
� ���N�E� �%��8�,�� �e� � ��O��&�&�x�0��� � ��O� �s � A �
A!� A!c �� � \ V\ 4 ' d! \ \ P ! V 4 V4 # Vvr#\ V 4 p\
\ \ V4 V4 p\ WR4 # )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� r0 r �reversedr )�matrix�shape� first_dim�dims�
scalar_stream�reshapeds && r` rD rD sY � �B �%�� � ��u�*�*�6�2�E�:�:� ��I�#�F�+�M��g�x��~�}�=�H� �(� &�&rb c � � \ V^ , 4 p\ \ \ \ V \ V4 4 4 V4 # )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.
)rp r( r r r rT )�m1�m2rg s && r` r5 r5 @ s0 � � �B�q�E�
�A� �7�8�W�R��2� �%?�@�!� D�Drb c � � \ ^V 4 Fo p^;r#^pV^8X dW W", V, V , pW3, V, V , pW3, V, V , p\ W#,
V 4 pK] W@8w g Km Vu # \ R4 h)r� zprime or under 5)r� r r� )rg r� r^ r_ �ds & r` �_factor_pollardr? O sy � � �1�a�[��� ��
���1�f�����a��A�����a��A�����a��A��A�E�1�
�A� �6��H� � �'�
(�(rb c # �V " � V ^8 d R# \ F pW, ' d K Vx � W, p K . pV ^8� d V .M. pV FI p V R8 g \ V 4 ' d VP V 4 K. \ V 4 pW4W, 3,
pKK \ V4 Rj x�L
R# L5i)z�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.
Ni� )�_primes_below_211r1 r� r? r� )rg �prime�primes�todo�facts & r` r. r. b s� � � � �1�u�� #���)�)��K�
�K�A� #� �F��a�%�A�3�R�D�
�� �v�:��!��� �M�M�!� �"�1�%�D� �1�9�%� %�D� � �f�~� � �s � B)�A;B)� B'�!B)c � � \ V 4 pV^ 8X d \ V4 ! ^ 4 # \ \ \ V4 \ \
V4 4 4 p\ W4 # )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.
)rp �typerj �powr r3 r� r )� coefficientsr^ rg �powerss && r` r> r> � sI � � �L��A��A�v��A�w�q�z��
��f�Q�i��%��(�!3�
4�F� �L� )�)rb c �& � \ \ V 4 ! # )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( s &r` rO rO � s � � �S��W� � rb c �t � \ V 4 p\ \ ^V4 4 p\ \ \
W4 4 # )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.
)rp r3 r� rf rj r )rI rg rJ s & r` r@ r@ � s0 � � �L��A�
�e�A�q�k�
"�F� ��C� �.� /�/rb c �Z � \ \ V 4 4 F pW V, , p K V # )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� r. )rg rB s & r` rS rS � s& � �& �V�A�Y� �� �%�Z��� � �Hrb c � � V ^,
V , P 4 ^,
pW, p^V, V, V 8X d V^, ' d V^ 8� g Q hW3# )z#Return s, d such that 2**s * d == n)�
bit_length)rg r� r> s & r` �
_shift_to_oddrP � sQ � � �a�%�1�� � �"�Q�&�A� ��A�
��F�a�<�1� ��Q���1��6�1� 1� �4�Krb c �6 � V ^8� d" V ^, ' d ^Tu;8: d V 8 g Q h Q h\ V ^,
4 w r#\ WV 4 pV^8X g W@^,
8X d R# \ V^,
4 F" pWD, V , pW@^,
8X g K! R# R# )� TF)rP rH r� )rg �baser� r> r^ �_s && r` �_strong_probable_primerU � s� � �
��E��A���A��M��M�2� 2�M�2� 2� ��Q�� �D�A� �D�Q��A��A�v��!�e���
�1�q�5�\��
�E�A�I�� �A��:�� �
rb c � a � S ^8 d S R9 # S ^, ' dL S ^, ' d= S ^, ' d. S ^, ' d S ^ , ' d S ^
, ' g R# \ F w rS V8 g K M V 3R l\ ^@4 4 p\ ;QJ d V 3R lV 4 F ' d K R# R# ! V 3R lV 4 4 # )am 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.
Fc 3 �J <" � T F p\ ^S^,
4 x � K R# 5i)rR N)�_private_randranger� s & �r` r� �is_prime.<locals>.<genexpr>* s �� � �A�y�!�#�A�q�1�u�-�-�y�s � #c 3 �< <" � T F p\ SV4 x � K R # 5ir] )rU )r� rS rg s & �r` r� rY , s �� � �A�5�4�%�a��.�.�5�r� T> rR � � � � �
)�_perfect_testsr� �all)rg �limit�basess f r` r1 r1 � s� �� �B �2�v��(�(�(�
��E�E�a�!�e�e��A���!�a�%�%�A��F�F�q�2�v�v��&� �� �u�9� � '� B�u�R�y�A�� �3�A�5�A�3�3�A�3�A�3�A�5�A� A�Arb c � � \ RV 4 # )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
N)r )rg s &r` r4 r4 / s � � �$��?�rb c �H � \ \ \ \ V 4 V 4 4 # )ue 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 )�countss *r` r6 r6 = s � �T ��D�*�V�,�f�5� 6�6rb c
# �F " � V P p. p. p\ \ 4 ;_uu_ 4 \ V\ W1! 4 4 4 V^ , x � \ V\
W!! 4 4 4 V^ , V^ , , ^, x � Kb + ' g i R# ; i5i)z.Non-windowed running_median() for Python 3.14+N)�__next__r r. rc r r
rd �rw �read�lo�his & r` �#_running_median_minheap_and_maxheaprm j s{ � � � � � �D� �B� �B� �-� � �� ��[��T�V� 4� 5��Q�%�K� �R� ��T�V�4� 5��a�5�2�a�5�=�A�%� %�
!� � �s �(B!�A#B
�
B � B!c
# �N " � V P p. p. p\ \ 4 ;_uu_ 4 \ V\ W1! 4 4 ) 4 V^ , ) x � \ V\ W!! 4 ) 4 ) 4 V^ , V^ , ,
^, x � Kf + ' g i R# ; i5i)zDBackport of non-windowed running_median() for Python 3.13 and prior.N)rh r r. r
r ri s & r` � _running_median_minheap_onlyro z s� � � � � � �D� �B� �B� �-� � �� �R�+�b�$�&�1�1� 2��a�5�&�L� �R�+�b�4�6�'�2�2� 3��a�5�2�a�5�=�A�%� %�
!� � �s �(B%�A'B� B" � B%c # �f " � \ 4 p. pV F� pVP V4 \ W44 \ V4 V8� d \ W2P 4 4 pW5 \ V4 pV^, pV^, ' d W7, M"W7^,
, W7, , ^, x � K� R# 5i)z+Yield median of values in a sliding window.N)r r� r rp r �popleft)rw ro r �orderedr^ r� rg �ms && r` �_running_median_windowedrt � s� � � � �W�F��G�
���
�
�a���w�� �w�<�&� ��G�^�^�%5�6�A��
� ��L��
��F�� ��E�E�g�j��A�����(C�q�'H�H� �s �B/B1ro c � � \ V 4 pVe) \ V4 pV^ 8: d \ R4 h\ W!4 # \ ' g \ V4 # \
V4 # )a 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().
z Window size should be positive)rs r" r� rt �_max_heap_availablero rm )rh ro rw s &$ r` rK rK � sV � �. �H�~�H�
���v� �� �Q�;� � =�>� >�'��9�9� � �+�H�5�5� .�x� 8�8rb )r� r] )r� N)NF)NN)r� N))i� )rR )i�� )� �I )l �tT7 )rR r] �= )l �ay)rR r_ � iS_ )l ;n>�)rR r[ r\ r] r^ )l � p� )rR r[ r\ r] r^ r_ )l )rR iE i�$ in i�� i=� i��k)l �%!H�n
�fW )
rR r[ r\ r] r^ r_ � � rz � rw �% �) )��__doc__�random�bisectr r � collectionsr �
contextlibr � functoolsr r r �heapqr
r � itertoolsr 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% �sysr& �__all__�objectr� r� r' rr r[ r � ImportErrorrc rd rv rR rP rQ r* r8 r' r� rC r; r: r7 r, r/ rI r� r< r� r� r� r� r� r0 rJ r= rA rW rX rV r2 r- rH rG rF rE r9 rB r+ r) rU r
r rM rN r? r3 rL r# r( r% rT �strr r, r0 rD r5 r? r� rA r. r> rO r@ rS r` rP rU �RandomrX r1 r4 r6 rm ro rt rK r� rb r` �<module>r� s� ��� � &� � � 0� 0� '�� � � � (� '� :� :� ,� ,� �3 ��3 �
�3 � �3 � � 3 �
� 3 � �
3 � �3 �
�3 � �3 � �3 � �3 � �3 � �3 � � 3 �
� 3 � �!3 �" �#3 �$
�%3 �& �'3 �( �)3 �* �+3 �, �-3 �. �/3 �0 �13 �2 �33 �4 �53 �6 �73 �8 �93 �: �;3 �< �=3 �> *�?3 �@ �A3 �B �C3 �D �E3 �F �G3 �H �I3 �J �K3 �L �M3 �N �O3 �P �Q3 �R �S3 �T �U3 �V �W3 �X �Y3 �Z �[3 �\ �]3 �^ �_3 �`
�a3 �b �c3 �d �e3 ��j �(��,��t�� �#�d�+�K�-�(� �3� ��
%� '�$
8� %+�P
4��4 !� $� )� ��;�
%� ,�.�6 � )�8�
,� !�(�(�H�� �J� ��
/� %=�P(�$;�8N�** �Z A� /�(�:1�(1�� 1�("�$
+� +�"'�T $� ('�V�&
� � �?�2 -� �,&;�R*�*�E� �( ���6�=�u� =� �&�&�G�O��G� � #&�u� � )� 1� &'�R E�
)� �%��*�%� � �B*�. �0�&
�2 �� �� ���& �]�]�_�.�.� �-B�` � *7�Z
&�
&� I�&"9�t� "9��w) � ��K��� � -�,�H�-�� � � �� ��` � ��H��sH �% I3 �9J � J �J$ �3 J �?J �
J�J� J!� J!�$ J1�0J1