Sindbad~EG File Manager
�
�X�fR}��Z
�dZddlmZmZddlZeee�Zed�Z d�Z
ee
�Z[
gd�ZdZ
eed��Zeee���Zeeij%���Zeeij)���Zeeij-���Zeeg��Zeeeg���Zeeed���Zeeed d
z���Zeee���Zeed��Z eed��Z!eee"���Z#eij%��Z$eij)��Z%eij-��Z&eejN�Z(ed
���Z)d�Z*e*�Z*ee*�Z+e*jY�[*d�Z-e-�Z-ee-�Z.[-d�Z/Gd�de��Z0Gd�de��Z1Gd�de1�Z2e2jge+�Gd�de��Z4Gd�de4�Z5Gd�de5�Z6e6jge.�Gd�de��Z7Gd �d!e7�Z8e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge �e8jge!�e8jge#�Gd"�d#e7�Z9Gd$�d%e8�Z:e:jge)�Gd&�d'e��Z;Gd(�d)e��Z<Gd*�d+e;e7e<�Z=Gd,�d-e��Z>Gd.�d/e�Z?d0�Z@d1�ZAGd2�d3e��ZBGd4�d5e=�ZCeCjgeD�Gd6�d7eC�ZEeEjge�Gd8�d9e=�ZFeFjge(�Gd:�d;e;�ZGGd<�d=eGeC�ZHeHjge$�Gd>�d?eGeC�ZIeIjge&�Gd@�dAeGe=�ZJeJjge%�GdB�dCeF�ZKeKjgeL�GdD�dEe9e=�ZMeMjgeN�eMjgeO�eMjge�eMjgeP�GdF�dGe�ZQGdH�dIeMeQ��ZReRjgeS�eRjge�GdJ�dKeM�ZTeTjge�eTjge�y)LzjAbstract Base Classes (ABCs) for collections, according to PEP 3119.
Unit tests are in test_collections.
�)�ABCMeta�abstractmethodN.c��y�N�r��./usr/src/Python-3.12.7/Lib/_collections_abc.py�_fr
(s��$r)� Awaitable� Coroutine�
AsyncIterable�
AsyncIterator�AsyncGenerator�Hashable�Iterable�Iterator� Generator�
Reversible�Sized� Container�Callable�
Collection�Set�
MutableSet�Mapping�MutableMapping�MappingView�KeysView� ItemsView�
ValuesView�Sequence�MutableSequence�
ByteString�Bufferzcollections.abcr�i��rc#�K�d��Srrrrr �<lambda>r(Xs����5rc��K�y�wrrrrr �_coror*Zs����4���c�K�d���y�wrrrrr �_agr-`s������� c��|j}|D]9}|D]+}||jvs�|j|�
tccS�2tcSy)NT)�__mro__�__dict__�NotImplemented)�C�methods�mro�method�Bs r �_check_methodsr8hsP��
�)�)�C����A�����#��:�:�f�%�-�)�)�� �"�!��rc�0�eZdZdZed��Zed��Zy)rrc��y�Nrr��selfs r �__hash__zHashable.__hash__x���rc�6�|turt|d�StS)Nr>)rr8r2��clsr3s r �__subclasshook__zHashable.__subclasshook__|����(�?�!�!�Z�0�0��rN)�__name__�
__module__�__qualname__� __slots__rr>�classmethodrCrrr rrt�-���I��������rr)� metaclassc�@�eZdZdZed��Zed��Zee�Z y)rrc#�K�d��y�wrrr<s r � __await__zAwaitable.__await__�s ����
�s�c�6�|turt|d�StS)NrN)rr8r2rAs r rCzAwaitable.__subclasshook__�s���)��!�!�[�1�1��rN)
rErFrGrHrrNrIrC�GenericAlias�__class_getitem__rrr rr�s:���I���������
$�L�1�rrc�H�eZdZdZed��Zedd��Zd�Zed��Z y)rrc��t�)zcSend a value into the coroutine.
Return next yielded value or raise StopIteration.
��
StopIteration�r=�values r �sendzCoroutine.send��
��
�rNc�F�|�|�|�|�}|�|j|�}|�)zgRaise an exception in the coroutine.
Return next yielded value or raise StopIteration.
��with_traceback�r=�typ�val�tbs r �throwzCoroutine.throw��4��
�;��z�� ��%�C�
�>��$�$�R�(�C�� rc�n� |jt�td��#ttf$rYywxYw)�.Raise GeneratorExit inside coroutine.
zcoroutine ignored GeneratorExitN�ra�
GeneratorExit�RuntimeErrorrUr<s r �closezCoroutine.close��;�� B��J�J�}�%��@�A�A���}�-� �� ���"�4�4c�<�|turt|dddd�StS)NrNrXrarh)rr8r2rAs r rCzCoroutine.__subclasshook__�s#���)��!�!�[�&�'�7�K�K��r�NN)
rErFrGrHrrXrarhrIrCrrr rr�sG���I������
��
�B����rrc�@�eZdZdZed��Zed��Zee�Z y)r
rc��t�Sr)rr<s r � __aiter__zAsyncIterable.__aiter__�s
����rc�6�|turt|d�StS)Nro)r
r8r2rAs r rCzAsyncIterable.__subclasshook__�s���-��!�!�[�1�1��rN)
rErFrGrHrrorIrCrPrQrrr r
r
�s:���I���������
$�L�1�rr
c�6�eZdZdZed��Zd�Zed��Zy)rrc��K�t��w)z@Return the next item or raise StopAsyncIteration when exhausted.��StopAsyncIterationr<s r � __anext__zAsyncIterator.__anext__�s����!� �r.c��|Srrr<s r rozAsyncIterator.__aiter__�����rc�8�|tur
t|dd�StS)Nruro)rr8r2rAs r rCzAsyncIterator.__subclasshook__�s���-��!�!�[�+�>�>��rN) rErFrGrHrrurorIrCrrr rr�s2���I��!��!�����rrc�N�eZdZdZd�Zed��Zedd��Zd�Ze d��Z
y) rrc��@K�|jd��d{���S7��w)zpReturn the next item from the asynchronous generator.
When exhausted, raise StopAsyncIteration.
N)�asendr<s r ruzAsyncGenerator.__anext__�s�����Z�Z��%�%�%�%�s���c��K�t��w)zuSend a value into the asynchronous generator.
Return next yielded value or raise StopAsyncIteration.
rsrVs r r{zAsyncGenerator.asend�s����
!� �r.Nc��NK�|�|�|�|�}|�|j|�}|��w)zyRaise an exception in the asynchronous generator.
Return next yielded value or raise StopAsyncIteration.
r[r]s r �athrowzAsyncGenerator.athrow�s8����
�;��z�� ��%�C�
�>��$�$�R�(�C�� �s�#%c��K� |jt��d{���td��7�#ttf$rYywxYw�w)rdNz,asynchronous generator ignored GeneratorExit)r~rfrgrtr<s r �aclosezAsyncGenerator.aclosesH���� O��+�+�m�,�,�,��M�N�N�
-���1�2� �� �s/�A�.�,�.�A�.�A�A�A�Ac�>�|turt|ddddd�StS)Nrorur{r~r�)rr8r2rAs r rCzAsyncGenerator.__subclasshook__s*���.� �!�!�[�+�")�8�X�?�
?��rrl)rErFrGrHrurr{r~r�rIrCrrr rr�sN���I�&��!��!��
��
�O����rrc�@�eZdZdZed��Zed��Zee�Z y)rrc#�K�y�wrrr<s r �__iter__zIterable.__iter__� �����r+c�6�|turt|d�StS)Nr�)rr8r2rAs r rCzIterable.__subclasshook__ rDrN)
rErFrGrHrr�rIrCrPrQrrr rrs:���I���������
$�L�1�rrc�6�eZdZdZed��Zd�Zed��Zy)rrc��t�)zKReturn the next item from the iterator. When exhausted, raise StopIterationrTr<s r �__next__zIterator.__next__-s
���rc��|Srrr<s r r�zIterator.__iter__2rwrc�8�|tur
t|dd�StS)Nr�r�)rr8r2rAs r rCzIterator.__subclasshook__5s���(�?�!�!�Z��<�<��rN) rErFrGrHrr�r�rIrCrrr rr)s2���I���������rrc�0�eZdZdZed��Zed��Zy)rrc#�K�y�wrrr<s r �__reversed__zReversible.__reversed__Pr�r+c�8�|tur
t|dd�StS)Nr�r�)rr8r2rAs r rCzReversible.__subclasshook__Us���*��!�!�^�Z�@�@��rN)rErFrGrHrr�rIrCrrr rrLs-���I��������rrc�N�eZdZdZd�Zed��Zedd��Zd�Ze d��Z
y) rrc�$�|jd�S)z^Return the next item from the generator.
When exhausted, raise StopIteration.
N)rXr<s r r�zGenerator.__next__`s���y�y���rc��t�)zcSend a value into the generator.
Return next yielded value or raise StopIteration.
rTrVs r rXzGenerator.sendfrYrNc�F�|�|�|�|�}|�|j|�}|�)zgRaise an exception in the generator.
Return next yielded value or raise StopIteration.
r[r]s r razGenerator.throwmrbrc�n� |jt�td��#ttf$rYywxYw)z.Raise GeneratorExit inside generator.
zgenerator ignored GeneratorExitNrer<s r rhzGenerator.closezrirjc�>�|turt|ddddd�StS)Nr�r�rXrarh)rr8r2rAs r rCzGenerator.__subclasshook__�s*���)��!�!�Z��"(�'�7�<�
<��rrl)rErFrGrHr�rrXrarhrIrCrrr rr\sN���I�������
��
�B����rrc�0�eZdZdZed��Zed��Zy)rrc��yr;rr<s r �__len__z
Sized.__len__�r?rc�6�|turt|d�StS)Nr�)rr8r2rAs r rCzSized.__subclasshook__�s���%�<�!�!�Y�/�/��rN)rErFrGrHrr�rIrCrrr rr�rJrrc�@�eZdZdZed��Zed��Zee�Z y)rrc��y�NFr)r=�xs r �__contains__zContainer.__contains__����rc�6�|turt|d�StS)Nr�)rr8r2rAs r rCzContainer.__subclasshook__�s���)��!�!�^�4�4��rN)
rErFrGrHrr�rIrCrPrQrrr rr�s:���I���������
$�L�1�rrc� �eZdZdZed��Zy)rrc�:�|turt|ddd�StS)Nr�r�r�)rr8r2rAs r rCzCollection.__subclasshook__�s!���*��!�!�i��^�L�L��rN)rErFrGrHrIrCrrr rr�s���I����rrc�:�eZdZdZededefd��Zed��Z y)r$r�flags�returnc��t�r��NotImplementedError)r=r�s r �
__buffer__zBuffer.__buffer__�s��!�!rc�6�|turt|d�StS)Nr�)r$r8r2rAs r rCzBuffer.__subclasshook__�s���&�=�!�!�\�2�2��rN)
rErFrGrHr�int�
memoryviewr�rIrCrrr r$r$�s;���I��"��"�:�"��"����rr$c�@��eZdZdZdZ�fd�Z�fd�Zd�Z�fd�Z�xZ S)�_CallableGenericAliasz� Represent `Callable[argtypes, resulttype]`.
This sets ``__args__`` to a tuple containing the flattened ``argtypes``
followed by ``resulttype``.
Example: ``Callable[[int, str], float]`` sets ``__args__`` to
``(int, str, float)``.
rc����t|t�rt|�dk(std��|\}}t|ttf�rg|�|��}nt|�std|����t�|�|||�S)N�z6Callable must be used as Callable[[arg, ...], result].zFExpected a list of types, an ellipsis, ParamSpec, or Concatenate. Got )�
isinstance�tuple�len� TypeError�list�_is_param_expr�super�__new__)rB�origin�args�t_args�t_result� __class__s �r r�z_CallableGenericAlias.__new__�s�����4��'�C��I��N��H�J�
J������f�u�d�m�,�&�V�&�X�&�D���'��>�>D�X�G�H�
H��w��s�F�D�1�1rc �.��t|j�dk(r&t|jd�rt�|��Sddj|jddD�cgc]
}t
|���c}��dt
|jd��d�Scc}w)Nr�rzcollections.abc.Callable[[z, ���z], �])r��__args__r�r��__repr__�join�
_type_repr)r=�ar�s �r r�z_CallableGenericAlias.__repr__�s�����t�}�}���"�~�d�m�m�A�6F�'G��7�#�%�%���Y�Y�t�}�}�S�b�7I�J�7I�!�
�1�
�7I�J�K�L�C��d�m�m�B�/�0�1��4� 5��Js�B
c��|j}t|�dk(rt|d�st|dd�|df}tt
|ffS)Nr�rr�)r�r�r�r�r�r)r=r�s r �
__reduce__z _CallableGenericAlias.__reduce__�sI���}�}���D� �Q��>�$�q�'�#:���S�b� �?�D��H�,�D�$�x��&6�6�6rc����t|t�s|f}t�|�
|�j}t|dtt
f�s|d}|dd}||f}t
tt|��S)Nrr�)r�r�r��__getitem__r�r�r�r)r=�item�new_argsr�r�r�s �r r�z!_CallableGenericAlias.__getitem__�sn���
�$��&��7�D��7�&�t�,�5�5���(�1�+��t�}�5���|�H��c�r�]�F���)�H�$�X�u�X��?�?r)
rErFrG�__doc__rHr�r�r�r��
__classcell__�r�s@r r�r��s*�����I�
2�5�7�@�@rr�c����turyt�t�ryt���d}�jdk(xrt�fd�|D��S)z|Checks if obj matches either a list of types, ``...``, ``ParamSpec`` or
``_ConcatenateGenericAlias`` from typing.py
T)� ParamSpec�_ConcatenateGenericAlias�typingc3�<�K�|]}�j|k(���y�wr)rE)�.0�name�objs �r � <genexpr>z!_is_param_expr.<locals>.<genexpr> s�����-U�u�t�c�l�l�d�.B�u�s�)�Ellipsisr�r��typerF�any)r��namess` r r�r��sI����h����#�t���
�s�)�C�5�E��>�>�X�%�U�#�-U�u�-U�*U�Urc���t|t�r6|jdk(r|jS|j�d|j��S|turyt|t
�r|jSt|�S)z�Return the repr() of an object, special-casing types (internal helper).
Copied from :mod:`typing` since collections.abc
shouldn't depend on that module.
(Keep this roughly in sync with the typing version.)
�builtins�.z...)r�r�rFrGr��FunctionTyperE�repr)r�s r r�r�sk���#�t���>�>�Z�'��#�#�#��.�.�!��3�#3�#3�"4�5�5�
�h����#�|�$��|�|����9�rc�@�eZdZdZed��Zed��Zee�Z y)rrc��yr�r)r=r��kwdss r �__call__zCallable.__call__!r�rc�6�|turt|d�StS)Nr�)rr8r2rAs r rCzCallable.__subclasshook__%rDrN)
rErFrGrHrr�rIrCr�rQrrr rrs;���I���������
$�$9�:�rrc�x�eZdZdZdZd�Zd�Zd�Zd�Zd�Z e
d��Zd �ZeZ
d
�Zd�ZeZd�Zd
�Zd�ZeZd�Zy)raZA set is a finite, iterable container.
This class provides concrete generic implementations of all
methods except for __contains__, __iter__ and __len__.
To override the comparisons (presumably for speed, as the
semantics are fixed), redefine __le__ and __ge__,
then the other operations will automatically follow suit.
rc�z�t|t�stSt|�t|�kDry|D]}||vs�yy�NFT�r�rr2r��r=�other�elems r �__le__z
Set.__le__>s?���%��%�!�!��t�9�s�5�z�!���D��5� ���rc��t|t�stSt|�t|�kxr|j |�Sr�r�rr2r�r��r=r�s r �__lt__z
Set.__lt__H�3���%��%�!�!��4�y�3�u�:�%�<�$�+�+�e�*<�<rc��t|t�stSt|�t|�kDxr|j |�Sr)r�rr2r��__ge__r�s r �__gt__z
Set.__gt__Mr�rc�z�t|t�stSt|�t|�kry|D]}||vs�yyr�r�r�s r r�z
Set.__ge__Rs?���%��%�!�!��t�9�s�5�z�!���D��4����rc��t|t�stSt|�t|�k(xr|j |�Srr�r�s r �__eq__z
Set.__eq__\s3���%��%�!�!��4�y�C��J�&�=�4�;�;�u�+=�=rc��||�S)z�Construct an instance of the class from any iterable input.
Must override this method if the class constructor signature
does not accept an iterable for an input.
r�rB�its r �_from_iterablezSet._from_iterableas
���2�w�rc�d��t|t�stS�j�fd�|D��S)Nc3�,�K�|]}|�vs�|���
y�wrr�r�rWr=s �r r�zSet.__and__.<locals>.<genexpr>ms�����"M�e�U�u��}�5�e�s� ��r�rr2r�r�s` r �__and__zSet.__and__js*����%��*�!�!��"�"�"M�e�"M�M�Mrc��|D]}||vs�yy)z1Return True if two sets have a null intersection.FTr)r=r�rWs r �
isdisjointzSet.isdisjointqs���E���}���rc�f�t|t�stSd�||fD�}|j|�S)Nc3�.K�|]
}|D]}|����y�wrr)r��s�es r r�zSet.__or__.<locals>.<genexpr>{s����5�M�q�1�a��1��M�s�r)r=r��chains r �__or__z
Set.__or__xs1���%��*�!�!�5�T�5�M�5���"�"�5�)�)rc���t�t�s't�t�stS|j ���|j �fd�|D��S)Nc3�*�K�|]
}|�vr|���y�wrr)r�rWr�s �r r�zSet.__sub__.<locals>.<genexpr>�s�����#:�d�U�&+�5�&8�$)�d����r�rrr2r�r�s `r �__sub__zSet.__sub__�sL����%��%��e�X�.�%�%��'�'��.�E��"�"�#:�d�#:�:� :rc���t|t�s't|t�stS�j |�}�j �fd�|D��S)Nc3�*�K�|]
}|�vr|���y�wrrr�s �r r�zSet.__rsub__.<locals>.<genexpr>�s�����#9�e�U�&+�4�&7�$)�e�rr
r�s` r �__rsub__zSet.__rsub__�sL����%��%��e�X�.�%�%��'�'��.�E��"�"�#9�e�#9�9� 9rc��t|t�s't|t�stS|j |�}||z
||z
zSrr
r�s r �__xor__zSet.__xor__�s?���%��%��e�X�.�%�%��'�'��.�E��u�����.�.rc��tj}d|zdz}t|�}d|dzz}||z}|D]#}t|�}|||dzzdzdzz}||z}�%||dz |dz zz}|d zd
z}||z}||kDr||dzz}|dk(rd}|S)
a+Compute the hash value of a set.
Note that we don't define __hash__: not all sets are hashable.
But if you define a hashable set type, its __hash__ should
call this function.
This must be compatible __eq__.
All sets ought to compare equal if they contain the same
elements, regardless of how they are implemented, and
regardless of the order of the elements; so there's not much
freedom for __eq__ or __hash__. We match the algorithm used
by the built-in frozenset type.
r�r%iM��r�i�M[l�4~2��i�
i��6r�i��8#)�sys�maxsizer��hash)r=�MAX�MASK�n�hr��hxs r �_hashz Set._hash�s����k�k���3�w��{����I���!�a�%� �� �T� ���A��a��B�
�"��b��/�H�,��;�;�A�
��I�A��
�a�2�g�!�r�'�
"�"��
��I� �!�� �T� ���s�7�
����M�A���7��A��rN)rErFrGr�rHr�r�r�r�r�rIr�r�__rand__rr �__ror__rrr�__rxor__r rrr rr1st����I��=�
=�
�>�
����N�
�H��*��G�:�9�/��H�rrc�^�eZdZdZdZed��Zed��Zd�Zd�Z d�Z
d�Zd �Zd
�Z
d�Zy)
ra�A mutable set is a finite, iterable container.
This class provides concrete generic implementations of all
methods except for __contains__, __iter__, __len__,
add(), and discard().
To override the comparisons (presumably for speed, as the
semantics are fixed), all you have to do is redefine __le__ and
then the other operations will automatically follow suit.
rc��t�)zAdd an element.r�rVs r �addzMutableSet.add��
��"�!rc��t�)z8Remove an element. Do not raise an exception if absent.r�rVs r �discardzMutableSet.discard�r'rc�D�||vrt|��|j|�y)z5Remove an element. If not a member, raise a KeyError.N)�KeyErrorr)rVs r �removezMutableSet.remove�s ������5�/�!����U�rc�~�t|�} t|�}|j |�|S#t$rtd�wxYw)z2Return the popped value. Raise KeyError if empty.N)�iter�nextrUr+r)�r=r�rWs r �popzMutableSet.pop�sE��
�$�Z�� %���H�E�
���U������ %���$� %�s�+�<c�F� |j��#t$rYywxYw)z6This is slow (creates N new iterators!) but effective.N)r1r+r<s r �clearzMutableSet.clear�s*�� �����
���� �� ���� � c�6�|D]}|j|��|Sr)r&r0s r �__ior__zMutableSet.__ior__�s���E��H�H�U�O���rc�<�||z
D]}|j|��|Sr)r)r0s r �__iand__zMutableSet.__iand__�s!���R�i�E��L�L��� ��rc���||ur|j�|St|t�s|j|�}|D])}||vr|j |��|j|��+|Sr)r3r�rr�r)r&r0s r �__ixor__zMutableSet.__ixor__�sd��
��:��J�J�L����b�#�&��(�(��,�����D�=��L�L��'��H�H�U�O� �
�rc�b�||ur|j�|S|D]}|j|��|Sr)r3r)r0s r �__isub__zMutableSet.__isub__s6��
��:��J�J�L��������U�#���rN)rErFrGr�rHrr&r)r,r1r3r6r8r:r<rrr rr�sW�� ��I��"��"��"��"�����
�
�rrc�R�eZdZdZdZdZed��Zdd�Zd�Z d�Z
d �Zd
�Zd�Z
dZy)
rz�A Mapping is a generic container for associating key/value
pairs.
This class provides concrete generic implementations of all
methods except for __getitem__, __iter__, and __len__.
r�@c��t�r�r+�r=�keys r r�zMapping.__getitem__ ����rNc�0� ||S#t$r|cYSwxYw)z<D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.r@�r=rB�defaults r �getzMapping.get$s%�� ���9���� ��N� �s���c�.� ||y#t$rYywxYw�NTFr@rAs r r�zMapping.__contains__+s'�� ���I���� �� �s�� �c��t|�S)z:D.keys() -> a set-like object providing a view on D's keys)rr<s r �keyszMapping.keys3s����~�rc��t|�S)z<D.items() -> a set-like object providing a view on D's items)rr<s r �itemsz
Mapping.items7s�����rc��t|�S)z6D.values() -> an object providing a view on D's values)r r<s r �valueszMapping.values;s
���$��rc��t|t�stSt|j ��t|j ��k(Sr)r�rr2�dictrMr�s r r�zMapping.__eq__?s3���%��)�!�!��D�J�J�L�!�T�%�+�+�-�%8�8�8rr)rErFrGr�rH�__abc_tpflags__rr�rGr�rKrMrOr�r�rrr rrsL����I��O��������� �9�
�Lrrc�2�eZdZdZd�Zd�Zd�Zee�Z y)r��_mappingc��||_yrrT)r=�mappings r �__init__zMappingView.__init__Ms ����
rc�,�t|j�Sr)r�rUr<s r r�zMappingView.__len__Ps���4�=�=�!�!rc�$�dj|�S)Nz&{0.__class__.__name__}({0._mapping!r}))�formatr<s r r�zMappingView.__repr__Ss��7�>�>�t�D�DrN)
rErFrGrHrXr�r�rIrPrQrrr rrIs$���I� �"�E�$�L�1�rrc�,�eZdZdZed��Zd�Zd�Zy)rrc��t|�Sr��setr�s r r�zKeysView._from_iterable]����2�w�rc��||jvSrrTrAs r r�zKeysView.__contains__as���d�m�m�#�#rc#�8K�|jEd{���y7��wrrTr<s r r�zKeysView.__iter__ds�����=�=� � �s���N�rErFrGrHrIr�r�r�rrr rrYs#���I�����$�!rrc�,�eZdZdZed��Zd�Zd�Zy)rrc��t|�Srr^r�s r r�zItemsView._from_iterableor`rc�`�|\}} |j|}||uxs||k(S#t$rYywxYwr�)rUr+)r=r�rBrW�vs r r�zItemsView.__contains__ssG���
��U� ,��
�
�c�"�A���:�+��e��+��� �� �s�!� -�-c#�TK�|jD]}||j|f���y�wrrTrAs r r�zItemsView.__iter__|s(�����=�=�C���
�
�c�*�+�+�!�s�&(Nrcrrr rrks#���I�����,�,rrc��eZdZdZd�Zd�Zy)r rc�Z�|jD]}|j|}||us||k(s�yyrIrT)r=rWrBrgs r r�zValuesView.__contains__�s3���=�=�C��
�
�c�"�A��E�z�Q�%�Z��!�rc#�PK�|jD]}|j|���y�wrrTrAs r r�zValuesView.__iter__�s#�����=�=�C��-�-��$�$�!�s�$&N)rErFrGrHr�r�rrr r r �s���I��%rr c�h�eZdZdZdZed��Zed��Ze�Z e fd�Z
d�Zd�Zdd�Z
dd
�Zy )
rz�A MutableMapping is a generic container for associating
key/value pairs.
This class provides concrete generic implementations of all
methods except for __getitem__, __setitem__, __delitem__,
__iter__, and __len__.
rc��t�rr@�r=rBrWs r �__setitem__zMutableMapping.__setitem__�rCrc��t�rr@rAs r �__delitem__zMutableMapping.__delitem__�rCrc�X� ||}||=|S#t$r||jur�|cYSwxYw)z�D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised.
)r+�_MutableMapping__marker)r=rBrFrWs r r1zMutableMapping.pop�sC�� ���I�E��S� ��L��
� ��$�-�-�'���N� �s��)�)c�l� tt|��}||}||=||fS#t$rtd�wxYw)z�D.popitem() -> (k, v), remove and return some (key, value) pair
as a 2-tuple; but raise KeyError if D is empty.
N)r/r.rUr+rns r �popitemzMutableMapping.popitem�sJ�� %��t�D�z�"�C��S� ����I��E�z��� � %���$� %�s�"�3c�F� |j��#t$rYywxYw)z,D.clear() -> None. Remove all items from D.N)rur+r<s r r3zMutableMapping.clear�s*�� ��������� �� �r4c���t|t�r|D]
}||||<�n9t|d�r|j�D]
}||||<�n|D]
\}}|||<�|j �D]
\}}|||<�y)aK D.update([E, ]**F) -> None. Update D from mapping/iterable E and F.
If E present and has a .keys() method, does: for k in E: D[k] = E[k]
If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k, v in F.items(): D[k] = v
rKN)r�r�hasattrrKrM)r=r�r�rBrWs r �updatezMutableMapping.update�s����e�W�%���!�#�J��S� ��
�U�F�
#��z�z�|��!�#�J��S� �$�$�
��U�!��S� �$��*�*�,�J�C���D��I�'rNc�8� ||S#t$r |||<Y|SwxYw)z@D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in Dr@rEs r �
setdefaultzMutableMapping.setdefault�s.�� ���9���� ��D��I��� �s���)rr)rErFrGr�rHrrorq�objectrsr1rur3ryr{rrr rr�sY����I����������x�H�'��
���$rrc�H�eZdZdZdZdZed��Zd�Zd�Z d�Z
dd �Zd
�Zy)r!z�All the operations on a read-only sequence.
Concrete subclasses must override __new__ or __init__,
__getitem__, and __len__.
r� c��t�r��
IndexError�r=�indexs r r�zSequence.__getitem__�����rc#�NK�d} ||}|��|dz
}�#t$rYywxYw�w)Nrr%r�)r=�irgs r r�zSequence.__iter__�sB����
�� ����G�����Q������ �� �s�%�� "�%�"�%c�(�|D]
}||us||k(s�
yyrIr)r=rWrgs r r�zSequence.__contains__s!���A��E�z�Q�%�Z���rc#�^K�ttt|���D] }||���y�wr)�reversed�ranger�)r=r�s r r�zSequence.__reversed__s'�����%��D� �*�+�A��q�'�M�,�s�+-Nc���|�|dkrtt|�|zd�}|�|dkr|t|�z
}|}|�||kr ||}||us||k(r|S|dz
}|��||kr�t�#t$rYt�wxYw)z�S.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
Supporting start and stop arguments is optional, but
recommended.
rr%)�maxr�r��
ValueError)r=rW�start�stopr�rgs r r�zSequence.indexs����������D� �E�)�1�-�E����q���C��I��D����l�a�$�h�
���G���E�z�Q�%�Z���
��F�A��l�a�$�h�����
����
�s�A#�# A4�3A4c�,��t�fd�|D��S)zBS.count(value) -> integer -- return number of occurrences of valuec3�6�K�|]}|�us|�k(s�
d���y�w)r%Nr)r�rgrWs �r r�z!Sequence.count.<locals>.<genexpr>+s�����?�d��a�5�j�A��J�1�d�s��)�sumrVs `r �countzSequence.count)s����?�d�?�?�?r)rN)
rErFrGr�rHrRrr�r�r�r�r�r�rrr r!r!�sA����I��O���������.@rr!c�(��eZdZ�fd�Z�fd�Z�xZS)�_DeprecateByteStringMetac�b��|dk7rddl}|jdd��t�|�||||fi|��S)Nr#r�collections.abc.ByteString����r,)�warnings�_deprecatedr�r�)rBr��bases� namespace�kwargsr�r�s �r r�z _DeprecateByteStringMeta.__new__3sC����<���� � �,��
!�
��w��s�D�%��E�f�E�Erc�P��ddl}|jdd��t�|�
|�S)Nrr�r�r�)r�r�r��__instancecheck__)rB�instancer�r�s �r r�z*_DeprecateByteStringMeta.__instancecheck__=s1�������(�� �
��w�(��2�2r)rErFrGr�r�r�r�s@r r�r�2s���F�3�3rr�c��eZdZdZdZy)r#zMThis unifies bytes and bytearray.
XXX Should add all their methods.
rN)rErFrGr�rHrrr r#r#Fs���
�Irr#c�p�eZdZdZdZed��Zed��Zed��Zd�Z d�Z
d�Zd �Zdd
�Z
d�Zd�Zy
)r"z�All the operations on a read-write sequence.
Concrete subclasses must provide __new__ or __init__,
__getitem__, __setitem__, __delitem__, __len__, and insert().
rc��t�rr��r=r�rWs r rozMutableSequence.__setitem__[r�rc��t�rr�r�s r rqzMutableSequence.__delitem___r�rc��t�)z3S.insert(index, value) -- insert value before indexr�r�s r �insertzMutableSequence.insertcs
���rc�:�|jt|�|�y)z:S.append(value) -- append value to the end of the sequenceN)r�r�rVs r �appendzMutableSequence.appendhs�����C��I�u�%rc�F� |j��#t$rYywxYw)z,S.clear() -> None -- remove all items from SN)r1r�r<s r r3zMutableSequence.clearls*�� �����
���� �� �r4c�z�t|�}t|dz�D]}|||z
dz
||c||<|||z
dz
<�!y)z!S.reverse() -- reverse *IN PLACE*r�r%N)r�r�)r=rr�s r �reversezMutableSequence.reversetsI����I���q�!�t��A�#'��!��A��;��Q�� �D��G�T�!�A�#�a�%�[�rc�R�||urt|�}|D]}|j|��y)zMS.extend(iterable) -- extend sequence by appending elements from the iterableN)r�r�)r=rOrgs r �extendzMutableSequence.extendzs'���T�>��&�\�F��A��K�K��N�rc��||}||=|S)z�S.pop([index]) -> item -- remove and return item at index (default last).
Raise IndexError if list is empty or index is out of range.
r)r=r�rgs r r1zMutableSequence.pop�s��
��K����K��rc�(�||j|�=y)zvS.remove(value) -- remove first occurrence of value.
Raise ValueError if the value is not present.
N)r�rVs r r,zMutableSequence.remove�s��
����E�"�#rc�(�|j|�|Sr)r�)r=rOs r �__iadd__zMutableSequence.__iadd__�s�����F���rN)r�)rErFrGr�rHrrorqr�r�r3r�r�r1r,r�rrr r"r"Rsk����I�������������&��8���$�rr")Ur��abcrrrr�r�r�rP�EllipsisTyper
r��__all__rEr.�bytes_iterator� bytearray�bytearray_iteratorrK�dict_keyiteratorrO�dict_valueiteratorrM�dict_itemiterator�
list_iteratorr��list_reverseiteratorr��range_iterator�longrange_iteratorr_�set_iterator�str_iterator�tuple_iterator�zip�zip_iterator� dict_keys�dict_values�
dict_itemsr1�mappingproxy� generatorr*� coroutinerhr-�async_generatorr8rrr�registerr
rrrrrrrrrr$r�r�r�rr� frozensetrrrrrr rrQr!r��strr�r�r#�bytesr"rrr �<module>r�s���>(�
��D��I����C�y����B�x���
�����d�3�i����$�y�{�+�,����R�W�W�Y��(���$�r�y�y�{�+�,����b�h�h�j�)�*���T�"�X��
��D��"��.�/���d�5��8�n�%���$�u�Q�$�Y�/�0�1���D���K� ���D��H�~���d�2�h����D���K� �������O� ��2�9�9�;���
�"�(�(�*�
�
��D�M�M�"���/�$�%� ��
�����K� ����
� �� �e���s�)���
����2�'�2�"&� �&�R
���9��2�g�2�"�M��&-�]�-�`����(�2��2�$�x��& ���.�!����$�%����"�#����$�%����#�$����-� ����&�'����.�!����$�%����,�����,�����.�!����,��
��
� -��-�`
���9���g��2�'�2�"���)���w��4@�L�4@�l
V��$;��;�(G�*�G�T���Y��M��M�`���C��
1�j�1�f�����
2�%�
2� !�{�C�!� ���)��,��S�,�,
���:��
%��j�
%� ���K� �O�W�O�d�����
=@�z�:�=@�~ ���%�����#�����%�����*��3�w�3�(��%=�����E��
���I��?�h�?�D���������#r
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists