$51 GRAYBYTE WORDPRESS FILE MANAGER $20



��Yf�`�@s�dZd
dl
mZmZ
d
dlZdddddd	d
ddd
ddddddddddddgZdZeed�
�
Z	eee
��
�
Zeeij��
�
Z
eeij��
�
Zeeij��
�
Zeeg�
�
Zeeeg�
�
�
Zeeed
�
�
�
Zeeed:�
�
�
Zeee��
�
Zeed�
�
Zeef�
�
Zeee��
�
Zeij��
Zeij��
Zeij��
Z eej!�
Z"edd ���
Z#d!d"�Z$e$�Z$ee$�
Z%e$j&�
[$Gd#d�dd$e�
Z'Gd%d�dd$e�
Z(Gd&d�de(�Z)e)j*e%�

Gd'd�dd$e�
Z+Gd(d�de+�Z,Gd)d	�d	d$e�
Z-Gd*d
�d
e-�Z.e.j*e	�

e.j*e�

e.j*e
�

e.j*e�

e.j*e�

e.j*e�

e.j*e�

e.j*e�

e.j*e�

e.j*e�

e.j*e�

e.j*e�

e.j*e�

Gd+d�de.�Z/e/j*e#�

Gd,d�dd$e�
Z0Gd-d
�d
d$e�
Z1Gd.d�dd$e�
Z2Gd/d�de0e-e1�Z3e3j*e4�

Gd0d�de3�Z5e5j*e�

Gd1d�de0e-e1�Z6e6j*e"�

Gd2d�de0�Z7Gd3d�de7e3�Z8e8j*e�

Gd4d�de7e3�Z9e9j*e �

Gd5d�de7�Z:e:j*e�

Gd6d�de6�Z;e;j*e<�

Gd7d�de0e-e1�Z=e=j*e>�

e=j*e?�

e=j*e�

e=j*e@�

Gd8d�de=�ZAeAj*eB�

eAj*e
�

Gd9d�de=�ZCeCj*eD�

eCj*e
�

dS);zjAbstract Base Classes (ABCs) for collections, according to PEP 3119.

Unit tests are in test_collections.
�)�ABCMeta�abstractmethodN�	Awaitable�	Coroutine�
AsyncIterable�
AsyncIterator�Hashable�Iterable�Iterator�	Generator�Sized�	Container�Callable�Set�
MutableSet�Mapping�MutableMapping�MappingView�KeysView�	ItemsView�
ValuesView�Sequence�MutableSequence�
ByteStringzcollections.abc��
i��c
csdVS)
N�rrr�5/opt/alt/python35/lib64/python3.5/_collections_abc.py�<lambda>7src
�sdS)
Nrrrrr�_coro9sr c@s:eZ
dZfZed
d��
Zedd��
ZdS)rc


Csd
S)Nr
r)
�selfrrr�__hash__FszHashable.__hash__cCsE|tkrAx2|
j
D]'}d
|jkr|jd
r<dSPqWtS)Nr"T)r�__mro__�__dict__�NotImplemented)�cls�
C�
Brrr�__subclasshook__Js






zHashable.__subclasshook__N)�__name__�
__module__�__qualname__�	__slots__rr"�classmethodr)rrrrrBs�	metaclassc@s:eZ
dZfZed
d��
Zedd��
ZdS)rc


cs	dV
dS)
Nr)
r!rrr�	__await__YszAwaitable.__await__cCsE|tkrAx2|
j
D]'}d
|jkr|jd
r<dSPqWtS)Nr0T)rr#r$r%)r&r'r(rrrr)]s






zAwaitable.__subclasshook__N)r*r+r,r-rr0r.r)rrrrrUsc@s^eZ
dZfZed
d��
Zedddd��
Zdd�Zedd	��
Z	dS)
rc
Cs
t�
d
S)zcSend a value into the coroutine.
        Return next yielded value or raise StopIteration.
        N)
�
StopIteration)r!�valuerrr�sendlszCoroutine.sendNcCsL|d
kr'|d
kr|
�
|
�}|d
k	rB|j|�
}|�
d
S)zgRaise an exception in the coroutine.
        Return next yielded value or raise StopIteration.
        N)
�with_traceback)r!�typ�val�tbrrr�throwss


	


zCoroutine.throwc

Cs<y|jt
�

Wnt
tfk
r+


Yn
Xtd
�
�
dS)z.Raise GeneratorExit inside coroutine.
        zcoroutine ignored GeneratorExitN)r8�
GeneratorExitr1�RuntimeError)
r!rrr�close�s



zCoroutine.closecCsS|tkrO|
j
}x3dD]+}x"|D]}||jkr)Pq)WtSqWdStS)Nr0r3r8r;T)r0r3r8r;)rr#r$r%)r&r'�mro�method�baserrrr)�s
	







zCoroutine.__subclasshook__)
r*r+r,r-rr3r8r;r.r)rrrrrhs

c@s:eZ
dZfZed
d��
Zedd��
ZdS)rc


Cst�S)
N)
r)
r!rrr�	__aiter__�szAsyncIterable.__aiter__cCs0|tkr,t
d
d�|
jD�
�
r,dStS)Nc
ss|]}
d|
jkV
qd
S)r?N)
r$)�.0r(rrr�	<genexpr>�sz1AsyncIterable.__subclasshook__.<locals>.<genexpr>T)r�anyr#r%)r&r'rrrr)�s


zAsyncIterable.__subclasshook__N)r*r+r,r-rr?r.r)rrrrr�sc@sFeZ
dZfZed
d��
Zdd�Zedd��
ZdS)rc


�s
t�
d
S)z@Return the next item or raise StopAsyncIteration when exhausted.N)
�StopAsyncIteration)
r!rrr�	__anext__�szAsyncIterator.__anext__c


Cs|S)
Nr)
r!rrrr?�s
zAsyncIterator.__aiter__cCsL|tkrHt
d
d�|
jD�
�
rHt
dd�|
jD�
�
rHdStS)Nc
ss|]}
d|
jkV
qd
S)rDN)
r$)r@r(rrrrA�sz1AsyncIterator.__subclasshook__.<locals>.<genexpr>c
ss|]}
d|
jkV
qd
S)r?N)
r$)r@r(rrrrA�sT)rrBr#r%)r&r'rrrr)�s




zAsyncIterator.__subclasshook__N)	r*r+r,r-rrDr?r.r)rrrrr�sc@s:eZ
dZfZed
d��
Zedd��
ZdS)r	c


csdS)
Nr)
r!rrr�__iter__�szIterable.__iter__cCs0|tkr,t
d
d�|
jD�
�
r,dStS)Nc
ss|]}
d|
jkV
qd
S)rEN)
r$)r@r(rrrrA�sz,Iterable.__subclasshook__.<locals>.<genexpr>T)r	rBr#r%)r&r'rrrr)�s


zIterable.__subclasshook__N)r*r+r,r-rrEr.r)rrrrr	�sc@sFeZ
dZfZed
d��
Zdd�Zedd��
ZdS)r
c


Cs
t�
d
S)zKReturn the next item from the iterator. When exhausted, raise StopIterationN)
r1)
r!rrr�__next__�szIterator.__next__c


Cs|S)
Nr)
r!rrrrE�s
zIterator.__iter__cCsL|tkrHt
d
d�|
jD�
�
rHt
dd�|
jD�
�
rHdStS)Nc
ss|]}
d|
jkV
qd
S)rFN)
r$)r@r(rrrrA�sz,Iterator.__subclasshook__.<locals>.<genexpr>c
ss|]}
d|
jkV
qd
S)rEN)
r$)r@r(rrrrA�sT)r
rBr#r%)r&r'rrrr)�s




zIterator.__subclasshook__N)	r*r+r,r-rrFrEr.r)rrrrr
�sc@sjeZ
dZfZd
d�Zedd��
Zedddd��
Zdd	�Ze	d
d��
Z
dS)rc

Cs
|jd
�
S)z^Return the next item from the generator.
        When exhausted, raise StopIteration.
        N)
r3)
r!rrrrF�szGenerator.__next__c
Cs
t�
d
S)zcSend a value into the generator.
        Return next yielded value or raise StopIteration.
        N)
r1)r!r2rrrr3�szGenerator.sendNcCsL|d
kr'|d
kr|
�
|
�}|d
k	rB|j|�
}|�
d
S)zgRaise an exception in the generator.
        Return next yielded value or raise StopIteration.
        N)
r4)r!r5r6r7rrrr8
s


	


zGenerator.throwc

Cs<y|jt
�

Wnt
tfk
r+


Yn
Xtd
�
�
dS)z.Raise GeneratorExit inside generator.
        zgenerator ignored GeneratorExitN)r8r9r1r:)
r!rrrr;
s



zGenerator.closecCsS|tkrO|
j
}x3dD]+}x"|D]}||jkr)Pq)WtSqWdStS)NrErFr3r8r;T)rErFr3r8r;)rr#r$r%)r&r'r<r=r>rrrr)
s
	







zGenerator.__subclasshook__)r*r+r,r-rFrr3r8r;r.r)rrrrr�s

c@s:eZ
dZfZed
d��
Zedd��
ZdS)rc


Csd
S)Nr
r)
r!rrr�__len__2
sz
Sized.__len__cCs0|tkr,t
d
d�|
jD�
�
r,dStS)Nc
ss|]}
d|
jkV
qd
S)rGN)
r$)r@r(rrrrA9
sz)Sized.__subclasshook__.<locals>.<genexpr>T)rrBr#r%)r&r'rrrr)6
s


zSized.__subclasshook__N)r*r+r,r-rrGr.r)rrrrr.
sc@s:eZ
dZfZed
d��
Zedd��
ZdS)r
c
Csd
S)NFr)r!�
xrrr�__contains__B
szContainer.__contains__cCs0|tkr,t
d
d�|
jD�
�
r,dStS)Nc
ss|]}
d|
jkV
qd
S)rIN)
r$)r@r(rrrrAI
sz-Container.__subclasshook__.<locals>.<genexpr>T)r
rBr#r%)r&r'rrrr)F
s


zContainer.__subclasshook__N)r*r+r,r-rrIr.r)rrrrr
>
sc@s:eZ
dZfZed
d��
Zedd��
ZdS)rc

Osd
S)NFr)r!�args�kwdsrrr�__call__R
szCallable.__call__cCs0|tkr,t
d
d�|
jD�
�
r,dStS)Nc
ss|]}
d|
jkV
qd
S)rLN)
r$)r@r(rrrrAY
sz,Callable.__subclasshook__.<locals>.<genexpr>T)rrBr#r%)r&r'rrrr)V
s


zCallable.__subclasshook__N)r*r+r,r-rrLr.r)rrrrrN
sc@s�eZ
dZd
ZfZdd�Zdd�Zdd�Zdd	�Zd
d�Z	e
dd
��
Zdd�ZeZ
dd�Zdd�ZeZdd�Zdd�Zdd�ZeZdd�ZdS)raZ
A 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.
    cCsTt|
t
�stSt|�
t|
�
kr/d
Sx|D]}||
kr6d
Sq6WdS)NFT)�
isinstancerr%�len)r!�other�elemrrr�__le__o
s








z
Set.__le__cCs8t|
t
�stSt|�
t|
�
ko7|j|
�
S)
N)rMrr%rNrQ)r!rOrrr�__lt__y
s


z
Set.__lt__cCs8t|
t
�stSt|�
t|
�
ko7|j|
�
S)
N)rMrr%rN�__ge__)r!rOrrr�__gt__~
s


z
Set.__gt__cCsTt|
t
�stSt|�
t|
�
kr/d
Sx|
D]}||kr6d
Sq6WdS)NFT)rMrr%rN)r!rOrPrrrrS�
s








z
Set.__ge__cCs8t|
t
�stSt|�
t|
�
ko7|j|
�
S)
N)rMrr%rNrQ)r!rOrrr�__eq__�
s


z
Set.__eq__cCs
||
�
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)r&�itrrr�_from_iterable�
szSet._from_iterablecs3t|
t
�stS�j�f
d
d�|
D�
�
S)Nc
3s!|]}
|
�kr|
V
qdS)
Nr)r@r2)
r!rrrA�
szSet.__and__.<locals>.<genexpr>)rMr	r%rW)r!rOr)
r!r�__and__�
s


zSet.__and__cCs%x|
D]}||krd
SqWdS)z1Return True if two sets have a null intersection.FTr)r!rOr2rrr�
isdisjoint�
s



zSet.isdisjointcCs9t|
t
�stSd
d�||
fD�
}|j|�
S)Nc
ss"|]}
|
D]}|V
q
qdS)
Nr)r@�
s�
errrrA�
szSet.__or__.<locals>.<genexpr>)rMr	r%rW)r!rO�chainrrr�__or__�
s



z
Set.__or__csQt�t
�s1t�t�s"tS|j��
�|j�f
d
d�|D�
�
S)Nc
3s!|]}
|
�kr|
V
qdS)
Nr)r@r2)
rOrrrA�
s
zSet.__sub__.<locals>.<genexpr>)rMrr	r%rW)r!rOr)
rOr�__sub__�
s





zSet.__sub__csQt|
t
�s1t|
t�s"tS�j|
�
}
�j�f
d
d�|
D�
�
S)Nc
3s!|]}
|
�kr|
V
qdS)
Nr)r@r2)
r!rrrA�
s
zSet.__rsub__.<locals>.<genexpr>)rMrr	r%rW)r!rOr)
r!r�__rsub__�
s





zSet.__rsub__cCsAt|
t
�s1t|
t�s"tS|j|
�
}
||
|
|BS)
N)rMrr	r%rW)r!rOrrr�__xor__�
s





zSet.__xor__c
Cs�tj
}
d
|
d}t|�
}d|d}||M}x>|D]6}t|�
}|||d>AdAdN}||M}qBW|dd}||M}||
kr�||d8}|d
kr�d	}|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.
        �riM��r�i�M[l�4~2i�

i��6i��8#���)�sys�maxsizerN�hash)r!�MAX�MASK�
n�
hrH�hxrrr�_hash�
s 	

















z	Set._hashN)r*r+r,�__doc__r-rQrRrTrSrUr.rWrX�__rand__rYr]�__ror__r^r_r`�__rxor__rlrrrrra
s$


	c@s�eZ
