python (3.11.7)

(root)/
lib/
python3.11/
__pycache__/
_collections_abc.cpython-311.opt-1.pyc

eu
dZddlmZmZddlZeeeZedZ	dZ
ee
Z[
gdZdZ
eedZeeeZeeiZeeiZeeiZeegZeeegZeeedZeeed	d
zZeeeZeedZ eedZ!eee"Z#eiZ$eiZ%eiZ&eej'Z(ed
Z)dZ*e*Z*ee*Z+e*,[*dZ-e-Z-ee-Z.[-dZ/GddeZ0GddeZ1Gdde1Z2e23e+GddeZ4Gdde4Z5Gdde5Z6e63e.GddeZ7Gd d!e7Z8e83ee83ee83ee83ee83ee83ee83ee83ee83ee83ee83e e83e!e83e#Gd"d#e7Z9Gd$d%e8Z:e:3e)Gd&d'eZ;Gd(d)eZ<Gd*d+e;e7e<Z=Gd,d-eZ>d.Z?d/Z@Gd0d1eZAGd2d3e=ZBeB3eCGd4d5eBZDeD3eGd6d7e=ZEeE3e(Gd8d9e;ZFGd:d;eFeBZGeG3e$Gd<d=eFeBZHeH3e&Gd>d?eFe=ZIeI3e%Gd@dAeEZJeJ3eKGdBdCe9e=ZLeL3eMeL3eNeL3eeL3eOGdDdEeLZPeP3eQeP3eGdFdGeLZReR3eeR3edS)HzjAbstract Base Classes (ABCs) for collections, according to PEP 3119.

Unit tests are in test_collections.
)ABCMetaabstractmethodN.cdSNrD/BuggyBox/python/3.11.7/bootstrap/lib/python3.11/_collections_abc.py_fr
sr)	Awaitable	Coroutine
AsyncIterable
AsyncIteratorAsyncGeneratorHashableIterableIterator	Generator
ReversibleSized	ContainerCallable
CollectionSet
MutableSetMappingMutableMappingMappingViewKeysView	ItemsView
ValuesViewSequenceMutableSequence
ByteStringzcollections.abcrirc#KdVSrrrrr	<lambda>r'>s5555rc
KdSrrrrr	_coror)@s
rcKdWVdSrrrrr	_agr+Fsrc|j}|D]3}|D]%}||jvr|j|tccSn
&tcS4dS)NT)__mro____dict__NotImplemented)CmethodsmromethodBs     r	_check_methodsr5Nsw
)C""	"	"A##:f%-))))))$
"!!!4rc>eZdZdZedZedZdS)rrcdSNrrselfs r	__hash__zHashable.__hash__^qrcB|turt|dStS)Nr;)rr5r/clsr0s  r	__subclasshook__zHashable.__subclasshook__b!(??!!Z000rN)__name__
__module____qualname__	__slots__rr;classmethodr@rrr	rrZMI^[rr)	metaclasscTeZdZdZedZedZeeZ	dS)rrc#KdVdSrrr9s r		__await__zAwaitable.__await__ms
rcB|turt|dStS)NrK)rr5r/r>s  r	r@zAwaitable.__subclasshook__qs#)!![111rN)
rBrCrDrErrKrFr@GenericAlias__class_getitem__rrr	rris[I^[
$L11rrc\eZdZdZedZeddZdZedZ	dS)rrct)zcSend a value into the coroutine.
        Return next yielded value or raise StopIteration.
        
StopIterationr:values  r	sendzCoroutine.send~

rNcT||||}|||}|)zgRaise an exception in the coroutine.
        Return next yielded value or raise StopIteration.
        with_tracebackr:typvaltbs    r	throwzCoroutine.throw;
;z	#%%C
>$$R((C	rc	|ttd#ttf$rYdSwxYw).Raise GeneratorExit inside coroutine.
        zcoroutine ignored GeneratorExitNr^
GeneratorExitRuntimeErrorrRr9s r	closezCoroutine.closeT	BJJ}%%%@AAA}-			DD	+AAcH|turt|ddddStS)NrKrUr^re)rr5r/r>s  r	r@zCoroutine.__subclasshook__s))!![&'7KKKrNN)
rBrCrDrErrUr^rerFr@rrr	rrzsI^


^
BBB[rrcTeZdZdZedZedZeeZ	dS)r
rctSr)rr9s r		__aiter__zAsyncIterable.__aiter__srcB|turt|dStS)Nrl)r
r5r/r>s  r	r@zAsyncIterable.__subclasshook__s#-!![111rN)
rBrCrDrErrlrFr@rMrNrrr	r
r
s[I^[
$L11rr
cDeZdZdZedZdZedZdS)rrcKt)z@Return the next item or raise StopAsyncIteration when exhausted.StopAsyncIterationr9s r		__anext__zAsyncIterator.__anext__s! rc|Srrr9s r	rlzAsyncIterator.__aiter__rcD|turt|ddStS)Nrrrl)rr5r/r>s  r	r@zAsyncIterator.__subclasshook__s%-!![+>>>rN)	rBrCrDrErrrrlrFr@rrr	rrs\I!!^![rrcbeZdZdZdZedZeddZdZe	dZ
dS)	rrc<K|dd{VS)zpReturn the next item from the asynchronous generator.
        When exhausted, raise StopAsyncIteration.
        N)asendr9s r	rrzAsyncGenerator.__anext__s,ZZ%%%%%%%%%rcKt)zuSend a value into the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        rprSs  r	rxzAsyncGenerator.asends
! rNcXK||||}|||}|)zyRaise an exception in the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        rXrZs    r	athrowzAsyncGenerator.athrows?
;z	#%%C
>$$R((C	rcK	|td{Vtd#ttf$rYdSwxYw)raNz,asynchronous generator ignored GeneratorExit)r{rcrdrqr9s r	aclosezAsyncGenerator.aclosesk	O++m,,,,,,,,,MNNN12			DD	s 3AAcJ|turt|dddddStS)Nrlrrrxr{r})rr5r/r>s  r	r@zAsyncGenerator.__subclasshook__s2.  !![+")8X??
?rri)rBrCrDrErrrrxr{r}rFr@rrr	rrsI&&&!!^!


^
OOO[rrcTeZdZdZedZedZeeZ	dS)rrc#
KdSrrr9s r	__iter__zIterable.__iter__		rcB|turt|dStS)Nr)rr5r/r>s  r	r@zIterable.__subclasshook__rArN)
rBrCrDrErrrFr@rMrNrrr	rrs[I^[
$L11rrcDeZdZdZedZdZedZdS)rrct)zKReturn the next item from the iterator. When exhausted, raise StopIterationrQr9s r	__next__zIterator.__next__s
rc|Srrr9s r	rzIterator.__iter__rtrcD|turt|ddStS)Nrr)rr5r/r>s  r	r@zIterator.__subclasshook__s#(??!!Z<<<rN)	rBrCrDrErrrrFr@rrr	rrs\I^[rrc>eZdZdZedZedZdS)rrc#
KdSrrr9s r	__reversed__zReversible.__reversed__6rrcD|turt|ddStS)Nrr)rr5r/r>s  r	r@zReversible.__subclasshook__;s%*!!^Z@@@rN)rBrCrDrErrrFr@rrr	rr2sMI^[rrcbeZdZdZdZedZeddZdZe	dZ
dS)	rrc,|dS)z^Return the next item from the generator.
        When exhausted, raise StopIteration.
        N)rUr9s r	rzGenerator.__next__Fsyyrct)zcSend a value into the generator.
        Return next yielded value or raise StopIteration.
        rQrSs  r	rUzGenerator.sendLrVrNcT||||}|||}|)zgRaise an exception in the generator.
        Return next yielded value or raise StopIteration.
        rXrZs    r	r^zGenerator.throwSr_rc	|ttd#ttf$rYdSwxYw)z.Raise GeneratorExit inside generator.
        zgenerator ignored GeneratorExitNrbr9s r	rezGenerator.close`rfrgcJ|turt|dddddStS)NrrrUr^re)rr5r/r>s  r	r@zGenerator.__subclasshook__js2)!!Z"('7<<
<rri)rBrCrDrErrrUr^rerFr@rrr	rrBsI^


^
BBB[rrc>eZdZdZedZedZdS)rrcdSr8rr9s r	__len__z
Sized.__len__yr<rcB|turt|dStS)Nr)rr5r/r>s  r	r@zSized.__subclasshook__}s!%<<!!Y///rN)rBrCrDrErrrFr@rrr	rrurGrrcTeZdZdZedZedZeeZ	dS)rrcdSNFr)r:xs  r	__contains__zContainer.__contains__urcB|turt|dStS)Nr)rr5r/r>s  r	r@zContainer.__subclasshook__s#)!!^444rN)
rBrCrDrErrrFr@rMrNrrr	rrs[I^[
$L11rrc(eZdZdZedZdS)rrcF|turt|dddStS)Nrrr)rr5r/r>s  r	r@zCollection.__subclasshook__s'*!!i^LLLrN)rBrCrDrErFr@rrr	rrs2I[rrc@eZdZdZdZfdZfdZdZfdZxZ	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)``.
    rcLt|trt|dkstd|\}}t|ttfrg||R}n!t|std|t
|||S)Nz6Callable must be used as Callable[[arg, ...], result].zFExpected a list of types, an ellipsis, ParamSpec, or Concatenate. Got )
isinstancetuplelen	TypeErrorlist_is_param_exprsuper__new__)r?originargst_argst_result	__class__s     r	rz_CallableGenericAlias.__new__s4''	JCIINNHJJ
Jfudm,,	H&V&X&&DD''	HG>DGGHH
HwwsFD111rc>t|jdkr:t|jdr tSddd|jddDdt
|jddS)	Nrrzcollections.abc.Callable[[z, c,g|]}t|Sr)
_type_repr).0as  r	
<listcomp>z2_CallableGenericAlias.__repr__.<locals>.<listcomp>sJJJ!
1

JJJrz], ])r__args__rr__repr__joinr)r:rs r	rz_CallableGenericAlias.__repr__st}""~dmA6F'G'G"77##%%%4YYJJt}SbS7IJJJKK44dmB/00444	5rc|j}t|dkrt|dst|dd|df}tt
|ffS)Nrrr)rrrrrr)r:rs  r	
__reduce__z _CallableGenericAlias.__reduce__sT}D		Q>$q'#:#:SbS	??DH,D$x&666rct|ts|f}t|jdkr4t	|jdr|rt	|ds|f}t|j}t|dttfs|d}|dd}||f}ttt|S)Nr$rr)rrr__parameters__rr__getitem__rrrr)r:itemnew_argsrrrs     r	rz!_CallableGenericAlias.__getitem__s$&&	7D
#$$))"4#6q#9::
*
*!/Q!8!8
*7D77&&t,,5(1+t}55	*|Hcrc]F)H$XuX???r)
rBrCrD__doc__rErrrr
__classcell__)rs@r	rrsI
2
2
2
2
255555777@@@@@@@@@rrcturdSttrdStd}jdkotfd|DS)z|Checks if obj matches either a list of types, ``...``, ``ParamSpec`` or
    ``_ConcatenateGenericAlias`` from typing.py
    T)	ParamSpec_ConcatenateGenericAliastypingc3.K|]}j|kVdSr)rB)rnameobjs  r		<genexpr>z!_is_param_expr.<locals>.<genexpr>s*-U-Utcld.B-U-U-U-U-U-Ur)EllipsisrrtyperCany)rnamess` r	rrsiht#tt