dZd
ZfZedd��
Zedd��
Zdd�Zdd	�Z	d
d�Z
dd
�Zdd�Zdd�Z
dd�ZdS)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.
    c
Cs
t�
d
S)zAdd an element.N)
�NotImplementedError)r!r2rrr�add�
szMutableSet.addc
Cs
t�
d
S)z8Remove an element.  Do not raise an exception if absent.N)
rq)r!r2rrr�discardszMutableSet.discardcCs)|
|krt|
�
�
|j
|
�

d
S)z5Remove an element. If not a member, raise a KeyError.N)�KeyErrorrs)r!r2rrr�removes

zMutableSet.removec
CsHt|�
}
yt
|
�
}Wntk
r6


t�
Yn
X|j|�

|S)
z2Return the popped value.  Raise KeyError if empty.)�iter�nextr1rtrs)r!rVr2rrr�pops







zMutableSet.popc

Cs.yx|j�
qWWnt
k
r)


Yn
Xd
S)z6This is slow (creates N new iterators!) but effective.N)rxrt)
r!rrr�clears





zMutableSet.clearcCs"x|
D]}|j|�

qW|S)
N)
rr)r!rVr2rrr�__ior__s



zMutableSet.__ior__cCs&x||
D]}|j|�

qW|S)
N)
rs)r!rVr2rrr�__iand__"s