s))C5E>X%U#-U-U-U-Uu-U-U-U*U*UUrc&t|trt|St|tr#|jdkr|jS|jd|jS|turdSt|tr|jSt|S)zReturn the repr() of an object, special-casing types (internal helper).

    Copied from :mod:`typing` since collections.abc
    shouldn't depend on that module.
    builtins.z...)	rrMreprrrCrDrFunctionTyperB)rs r	rrs#|$$Cyy#t6>Z''##.553#3555
hu#|$$|99rcTeZdZdZedZedZeeZ	dS)rrcdSrr)r:rkwdss   r	__call__zCallable.__call__rrcB|turt|dStS)Nr)rr5r/r>s  r	r@zCallable.__subclasshook__rArN)
rBrCrDrErrrFr@rrNrrr	rrs\I^[
$$9::rrceZdZdZdZdZdZdZdZdZ	e
dZd	ZeZ
d
ZdZeZdZd
ZdZeZdZdS)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.
    rct|tstSt|t|krdS|D]	}||vrdS
dSNFTrrr/rr:otherelems   r	__le__z
Set.__le__sa%%%	"!!t99s5zz!!5		D5  uu!trct|tstSt|t|ko||Srrrr/rrr:rs  r	__lt__z
Set.__lt__'B%%%	"!!4yy3u::%<$++e*<*<<rct|tstSt|t|ko||Sr)rrr/r__ge__rs  r	__gt__z
Set.__gt__,rrct|tstSt|t|krdS|D]	}||vrdS
dSrrrs   r	rz
Set.__ge__1sa%%%	"!!t99s5zz!!5		D4uu trct|tstSt|t|ko||Srrrs  r	__eq__z
Set.__eq__;sB%%%	"!!4yyCJJ&=4;;u+=+==rc||S)zConstruct 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.
        rr?its  r	_from_iterablezSet._from_iterable@ss2wwrc~t|tstSfd|DS)Nc3$K|]
}|v|VdSrrrrTr:s  r	rzSet.__and__.<locals>.<genexpr>Ls'"M"MUu}}5}}}}"M"Mrrrr/rrs` r	__and__zSet.__and__IsD%**	"!!"""M"M"M"Me"M"M"MMMMrc|D]	}||vrdS
dS)z1Return True if two sets have a null intersection.FTr)r:rrTs   r	
isdisjointzSet.isdisjointPs+		E}}uutrct|tstSd||fD}||S)Nc3$K|]}|D]}|VdSrr)rses   r	rzSet.__or__.<locals>.<genexpr>Zs/55q155a5555555rr)r:rchains   r	__or__z
Set.__or__WsE%**	"!!55T5M555""5)))rctts1ttstS||fd|DS)Nc3$K|]
}|v|VdSrr)rrTrs  r	rzSet.__sub__.<locals>.<genexpr>ds9#:#:U&+5&8&8$)&8&8&8&8#:#:rrrrr/rrs `r	__sub__zSet.__sub___s}%%%	/eX..
&%%''..E""#:#:#:#:d#:#:#:::	:rct|ts1t|tstS|}fd|DS)Nc3$K|]
}|v|VdSrrrs  r	rzSet.__rsub__.<locals>.<genexpr>ls9#9#9U&+4&7&7$)&7&7&7&7#9#9rrrs` r	__rsub__zSet.__rsub__gs}%%%	/eX..
&%%''..E""#9#9#9#9e#9#9#999	9rct|ts1t|tstS||}||z
||z
zSrrrs  r	__xor__zSet.__xor__osR%%%	/eX..
&%%''..Eu..rctj}d|zdz}t|}d|dzz}||z}|D]'}t|}|||dzzdzdzz}||z}(||dz	|dz	zz}|d	zd
z}||z}||kr||dzz}|dkrd}|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.
        rr$iMriM[l4~2i
i6ri8#)sysmaxsizerhash)r:MAXMASKnhrhxs       r	_hashz	Set._hashxsk3w{II!a% 	T			AaB
"b/H,;;A
IAA	a2g!r'
""
I	!	T	s77
MA77ArN)rBrCrDrrErrrrrrFrr__rand__rr__ror__rrr__rxor__rrrr	rrsI===
===
>>>
[NNN
H***G:::999///HrrcleZdZdZdZedZedZdZdZ	dZ
dZd	Zd
Z
dZdS)
raA 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.
    rct)zAdd an element.NotImplementedErrorrSs  r	addzMutableSet.add