zMutableSet.__iand__cCsu|
|kr|j�
nXt
|
t�s7|j|
�
}
x7|
D]/}||kr`|j|�

q>|j|�

q>W|S)
N)ryrMrrWrsrr)r!rVr2rrr�__ixor__'s








zMutableSet.__ixor__cCs;|
|kr|j�
nx|
D]}|j
|�

q W|S)
N)ryrs)r!rVr2rrr�__isub__4s






zMutableSet.__isub__N)r*r+r,rmr-rrrrsrurxryrzr{r|r}rrrrr�
s


c@sseZ
dZfZed
d��
Zddd�
Zdd�Zdd	�Zd
d�Z	dd
�Z
dd�ZdS)rc
Cs
t�
dS)
N)
rt)r!�keyrrr�__getitem__NszMapping.__getitem__NcCs)y||
SWntk
r$


|SYn
Xd
S)z<D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.N)
rt)r!r~�defaultrrr�getRs



zMapping.getcCs-y||

Wntk
r$


d
SYnXdSdS)NFT)
rt)r!r~rrrrIYs





	zMapping.__contains__c

Cs
t|�
S)
z:D.keys() -> a set-like object providing a view on D's keys)
r)
r!rrr�keysaszMapping.keysc

Cs
t|�
S)
z<D.items() -> a set-like object providing a view on D's items)
r)
r!rrr�itemsesz
Mapping.itemsc

Cs
t|�
S)
z6D.values() -> an object providing a view on D's values)
r)
r!rrr�valuesiszMapping.valuescCs5t|
t
�stSt|j��
t|
j��
kS)
N)rMrr%�dictr�)r!rOrrrrUms


zMapping.__eq__)r*r+r,r-rrr�rIr�r�r�rUrrrrrBs
c@s:eZ
dZd	Zdd�Zdd�Zdd�ZdS)
r�_mappingcCs
|
|_dS)
N)
r�)r!�mappingrrr�__init__ys
zMappingView.__init__c

Cs
t|j
�
S)
N)rNr�)
r!rrrrG|s
zMappingView.__len__c

Cs
d
j|�
S)Nz&{0.__class__.__name__}({0._mapping!r}))
�format)
r!rrr�__repr__s
zMappingView.__repr__N)
r�)r*r+r,r-r�rGr�rrrrrusc@s@eZ
dZfZed
d��
Zdd�Zdd�ZdS)rcCs
t|
�
S)
N)
�set)r!rVrrrrW�szKeysView._from_iterablecCs
|
|jkS)
N)
r�)r!r~rrrrI�s
zKeysView.__contains__c

cs|jEdH
dS)
N)
r�)
r!rrrrE�s
zKeysView.__iter__N)r*r+r,r-r.rWrIrErrrrr�sc@s@eZ
dZfZed
d��
Zdd�Zdd�ZdS)rcCs
t|
�
S)
N)
r�)r!rVrrrrW�szItemsView._from_iterablecCsD|
\}}y|j|}Wnt
k
r5


d
SYnX||kSdS)NF)r�rt)r!�itemr~r2�
vrrrrI�s





	zItemsView.__contains__c
cs*x#|jD]}
|
|j|
fV
q
WdS)
N)
r�)r!r~rrrrE�s

zItemsView.__iter__N)r*r+r,r-r.rWrIrErrrrr�s	c@s.eZ
dZfZd
d�Zdd�ZdS)rcCs/x(|jD]}|
|j|kr
d
Sq
WdS)NTF)
r�)r!r2r~rrrrI�s



zValuesView.__contains__c
cs$x|jD]}
|j|
V
q
WdS)
N)
r�)r!r~rrrrE�s

zValuesView.__iter__N)r*r+r,r-rIrErrrrr�sc@s�eZ
dZfZed
d��
Zedd��
Ze�Zedd�
Z	dd�Z
d	d
�Zdd�Zd
dd�
Z
d
S)rc
Cs
t�
dS)
N)
rt)r!r~r2rrr�__setitem__�szMutableMapping.__setitem__c
Cs
t�
dS)
N)
rt)r!r~rrr�__delitem__�szMutableMapping.__delitem__cCsHy||
}Wn(tk
r8


||j
kr0�|SYnX||
=|Sd
S)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.
        N)rt�_MutableMapping__marker)r!r~r�r2rrrrx�s





	
zMutableMapping.popc
CsLytt
|�
�
}
Wntk
r0


t�
Yn
X||
}||
=|
|fS)
z�D.popitem() -> (k, v), remove and return some (key, value) pair
           as a 2-tuple; but raise KeyError if D is empty.
        )rwrvr1rt)r!r~r2rrr�popitem�s







zMutableMapping.popitemc

Cs.yx|j�
qWWnt
k
r)


Yn
Xd
S)z,D.clear() -> None.  Remove all items from D.N)r�rt)
r!rrrry�s





zMutableMapping.clearcOs

|std
�
�
|^
}}t
|�
dkrFtdt
|�
�
�
|r�|d}t|t�r�xw|D]}||||<qlWnXt|d�r�xF|j�D]}||||<q�Wn!x|D]\}}|||<q�Wx$|
j�D]\}}|||<q�WdS)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
        z@descriptor 'update' of 'MutableMapping' object needs an argumentrz+update expected at most 1 arguments, got %dr
r�N)�	TypeErrorrNrMr�hasattrr�r�)rJrKr!rOr~r2rrr�update�s$
















zMutableMapping.updateNcCs/y||
SWntk
r*


|||
<Yn
X|S)
[email protected](k[,d]) -> D.get(k,d), also set D[k]=d if k not in D)
rt)r!r~r�rrr�
setdefaults





zMutableMapping.setdefault)r*r+r,r-rr�r��objectr�rxr�ryr�r�rrrrr�s	c@speZ
dZd
ZfZedd��
Zdd�Zdd�Zdd	�Z	d
ddd
�Z
dd�ZdS)rz�All the operations on a read-only sequence.

    Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    c
Cs
t�
dS)
N)
�
IndexError)r!�indexrrrr)szSequence.__getitem__c
csGd
}
y$x||
}|V
|
d7}
qWWntk
rB


dSYn
XdS)Nr
r)
r�)r!�
ir�rrrrE-s









zSequence.__iter__cCs%x|D]}||
krd
SqWdS)NTFr)r!r2r�rrrrI7s




zSequence.__contains__c
cs0x)tt
t|�
�
�
D]}
||
V
qWdS)
N)�reversed�rangerN)r!r�rrr�__reversed__=s

zSequence.__reversed__r
NcCs�|d
k	r1|dkr1tt
|�
|d�}|d
k	rY|dkrY|t
|�
7}|}xT|d
ksz||kr�y|||
kr�|SWntk
r�


PYn
X|d7}qbWt�
d
S)z�S.index(value, [start, [stop]]) -> integer -- return first index of value.
           Raises ValueError if the value is not present.
        Nr
r)�maxrNr��
ValueError)r!r2�start�stopr�rrrr�As











zSequence.indexcst�f
d
d�|D�
�
S)zBS.count(value) -> integer -- return number of occurrences of valuec
3s!|]}
|
�krdV
qd
S)rNr)r@r�)
r2rrrAVsz!Sequence.count.<locals>.<genexpr>)
�sum)r!r2r)
r2r�countTszSequence.count)r*r+r,rmr-rrrErIr�r�r�rrrrrs
c
@seZ
dZd
ZfZdS)rzMThis unifies bytes and bytearray.

    XXX Should add all their methods.
    N)r*r+r,rmr-rrrrr^sc@s�eZ
dZfZed
d��
Zedd��
Zedd��
Zdd�Zd	d
�Z	dd�Z
d
d�Zddd�
Zdd�Z
dd�ZdS)rc
Cs
t�
dS)
N)
r�)r!r�r2rrrr�vszMutableSequence.__setitem__c
Cs
t�
dS)
N)
r�)r!r�rrrr�zszMutableSequence.__delitem__c
Cs
t�
d
S)z3S.insert(index, value) -- insert value before indexN)
r�)r!r�r2rrr�insert~szMutableSequence.insertcCs|jt
|�
|
�
d
S)z:S.append(value) -- append value to the end of the sequenceN)r�rN)r!r2rrr�append�szMutableSequence.appendc

Cs.yx|j�
qWWnt
k
r)


Yn
Xd
S)z,S.clear() -> None -- remove all items from SN)rxr�)
r!rrrry�s





zMutableSequence.clearc
CsXt|�
}
xEt
|
d
�
D]3}||
|d||||<||
|d<qWdS)z!S.reverse() -- reverse *IN PLACE*rarN)rNr�)r!rir�rrr�reverse�s

zMutableSequence.reversecCs"x|
D]}|j|�

qWd
S)zMS.extend(iterable) -- extend sequence by appending elements from the iterableN)
r�)r!r�r�rrr�extend�s

zMutableSequence.extendrcCs||
}||
=|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�r�rrrrx�s


zMutableSequence.popcCs||j|
�
=d
S)zvS.remove(value) -- remove first occurrence of value.
           Raise ValueError if the value is not present.
        N)
r�)r!r2rrrru�szMutableSequence.removecCs|j|
�

|S)
N)
r�)r!r�rrr�__iadd__�s


zMutableSequence.__iadd__Nrc)r*r+r,r-rr�r�r�r�ryr�r�rxrur�rrrrrks	lC)Erm�abcrrrd�__all__r*�typerv�bytes_iterator�	bytearray�bytearray_iteratorr��dict_keyiteratorr��dict_valueiteratorr��dict_itemiterator�
list_iteratorr��list_reverseiteratorr��range_iterator�longrange_iteratorr��set_iterator�str_iterator�tuple_iterator�zip�zip_iterator�	dict_keys�dict_values�
dict_itemsr$�mappingproxy�	generatorr �	coroutiner;rrr�registerrrr	r
rrr
rr�	frozensetrrrrrrrr�r�tuple�str�
memoryviewr�bytesr�listrrrr�<module>s�


	




		














	



0
























6
�
O
0



\
9






	


A