"!rct)z8Remove an element.  Do not raise an exception if absent.rrSs  r	discardzMutableSet.discardrrcV||vrt|||dS)z5Remove an element. If not a member, raise a KeyError.N)KeyErrorrrSs  r	removezMutableSet.removes15//!Urct|}	t|}n#t$r	tdwxYw|||S)z2Return the popped value.  Raise KeyError if empty.N)iternextrRr!rr:rrTs   r	popzMutableSet.popsY
$ZZ	%HHEE	%	%	%$	%Us!4cR		|#t$rYdSwxYw)z6This is slow (creates N new iterators!) but effective.TN)r'r!r9s r	clearzMutableSet.clears@	




			DD	
&&c:|D]}|||Sr)rr&s   r	__ior__zMutableSet.__ior__s'		EHHUOOOOrc@||z
D]}|||Sr)rr&s   r	__iand__zMutableSet.__iand__s/Ri	 	 ELLrc||ur|n^t|ts||}|D]1}||vr||||2|Sr)r)rrrrrr&s   r	__ixor__zMutableSet.__ixor__s
::JJLLLLb#&&
-((,,
$
$D==LL''''HHUOOOOrcl||ur|n|D]}|||Sr)r)rr&s   r	__isub__zMutableSet.__isub__sC
::JJLLLL
$
$U####rN)rBrCrDrrErrrr"r'r)r,r.r0r2rrr	rrs		I""^"""^"

rrcZeZdZdZdZdZedZddZdZ	dZ
d	Zd
ZdZ
dZdS)
rzA 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@ctrr!r:keys  r	rzMapping.__getitem__rNc8	||S#t$r|cYSwxYw)z<D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.r6r:r8defaults   r	getzMapping.gets5	9			NNN	s
c:	||dS#t$rYdSwxYwNTFr6r7s  r	rzMapping.__contains__
s;	II4			55	s
c t|S)z:D.keys() -> a set-like object providing a view on D's keys)rr9s r	keyszMapping.keyss~~rc t|S)z<D.items() -> a set-like object providing a view on D's items)rr9s r	itemsz
Mapping.itemssrc t|S)z6D.values() -> an object providing a view on D's values)r r9s r	valueszMapping.valuess$rct|tstSt|t|kSr)rrr/dictrCrs  r	rzMapping.__eq__sE%))	"!!DJJLL!!T%++--%8%888rr)rBrCrDrrE__abc_tpflags__rrr=rrArCrErrrrr	rrsIO^   999
LLLrrc:eZdZdZdZdZdZeeZ	dS)r_mappingc||_dSrrJ)r:mappings  r	__init__zMappingView.__init__,s



rc*t|jSr)rrKr9s r	rzMappingView.__len__/s4=!!!rc,d|S)Nz&{0.__class__.__name__}({0._mapping!r}))formatr9s r	rzMappingView.__repr__2s7>>tDDDrN)
rBrCrDrErNrrrFrMrNrrr	rr(sWI   """EEE$L11rrc4eZdZdZedZdZdZdS)rrc t|Srsetrs  r	rzKeysView._from_iterable<
2wwrc||jvSrrJr7s  r	rzKeysView.__contains__@sdm##rc#$K|jEd{VdSrrJr9s r	rzKeysView.__iter__Cs&=         rNrBrCrDrErFrrrrrr	rr8sPI[$$$!!!!!rrc4eZdZdZedZdZdZdS)rrc t|SrrTrs  r	rzItemsView._from_iterableNrVrc^|\}}	|j|}||up||kS#t$rYdSwxYwr)rKr!)r:rr8rTvs     r	rzItemsView.__contains__RsU
U	,
c"A:+e+			55	s

,,c#@K|jD]}||j|fVdSrrJr7s  r	rzItemsView.__iter__[s<=	,	,C
c*+++++	,	,rNrYrrr	rrJsPI[,,,,,,,,rrceZdZdZdZdZdS)r rcN|jD]}|j|}||us||krdSdSr?rJ)r:rTr8r]s    r	rzValuesView.__contains__gsA=		C
c"AEzzQ%ZZtt(urc#<K|jD]}|j|VdSrrJr7s  r	rzValuesView.__iter__ns7=	%	%C-$$$$$	%	%rN)rBrCrDrErrrrr	r r cs7I%%%%%rr c|eZdZdZdZedZedZeZ	e	fdZ
dZdZddZ
dd
Zd	S)
rzA 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__.
    rctrr6r:r8rTs   r	__setitem__zMutableMapping.__setitem__r9rctrr6r7s  r	__delitem__zMutableMapping.__delitem__r9rcV	||}||=|S#t$r||jur|cYSwxYw)zD.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:r8r<rTs    r	r'zMutableMapping.popsT	IES	L
			$-''NNN	s((c	tt|}n#t$r	tdwxYw||}||=||fS)zD.popitem() -> (k, v), remove and return some (key, value) pair
           as a 2-tuple; but raise KeyError if D is empty.
        N)r%r$rRr!rds   r	popitemzMutableMapping.popitemsY	%tDzz""CC	%	%	%$	%S	IEzs2cR		|#t$rYdSwxYw)z,D.clear() -> None.  Remove all items from D.TN)rkr!r9s r	r)zMutableMapping.clears@	

			DD	r*ct|tr|D]
}||||<n@t|dr#|D]
}||||<n
|D]
\}}|||<|D]
\}}|||<dS)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
        rAN)rrhasattrrArC)r:rrr8rTs     r	updatezMutableMapping.updateseW%%	"
'
'!#JS		
'
UF
#
#	"zz||
'
'!#JS		
'$
"
"
U!S		**,,		JCDII		rNcB	||S#t$r|||<YnwxYw|S)z@D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in Dr6r;s   r	
setdefaultzMutableMapping.setdefaults>	 9	 	 	 DIII	 s
)rr)rBrCrDrrErrergobjectrir'rkr)rorqrrr	rrvsI^^vxxH'


$rrcPeZdZdZdZdZedZdZdZ	dZ
dd
ZdZd	S)
r!zAll the operations on a read-only sequence.

    Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    r ctr
IndexErrorr:indexs  r	rzSequence.__getitem__rc#TKd}		||}|V|dz
}#t$rYdSwxYw)NrTr$rv)r:ir]s   r	rzSequence.__iter__sY
	
GQ
			FF	s
''c*|D]}||us||krdSdSr?r)r:rTr]s   r	rzSequence.__contains__s3		AEzzQ%ZZtt(urc#vKttt|D]}||V
dSr)reversedranger)r:r|s  r	rzSequence.__reversed__sD%D		**++		Aq'MMMM		rrNc|&|dkr tt||zd}||dkr|t|z
}|}|||kr3	||}n#t$rYnwxYw||us||kr|S|dz
}|-||k3t)zS.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.
        Nrr$)maxrrw
ValueError)r:rTstartstopr|r]s      r	ryzSequence.indexsD		E)1--EqCIIDla$hh
G



EzzQ%ZZ
FAla$hhsA
A$#A$c:tfd|DS)zBS.count(value) -> integer -- return number of occurrences of valuec30K|]}|us|kdVdS)r$Nr)rr]rTs  r	rz!Sequence.count.<locals>.<genexpr>
s/??a5jjAJJ1JJJJ??r)sumrSs `r	countzSequence.counts&????d??????r)rN)
rBrCrDrrErHrrrrrryrrrr	r!r!sIO^.@@@@@rr!ceZdZdZdZdS)r#zMThis unifies bytes and bytearray.

    XXX Should add all their methods.
    rN)rBrCrDrrErrr	r#r#s
IIIrr#ceZdZdZdZedZedZedZdZ	dZ
dZd	ZddZ
dZd
ZdS)r"zAll the operations on a read-write sequence.

    Concrete subclasses must provide __new__ or __init__,
    __getitem__, __setitem__, __delitem__, __len__, and insert().
    rctrrvr:ryrTs   r	rezMutableSequence.__setitem__'rzrctrrvrxs  r	rgzMutableSequence.__delitem__+rzrct)z3S.insert(index, value) -- insert value before indexrvrs   r	insertzMutableSequence.insert/s
rcL|t||dS)z:S.append(value) -- append value to the end of the sequenceN)rrrSs  r	appendzMutableSequence.append4s"CIIu%%%%%rcR		|#t$rYdSwxYw)z,S.clear() -> None -- remove all items from STN)r'rwr9s r	r)zMutableSequence.clear8s@	




			DD	r*ct|}t|dzD]%}|||z
dz
||c||<|||z
dz
<&dS)z!S.reverse() -- reverse *IN PLACE*rr$N)rr)r:rr|s   r	reversezMutableSequence.reverse@s^IIq!t	8	8A#'!A;Q DGT!A#a%[[	8	8rc`||urt|}|D]}||dS)zMS.extend(iterable) -- extend sequence by appending elements from the iterableN)rr)r:rEr]s   r	extendzMutableSequence.extendFs@T>>&\\F		AKKNNNN		rrc||}||=|S)zS.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:ryr]s   r	r'zMutableSequence.popMs
KKrc2|||=dS)zvS.remove(value) -- remove first occurrence of value.
           Raise ValueError if the value is not present.
        N)ryrSs  r	r"zMutableSequence.removeUs
E""###rc0|||Sr)r)r:rEs  r	__iadd__zMutableSequence.__iadd__[sFrN)r)rBrCrDrrErrergrrr)rrr'r"rrrr	r"r"sI^^^&&&888$$$rr")SrabcrrrrrintrMEllipsisTyper
r__all__rBr$bytes_iterator	bytearraybytearray_iteratorrAdict_keyiteratorrEdict_valueiteratorrCdict_itemiterator
list_iteratorrlist_reverseiteratorrrange_iteratorlongrange_iteratorrUset_iteratorstr_iteratortuple_iteratorzipzip_iterator	dict_keysdict_values
dict_itemsr.mappingproxy	generatorr)	coroutinerer+async_generatorr5rrrregisterr
rrrrrrrrrrrrrr	frozensetrrrrrr rrGr!rstr
memoryviewr#bytesr"rrr	<module>rs%

('''''''



tDItCyytBxx	
	
	
dd3iiT$$yy{{++,,4RWWYY((T$$ryy{{++,,Dbhhjj))**TT"XX
tDD"..//dd5588nn%%T$$uuQ$Y//0011tDDKK  tDDHH~~dd2hhtDDKK  DOO	d299;;
T"((**


tDM""D///$$%%	
DKK	


		cee$s))



22222'2222"&&&&&	&&&R
922222g2222"M&-----]---`(((222222222$x&	.!!!$%%%"###$%%%#$$$-   &'''.!!!$%%%,,.!!!,







 --------`
9g22222'2222");@;@;@;@;@L;@;@;@z
V
V
V&;;;;;;;;;(GGGGG*GGGTYMMMMMMMM`C
11111j111f
2
2
2
2
2%
2
2
2 !!!!!{C!!!	),,,,,S,,,,
:
%
%
%
%
%j
%
%
% K   OOOOOWOOOd
=@=@=@=@=@z:=@=@=@~	%#%*E
I?????h???D#####r