HEX

Warning: set_time_limit() [function.set-time-limit]: Cannot set time limit - prohibited by configuration in /home/u547966/brikov.ru/www/wp-content/plugins/admin-menu-editor/menu-editor.php on line 745
Server: Apache
System: Linux 4.19.0-0.bpo.9-amd64 x86_64 at red40
User: u547966 (5490)
PHP: 5.3.29-mh2
Disabled: syslog, dl, popen, proc_open, proc_nice, proc_get_status, proc_close, proc_terminate, posix_mkfifo, chown, chgrp, accelerator_reset, opcache_reset, accelerator_get_status, opcache_get_status, pcntl_alarm, pcntl_fork, pcntl_waitpid, pcntl_wait, pcntl_wifexited, pcntl_wifstopped, pcntl_wifsignaled, pcntl_wifcontinued, pcntl_wexitstatus, pcntl_wtermsig, pcntl_wstopsig, pcntl_signal, pcntl_signal_dispatch, pcntl_get_last_error, pcntl_strerror, pcntl_sigprocmask, pcntl_sigwaitinfo, pcntl_sigtimedwait, pcntl_exec, pcntl_getpriority, pcntl_setpriority
Upload Files
File: //usr/lib/python3.5/__pycache__/pickle.cpython-35.pyc


Fap@sdZddlmZddlmZddlmZmZmZddlm	Z	ddl
Z
ddl
mZddlm
Z
mZddlZddlZddlZddlZd	d
ddd
ddddg	ZeefZdZdddddddgZdZdZGdd	d	eZGdd
d
eZGdddeZGdddeZydd l m!Z!Wne"k
rdZ!YnXd!Z#d"Z$d#Z%d$Z&d%Z'd&Z(d'Z)d(Z*d)Z+d*Z,d+Z-d,Z.d-Z/d.Z0d/Z1d0Z2d1Z3d2Z4d3Z5d4Z6d5Z7d6Z8d7Z9d8Z:d9Z;d:Z<d;Z=d<Z>d=Z?d>Z@d?ZAd@ZBdAZCdBZDdCZEdDZFdEZGdFZHdGZIdHZJdIZKdJZLdKZMdLZNdMZOdNZPdOZQdPZRdQZSdRZTdSZUdTZVdUZWdVZXdWZYeIeSeTeUgZZdXZ[dYZ\dZZ]d[Z^d\Z_d]Z`d^Zad_Zbd`ZcdaZddbZedcZfejgdddeehDGdfdgdgZiGdhdidiZjdjdkZkdldmZldndoZmdpdqZnGdrdsdsZoGdtduduZpddvdwdxdyZqddvdwdzd{Zrdvdwd|d}d~dddZsdvdwd|d}d~dddZtyDddlumZmZmZmvZvmwZwmxZxmyZymzZzm{Z{WnBe"k
reoepf\ZvZweqeresetf\ZxZyZzZ{YnXddZ|e}dkrddl~Z~e~jddZejdde~jdddddejddddddejdddddejZejrse|nPejrejn9ddlZx*ejD]ZezeZejeqWdS)aCreate portable serialized representations of Python objects.

See module copyreg for a mechanism for registering custom picklers.
See module pickletools source for extensive comments.

Classes:

    Pickler
    Unpickler

Functions:

    dump(object, file)
    dumps(object) -> string
    load(file) -> object
    loads(string) -> object

Misc variables:

    __version__
    format_version
    compatible_formats

)FunctionType)dispatch_table)_extension_registry_inverted_registry_extension_cache)isliceN)maxsize)packunpackPickleError
PicklingErrorUnpicklingErrorPickler	Unpicklerdumpdumpsloadloadsz4.0z1.0z1.1z1.2z1.3z2.0z3.0c@seZdZdZdS)rz6A common base class for the other pickling exceptions.N)__name__
__module____qualname____doc__rr/usr/lib/python3.5/pickle.pyr?sc@seZdZdZdS)rz]This exception is raised when an unpicklable object is passed to the
    dump() method.

    N)rrrrrrrrrCsc@seZdZdZdS)r
aThis exception is raised when there is a problem unpickling an object,
    such as a security violation.

    Note that other exceptions may also be raised during unpickling, including
    (but not necessarily limited to) AttributeError, EOFError, ImportError,
    and IndexError.

    N)rrrrrrrrr
Jsc@seZdZddZdS)_StopcCs
||_dS)N)value)selfrrrr__init__Xsz_Stop.__init__N)rrrrrrrrrWsr)PyStringMap(.012FIJKLMNPQRSTUVXabcd}eghijl]opqrst)uGsI01
sI00
ssssssssssssBCsssssssssscCs(g|]}tjd|r|qS)z[A-Z][A-Z0-9_]+$)rematch).0xrrr
<listcomp>s	rPc@sUeZdZdZddZddZddZd	d
dZdd
ZdS)_Framer@icCs||_d|_dS)N)
file_write
current_frame)rrSrrrrs	z_Framer.__init__cCstj|_dS)N)ioBytesIOrT)rrrr
start_framingsz_Framer.start_framingcCs;|jr7|jjdkr7|jddd|_dS)NrforceT)rTtellcommit_frame)rrrrend_framingsz_Framer.end_framingFcCs|jr|j}|j|jks-|r|jC}t|}|j}|t|td|||WdQRX|jd|j	dS)Nz<Qr)
rTrY_FRAME_SIZE_TARGET	getbufferlenrSFRAMEr	seektruncate)rrXfdatanwriterrrrZs			

z_Framer.commit_framecCs*|jr|jj|S|j|SdS)N)rTrerS)rrcrrrres	z
_Framer.writeNi)	rrrr\rrWr[rZrerrrrrQs
rQc@sCeZdZdddZddZddZdd	ZdS)
	_UnframerNcCs||_||_d|_dS)N)	file_read
file_readlinerT)rrgrhZ	file_tellrrrrs		z_Unframer.__init__cCsw|jrf|jj|}|rD|dkrDd|_|j|St||krbtd|S|j|SdS)Nrz$pickle exhausted before end of frame)rTreadrgr^r
)rrdrcrrrris		
	z_Unframer.readcCs_|jrQ|jj}|s1d|_|jS|ddkrMtd|S|jSdS)Ns
rz$pickle exhausted before end of frame
)rTreadlinerhr
)rrcrrrrms		
	z_Unframer.readlinecCsI|jr*|jjdkr*tdtj|j||_dS)Nz4beginning of a new frame before end of current frame)rTrir
rUrVrg)r
frame_sizerrr
load_frames	z_Unframer.load_frame)rrrrrirmrprrrrrfs

rfcCsx|jdD]p}|dkr:tdj||y|}t||}Wqtk
rtdj||YqXqW||fS)N.z<locals>z&Can't get local attribute {!r} on {!r}z Can't get attribute {!r} on {!r})splitAttributeErrorformatgetattr)objnameZsubpathparentrrr
_getattributes	
	rycCst|dd}|dk	r"|SxtttjjD]]\}}|dks8|dkr_q8y!t||d|kr|SWq8tk
rYq8Xq8WdS)z$Find the module an object belong to.rN__main__r)rulistsysmodulesitemsryrs)rvrwmodule_namemodulerrrwhichmodules"
	rcCs|dkrdS|jd?d}|j|dddd}|dkr|dkr|d
d	kr|dd@dkr|dd}|S)aEncode a long to a two's complement little-endian binary string.
    Note that 0 is a special case, returning an empty string, to save a
    byte in the LONG1 pickling context.

    >>> encode_long(0)
    b''
    >>> encode_long(255)
    b'\xff\x00'
    >>> encode_long(32767)
    b'\xff\x7f'
    >>> encode_long(-256)
    b'\x00\xff'
    >>> encode_long(-32768)
    b'\x00\x80'
    >>> encode_long(-128)
    b'\x80'
    >>> encode_long(127)
    b'\x7f'
    >>>
    rrnrrj	byteorderlittlesignedTNrkrk)
bit_lengthto_bytes)rOnbytesresultrrrencode_long#s$rcCstj|ddddS)a\Decode a long from a two's complement little-endian binary string.

    >>> decode_long(b'')
    0
    >>> decode_long(b"\xff\x00")
    255
    >>> decode_long(b"\xff\x7f")
    32767
    >>> decode_long(b"\x00\xff")
    -256
    >>> decode_long(b"\x00\x80")
    -32768
    >>> decode_long(b"\x80")
    -128
    >>> decode_long(b"\x7f")
    127
    rrrT)int
from_bytes)rcrrrdecode_longAsrc@seZdZdddddZddZdd	Zd
dZdd
ZddZdddZ	ddZ
ddZddddddZiZ
ddZee
ed<ddZee
e<ddZee
e<ddZee
e<d d!Zee
e<d"d#Zee
e<d$d%Zee
e<d&d'Zee
e<d(Zd)d*Zd+d,Z e e
e!<e"dk	re e
e"<d-d.Z#d/d0Z$e$e
e%<d1d2Z&e&e
e'<dd3d4Z(d5d6Z)e(e
e*<e)e
e<dS)7_PicklerNfix_importsTcCs|dkrt}|dkr't}n,d|ko>tknsStdty|j|_Wntk
rtdYnXt|j|_|jj|_i|_	t
||_|dk|_d|_
|o|dk|_dS)aThis takes a binary file for writing a pickle data stream.

        The optional *protocol* argument tells the pickler to use the
        given protocol; supported protocols are 0, 1, 2, 3 and 4.  The
        default protocol is 3; a backward-incompatible protocol designed
        for Python 3.

        Specifying a negative protocol version selects the highest
        protocol version supported.  The higher the protocol used, the
        more recent the version of Python needed to read the pickle
        produced.

        The *file* argument must have a write() method that accepts a
        single bytes argument. It can thus be a file object opened for
        binary writing, an io.BytesIO instance, or any other custom
        object that meets this interface.

        If *fix_imports* is True and *protocol* is less than 3, pickle
        will try to map the new Python 3 names to the old module names
        used in Python 2, so that the pickle data stream is readable
        with Python 2.
        Nrzpickle protocol must be <= %dz"file must have a 'write' attributerjr)DEFAULT_PROTOCOLHIGHEST_PROTOCOL
ValueErrorre_file_writers	TypeErrorrQframermemorprotobinfastr)rfileprotocolrrrrrZs"	
		z_Pickler.__init__cCs|jjdS)aClears the pickler's "memo".

        The memo is the data structure that remembers which objects the
        pickler has already seen, so that shared or recursive objects
        are pickled by reference and not by value.  This method is
        useful when re-using picklers.
        N)rclear)rrrr
clear_memosz_Pickler.clear_memocCst|ds(td|jjf|jdkrT|jttd|j|jdkrp|jj	|j
||jt|jjdS)z7Write a pickled representation of obj to the open file.rz2Pickler.__init__() was not called by %s.__init__()rz<BrN)
hasattrr	__class__rrrePROTOr	rrWsaveSTOPr[)rrvrrrrs


z
_Pickler.dumpcCsj|jr
dSt||jks(tt|j}|j|j|||f|jt|<dS)zStore an object in the memo.N)ridrAssertionErrorr^reput)rrvidxrrrmemoizes	z_Pickler.memoizecCsl|jdkrtS|jrM|dkr9ttd|Sttd|Sntt|jddSdS)Nrz<Bz<Iasciis
)	rMEMOIZErBINPUTr	LONG_BINPUTPUTreprencode)rrrrrrs	z_Pickler.putcCsR|jr7|dkr&ttd|Sttd|Stt|jddS)Nrz<Bz<Irs
)rBINGETr	LONG_BINGETGETrr)rirrrgets
	z_Pickler.getcCs;|jj|j|}|dk	r?|r?|j|dS|jjt|}|dk	r|j|j|ddSt|}|j	j|}|dk	r|||dSt
|dtj|}|dk	r||}nyt|t}	Wnt
k
rd}	YnX|	r7|j|dSt
|dd}|dk	rg||j}nCt
|dd}|dk	r|}ntd|j|ft|tr|j||dSt|tstd|t|}
d|
kod	kns$td
||j|d|dS)NrrF
__reduce_ex__
__reduce__zCan't pickle %r object: %rz%s must return string or tuplerz3Tuple returned by %s must have two to five elementsrv)rrZ
persistent_id	save_persrrrretypedispatchrur
issubclassrsave_globalrrr
isinstancestrtupler^save_reduce)rrvsave_persistent_idpidrOtrbreducervZissclrrrrsT





z
_Pickler.savecCsdS)Nr)rrvrrrr
sz_Pickler.persistent_idcCsy|jr,|j|dd|jtnIy(|jtt|jddWntk
rttdYnXdS)NrFrs
z2persistent IDs in protocol 0 must be ASCII strings)	rrre	BINPERSIDPERSIDrrUnicodeEncodeErrorr)rrrrrrs	(
z_Pickler.save_perscCset|tstdt|s3td|j}|j}t|dd}	|jdkr|	dkr|\}
}}t|
dstdj	|	|dk	r|
|j
k	rtd	j	|	||
|||||tn|jd
kr|	dkr|d}
t|
ds@td
|dk	rg|
|j
k	rgtd|dd}||
|||tn|||||t
|dk	rt||jkr|t|j|jt|dn
|j||dk	r(|j||dk	rA|j||dk	ra|||tdS)Nz'args from save_reduce() must be a tuplez(func from save_reduce() must be callablerr
__newobj_ex____new__z#args[0] from {} args has no __new__z(args[0] from {} args has the wrong classr
__newobj__rz+args[0] from __newobj__ args has no __new__z0args[0] from __newobj__ args has the wrong classrj)rrrcallablerrerurrrtr	NEWOBJ_EXNEWOBJREDUCErrPOPrr_batch_appends_batch_setitemsBUILD)rfuncargsstateZ	listitemsZ	dictitemsrvrreZ	func_nameclskwargsrrrrsZ				




		





+



z_Pickler.save_reducecCs|jtdS)N)reNONE)rrvrrr	save_nonezsz_Pickler.save_nonecCsH|jdkr+|j|r!tntn|j|r=tntdS)Nr)rreNEWTRUENEWFALSETRUEFALSE)rrvrrr	save_bool~sz_Pickler.save_boolcCsA|jr|dkri|dkr?|jttd|dS|dkri|jttd|dSd
|kodknr|jttd|dS|jd	krt|}t|}|d
kr|jt	td||n|jt
td||dS|jtt|j
dddS)Nrrz<Biz<Hliz<irrrsL
i)rreBININT1r	BININT2BININTrrr^LONG1LONG4LONGrr)rrvencodedrdrrr	save_longs&	!z_Pickler.save_longcCsN|jr&|jttd|n$|jtt|jdddS)Nz>drs
)rreBINFLOATr	FLOATrr)rrvrrr
save_floats	z_Pickler.save_floatcCs|jdkrZ|s.|jtfd|n(|jtjt|ddfd|dSt|}|dkr|jtt	d||nZ|dkr|jdkr|jt
t	d||n|jtt	d	|||j|dS)
Nrrvlatin1rz<Blrz<Qz<I)
rrbytescodecsrrr^reSHORT_BINBYTESr		BINBYTES8BINBYTESr)rrvrdrrr
save_bytess!!z_Pickler.save_bytescCs|jr|jdd}t|}|dkrc|jdkrc|jttd||q|dkr|jdkr|jttd||q|jttd||nB|j	d	d
}|j	dd}|jt
|jd
d|j|dS)Nzutf-8
surrogatepassrrz<Blz<Qz<I\z\u005c
z\u000azraw-unicode-escapes
)rrr^rreSHORT_BINUNICODEr	BINUNICODE8
BINUNICODEreplaceUNICODEr)rrvrrdrrrsave_strs	!!!z_Pickler.save_strcCs|s4|jr|jtn|jttdSt|}|j}|j}|dkr|jdkrx|D]}||qtWt	||kr|j
|t	|d}|jt||n|jt||j
|dS|j}|tx|D]}||qWt	||kr|j
|t	|d}|jrh|t|n|t|d|dS|t|j
|dS)Nrrrrj)rreEMPTY_TUPLEMARKTUPLEr^rrrrrr_tuplesize2coderPOP_MARK)rrvrdrrelementrrerrr
save_tuples:			

	

	
z_Pickler.save_tuplecCsH|jr|jtn|jtt|j||j|dS)N)rre
EMPTY_LISTrLISTrr)rrvrrr	save_lists
	
z_Pickler.save_listicCs|j}|j}|jsDx"|D]}|||tq"WdSt|}xtt||j}t|}|dkr|t	x|D]}||qW|t
n|r||d|t||jkrSdSqSWdS)Nrjr)rrerAPPENDiterr{r
_BATCHSIZEr^rAPPENDS)rr~rrerOittmprdrrrrs*			





z_Pickler._batch_appendscCsN|jr|jtn|jtt|j||j|jdS)N)rre
EMPTY_DICTrDICTrrr~)rrvrrr	save_dict's
	
z_Pickler.save_dictc	Cs$|j}|j}|jsTx2|D]*\}}|||||tq"WdSt|}xtt||j}t|}|dkr|t	x(|D] \}}||||qW|t
n4|r	|d\}}|||||t||jkrcdSqcWdS)Nrjr)rrerSETITEMrr{rr
r^rSETITEMS)	rr~rrekvrrrdrrrr4s2			







z_Pickler._batch_setitemscCs|j}|j}|jdkrD|jtt|fd|dS|t|j|t|}xvtt	||j
}t|}|dkr|tx|D]}||qW|t
||j
krjdSqjWdS)Nrrvr)rrerrsetr{	EMPTY_SETrrrr
r^rADDITEMS)rrvrrerZbatchrditemrrrsave_setSs$		




z_Pickler.save_setcCs|j}|j}|jdkrD|jtt|fd|dS|tx|D]}||qUWt||jkr|t	|j
|jt|ddS|t|j|dS)Nrrvr)
rrerr	frozensetr{rrrrr	FROZENSETr)rrvrrerrrrsave_frozensetks		

(
z_Pickler.save_frozensetc
Cs|j}|j}|dkr0t|dd}|dkrE|j}t||}y6t|ddtj|}t||\}}Wn4t	t
tfk
rtd|||fYn&X||k	rtd|||f|j
dkrtj||f}	|	r|	dks"t|	dkrH|ttd|	n=|	d	krn|ttd
|	n|ttd|	dS|jdd}
||kr|
}|j
d
kr|j||j||tn ||k	r	|jt||
fn|j
dkrG|tt|ddt|ddn|jrtj}tj}||f|kr|||f\}}n||kr||}y0|tt|ddt|ddWn.tk
rtd|||j
fYnX|j |dS)Nrlevelrz(Can't pickle %r: it's not found as %s.%sz2Can't pickle %r: it's not the same object as %s.%srrz<Biz<Hz<irqrrzutf-8s
rz?can't pickle global identifier '%s.%s' using pickle protocol %i)!rerrurr
__import__r|r}ryImportErrorKeyErrorrsrrrrrEXT1r	EXT2EXT4
rpartitionrSTACK_GLOBALrGLOBALrr_compat_pickleZREVERSE_NAME_MAPPINGZREVERSE_IMPORT_MAPPINGrr)
rrvrwrerrrZobj2rxcodeZlastnameZr_name_mappingZr_import_mappingrrrrsp			



,			
-
z_Pickler.save_globalcCs|tdkr(|jtdd|S|ttkrS|jttfd|S|tdkr{|jtdd|S|j|S)Nrv.)N).)rrNotImplementedr)rrvrrr	save_typesz_Pickler.save_type)+rrrrrrrrrrrrrrrrrboolrrrfloatrrrrrrr
r{r
rrdictr rrrrrrr-rrrrrrXsV)
	B]




1
	
	



B	
rc@s"eZdZddddddddZd	d
ZddZd
dZiZddZeee	d<ddZ
e
eed<ddZeee
d<ddZeeed<ddZeeed<ddZeeed<ddZeeed<ddZeeed<d d!Zeeed<d"d#Zeeed<d$d%Zeeed<d&d'Zeeed<d(d)Z e ee!d<d*d+Z"e"ee#d<d,d-Z$e$ee%d<d.d/Z&e&ee'd<d0d1Z(d2d3Z)e)ee*d<d4d5Z+e+ee,d<d6d7Z-e-ee.d<d8d9Z/e/ee0d<d:d;Z1e1ee2d<d<d=Z3e3ee4d<d>d?Z5e5ee6d<d@dAZ7e7ee8d<dBdCZ9e9ee:d<dDdEZ;e;ee<d<dFdGZ=e=ee>d<dHdIZ?e?ee@d<dJdKZAeAeeBd<dLdMZCeCeeDd<dNdOZEeEeeFd<dPdQZGeGeeHd<dRdSZIeIeeJd<dTdUZKeKeeLd<dVdWZMeMeeNd<dXdYZOeOeePd<dZd[ZQeQeeRd<d\d]ZSd^d_ZTeTeeUd<d`daZVeVeeWd<dbdcZXeXeeYd<dddeZZeZee[d<dfdgZ\e\ee]d<dhdiZ^e^ee_d<djdkZ`e`eead<dldmZbebeecd<dndoZdedeeed<dpdqZfdrdsZgdtduZheheeid<dvdwZjejeekd<dxdyZleleemd<dzd{Zneneeod<d|d}Zpepeeqd<d~dZrereesd<ddZteteeud<ddZveveewd<ddZxexeeyd<ddZzezee{d<ddZ|e|ee}d<ddZ~e~eed<ddZeeed<ddZeeed<ddZeeed<ddZeeed<ddZeeed<ddZeeed<ddZeeed<dS)
_UnpicklerrTencodingASCIIerrorsstrictcCsI|j|_|j|_i|_||_||_d|_||_dS)aThis takes a binary file for reading a pickle data stream.

        The protocol version of the pickle is detected automatically, so
        no proto argument is needed.

        The argument *file* must have two methods, a read() method that
        takes an integer argument, and a readline() method that requires
        no arguments.  Both methods should return bytes.  Thus *file*
        can be a binary file object opened for reading, an io.BytesIO
        object, or any other custom object that meets this interface.

        The file-like object must have two methods, a read() method
        that takes an integer argument, and a readline() method that
        requires no arguments.  Both methods should return bytes.
        Thus file-like object can be a binary file object opened for
        reading, a BytesIO object, or any other custom object that
        meets this interface.

        Optional keyword arguments are *fix_imports*, *encoding* and
        *errors*, which are used to control compatibility support for
        pickle stream generated by Python 2.  If *fix_imports* is True,
        pickle will try to map the old Python 2 names to the new names
        used in Python 3.  The *encoding* and *errors* tell pickle how
        to decode 8-bit string instances pickled by Python 2; these
        default to 'ASCII' and 'strict', respectively. *encoding* can be
        'bytes' to read theses 8-bit string instances as bytes objects.
        rN)	rm_file_readlineri
_file_readrr2r4rr)rrrr2r4rrrrs				z_Unpickler.__init__cCst|ds(td|jjft|j|j|_|jj|_|jj	|_	t
|_g|_|jj
|_
d|_|j}|j}yJxC|d}|stt|tst||d|qWWn,tk
r}z|jSWYdd}~XnXdS)zRead a pickled object representation from the open file.

        Return the reconstituted object hierarchy specified in the file.
        r7z4Unpickler.__init__() was not called by %s.__init__()rrjN)rr
rrrfr7r6	_unframerrirmobjectmarkstackappendrrEOFErrorrbytes_typesrrr)rrirkeyZstopinstrrrrs*				z_Unpickler.loadcCsG|j}|j}t|d}x|||k	rB|d}q%W|S)Nrj)r;r:r^)rr;r:rrrrmarkers		z_Unpickler.markercCstddS)Nz%unsupported persistent id encountered)r
)rrrrrpersistent_load&sz_Unpickler.persistent_loadcCsL|jdd}d|ko*tkns?td|||_dS)Nrjrzunsupported pickle protocol: %d)rirrr)rrrrr
load_proto+sz_Unpickler.load_protorcCsNtd|jd\}|tjkr:td||jj|dS)Nz<Qzframe size > sys.maxsize: %d)r
rir|rrr8rp)rrorrrrp2sz_Unpickler.load_framecCs^y#|jddjd}Wntk
rCtdYnX|j|j|dS)Nrjrz2persistent IDs in protocol 0 must be ASCII stringsrk)rmdecodeUnicodeDecodeErrorr
r<rA)rrrrrload_persid9s#
z_Unpickler.load_persidcCs)|jj}|j|j|dS)N)r;popr<rA)rrrrrload_binpersidBsz_Unpickler.load_binpersidcCs|jddS)N)r<)rrrr	load_noneGsz_Unpickler.load_nonecCs|jddS)NF)r<)rrrr
load_falseKsz_Unpickler.load_falsecCs|jddS)NT)r<)rrrr	load_trueOsz_Unpickler.load_truecCsj|j}|tddkr+d}n.|tddkrJd}nt|d}|j|dS)NrjFTr)rmrrrr<)rrcvalrrrload_intSs		z_Unpickler.load_intcCs'|jtd|jdddS)Nz<irr)r<r
ri)rrrrload_binint^sz_Unpickler.load_binintcCs|j|jdddS)Nrjr)r<ri)rrrrload_binint1bsz_Unpickler.load_binint1cCs'|jtd|jdddS)Nz<Hrr)r<r
ri)rrrrload_binint2fsz_Unpickler.load_binint2cCsV|jdd}|r<|ddkr<|dd}|jt|ddS)Nrjr*rrkrkLrk)rmr<r)rrLrrr	load_longjsz_Unpickler.load_longcCs9|jdd}|j|}|jt|dS)Nrjr)rir<r)rrdrcrrr
load_long1qsz_Unpickler.load_long1cCsYtd|jd\}|dkr3td|j|}|jt|dS)Nz<irrz#LONG pickle has negative byte count)r
rir
r<r)rrdrcrrr
load_long4ws
z_Unpickler.load_long4cCs'|jt|jdddS)Nrjrk)r<r/rm)rrrr
load_floatsz_Unpickler.load_floatcCs'|jtd|jdddS)Nz>drCr)r<r
ri)rrrr
load_binfloatsz_Unpickler.load_binfloatcCs-|jdkr|S|j|j|jSdS)Nr)r2rDr4)rrrrr_decode_stringsz_Unpickler._decode_stringcCs|jdd}t|dkr_|d|dkr_|ddkr_|dd}ntd|j|jtj|ddS)	Nrjrrs"'z)the STRING opcode argument must be quotedrkrkrk)rmr^r
r<rWr
escape_decode)rrcrrrload_strings
6z_Unpickler.load_stringcCs\td|jd\}|dkr3td|j|}|j|j|dS)Nz<irrz(BINSTRING pickle has negative byte count)r
rir
r<rW)rr^rcrrrload_binstrings
z_Unpickler.load_binstringcCsQtd|jd\}|tkr7tdt|j|j|dS)Nz<Irz2BINBYTES exceeds system's maximum size of %d bytes)r
rirr
r<)rr^rrr
load_binbytess

z_Unpickler.load_binbytescCs*|jt|jddddS)Nrjzraw-unicode-escaperk)r<rrm)rrrrload_unicodesz_Unpickler.load_unicodecCs]td|jd\}|tkr7tdt|jt|j|dddS)Nz<Irz4BINUNICODE exceeds system's maximum size of %d byteszutf-8r)r
rirr
r<r)rr^rrrload_binunicodes

z_Unpickler.load_binunicodecCs]td|jd\}|tkr7tdt|jt|j|dddS)Nz<QrCz5BINUNICODE8 exceeds system's maximum size of %d byteszutf-8r)r
rirr
r<r)rr^rrrload_binunicode8s

z_Unpickler.load_binunicode8cCsQtd|jd\}|tkr7tdt|j|j|dS)Nz<QrCz3BINBYTES8 exceeds system's maximum size of %d bytes)r
rirr
r<)rr^rrrload_binbytes8s

z_Unpickler.load_binbytes8cCs<|jdd}|j|}|j|j|dS)Nrjr)rir<rW)rr^rcrrrload_short_binstringsz_Unpickler.load_short_binstringcCs-|jdd}|j|j|dS)Nrjr)rir<)rr^rrrload_short_binbytessz_Unpickler.load_short_binbytescCs9|jdd}|jt|j|dddS)Nrjrzutf-8r)rir<r)rr^rrrload_short_binunicodesz _Unpickler.load_short_binunicodecCs=|j}t|j|ddg|j|d<dS)Nrj)r@rr;)rrrrr
load_tuplesz_Unpickler.load_tuplecCs|jfdS)N)r<)rrrrload_empty_tuplesz_Unpickler.load_empty_tuplecCs|jdf|jd<dS)Nrjrkrk)r;)rrrrload_tuple1sz_Unpickler.load_tuple1cCs.|jd|jdfg|jdd<dS)Nrrjrrkr)r;)rrrrload_tuple2sz_Unpickler.load_tuple2cCs8|jd|jd|jdfg|jdd<dS)Nrrrjrrkrg)r;)rrrrload_tuple3sz_Unpickler.load_tuple3cCs|jgdS)N)r<)rrrrload_empty_listsz_Unpickler.load_empty_listcCs|jidS)N)r<)rrrrload_empty_dictionarysz _Unpickler.load_empty_dictionarycCs|jtdS)N)r<r)rrrrload_empty_setsz_Unpickler.load_empty_setcCs=|j}t|j|ddg|j|d<dS)Nrj)r@rr;)rrrrrload_frozensetsz_Unpickler.load_frozensetcCs7|j}|j|ddg|j|d<dS)Nrj)r@r;)rrrrr	load_listsz_Unpickler.load_listcsh|j}|j|ddfddtdtdD}|g|j|d<dS)Nrjcs%i|]}|d|qS)rjr)rNr)r~rr
<dictcomp>s	z(_Unpickler.load_dict.<locals>.<dictcomp>rr)r@r;ranger^)rrdr)r~r	load_dicts
z_Unpickler.load_dictcCst|j|dd}|j|d=|sRt|tsRt|dry||}Wqtk
r}z1td|jt|ftj	dWYdd}~XqXn|j
|}|j|dS)NrjZ__getinitargs__zin constructor for %s: %sr)rr;rrrrrrr|exc_inforr<)rklassrrrerrrrr_instantiates<z_Unpickler._instantiatecCsj|jddjd}|jddjd}|j||}|j||jdS)Nrjrrkrk)rmrD
find_classrur@)rrrwrsrrr	load_instsz_Unpickler.load_instcCs6|j}|jj|d}|j||dS)Nrj)r@r;rGru)rrrsrrrload_obj%sz_Unpickler.load_objcCsA|jj}|jj}|j||}|j|dS)N)r;rGrr<)rrrrvrrrload_newobj,sz_Unpickler.load_newobjcCsS|jj}|jj}|jj}|j|||}|j|dS)N)r;rGrr<)rrrrrvrrrload_newobj_ex3s
z_Unpickler.load_newobj_excCsa|jddjd}|jddjd}|j||}|j|dS)Nrjzutf-8rkrk)rmrDrvr<)rrrwrsrrrload_global;sz_Unpickler.load_globalcCsk|jj}|jj}t|tk	sBt|tk	rNtd|j|j||dS)NzSTACK_GLOBAL requires str)r;rGrrr
r<rv)rrwrrrrload_stack_globalBs
$z_Unpickler.load_stack_globalcCs$|jdd}|j|dS)Nrjr)ri
get_extension)rr+rrr	load_ext1Jsz_Unpickler.load_ext1cCs,td|jd\}|j|dS)Nz<Hr)r
rir})rr+rrr	load_ext2Osz_Unpickler.load_ext2cCs,td|jd\}|j|dS)Nz<ir)r
rir})rr+rrr	load_ext4Tsz_Unpickler.load_ext4cCsg}tj||}||k	r5|j|dStj|}|sr|dkrbtdtd||j|}|t|<|j|dS)NrzEXT specifies code <= 0zunregistered extension code %d)rrr<rr
rrv)rr+Znilrvr?rrrr}Ys

z_Unpickler.get_extensioncCs|jdkre|jre||ftjkrItj||f\}}n|tjkretj|}t|dd|jdkrttj||dSt	tj||SdS)Nrr rr)
rrr*ZNAME_MAPPINGZIMPORT_MAPPINGr!ryr|r}ru)rrrwrrrrvis
z_Unpickler.find_classcCs3|j}|j}|d}|||d<dS)Nrjrkrk)r;rG)rr;rrrrrload_reducevs	
z_Unpickler.load_reducecCs|jd=dS)Nrjrk)r;)rrrrload_pop}sz_Unpickler.load_popcCs |j}|j|d=dS)N)r@r;)rrrrr
load_pop_marksz_Unpickler.load_pop_markcCs|j|jddS)Nrjrk)r<r;)rrrrload_dupsz_Unpickler.load_dupcCs4t|jdd}|j|j|dS)Nrjrk)rrmr<r)rrrrrload_getsz_Unpickler.load_getcCs+|jdd}|j|j|dS)Nrjr)rir<r)rrrrrload_bingetsz_Unpickler.load_bingetcCs3td|jd\}|j|j|dS)Nz<Ir)r
rir<r)rrrrrload_long_bingetsz_Unpickler.load_long_bingetcCsLt|jdd}|dkr4td|jd|j|<dS)Nrjrznegative PUT argumentrkrk)rrmrr;r)rrrrrload_putsz_Unpickler.load_putcCsC|jdd}|dkr+td|jd|j|<dS)Nrjrznegative BINPUT argumentrk)rirr;r)rrrrrload_binputsz_Unpickler.load_binputcCsKtd|jd\}|tkr3td|jd|j|<dS)Nz<Irznegative LONG_BINPUT argumentrjrk)r
rirrr;r)rrrrrload_long_binputsz_Unpickler.load_long_binputcCs$|j}|jd|t|<dS)Nrjrk)rr;r^)rrrrrload_memoizes	z_Unpickler.load_memoizecCs0|j}|j}|d}|j|dS)Nrjrk)r;rGr<)rr;rr{rrrload_appends	
z_Unpickler.load_appendcCs|j}|j}||d}||dd}t|trV|j|n$|j}x|D]}||qfW||d=dS)Nrj)r;r@rr{extendr<)rr;r:Zlist_objr~r<rrrrload_appendss		
z_Unpickler.load_appendscCs9|j}|j}|j}|d}|||<dS)Nrjrk)r;rG)rr;rr?r0rrrload_setitems
	
z_Unpickler.load_setitemcCsq|j}|j}||d}x:t|dt|dD]}||d|||<q@W||d=dS)Nrjr)r;r@ror^)rr;r:r0rrrr
load_setitemss	#z_Unpickler.load_setitemscCs|j}|j}||d}||dd}t|trV|j|n$|j}x|D]}||qfW||d=dS)Nrj)r;r@rrupdateadd)rr;r:Zset_objr~rrrrr
load_additemss		
z_Unpickler.load_additemsc
Cs|j}|j}|d}t|dd}|dk	rK||dSd}t|tr~t|dkr~|\}}|r|j}tj}xI|j	D];\}}	t
|tkr|	|||<q|	||<qW|rx*|j	D]\}}	t|||	qWdS)Nrj__setstate__rrk)
r;rGrurrr^__dict__r|internr~rrsetattr)
rr;rZinstsetstateZ	slotstateZ	inst_dictrrrrrr
load_builds(	

!		z_Unpickler.load_buildcCs|j|jdS)N)r<r:)rrrr	load_marksz_Unpickler.load_markcCs|jj}t|dS)N)r;rGr)rrrrr	load_stopsz_Unpickler.load_stopN)rrrrrr@rArrBrrpr_rFrrHrrIrrJrrKrrMINTrNrrOrrPrrRrrSrrTrrUrrVrrWrYSTRINGrZ	BINSTRINGr[rr\rr]rr^rr_rr`SHORT_BINSTRINGrarrbrrcrrdrreTUPLE1rfTUPLE2rhTUPLE3rirrjrrkrrlrrmr	rqrrurwINSTrxOBJryrrzrr{r)r|r(r~r$rr%rr&r}rvrrrrrrrDUPrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr1s	$%		
r1rTcCs t||d|j|dS)Nr)rr)rvrrrrrr_dumpsrcCsMtj}t||d|j||j}t|tsIt|S)Nr)rUrVrrgetvaluerr>r)rvrrrbZresrrr_dumpss
rr2r3r4r5cCs"t|d|d|d|jS)Nrr2r4)r1r)rrr2r4rrr_loadsrcCsLt|trtdtj|}t|d|d|d|jS)Nz%Can't load pickle from unicode stringrr2r4)rrrrUrVr1r)srr2r4rrrr_loadss
r)	rrr
rrrrrrcCsddl}|jS)Nr)doctestZtestmod)rrrr_test3srrzZdescriptionz$display contents of the pickle filespickle_filerZbrnargs*helpzthe pickle filez-tz--testaction
store_truezrun self-test suitez-vz)run verbosely; only affects self-test run)rtypesrcopyregrrrr	itertoolsrr|rZstructr	r
rLrUrr*__all__r	bytearrayr>Zformat_versionZcompatible_formatsrr	Exceptionrrr
rZorg.python.corer r"rrrrrrrrrrrrrrrrrrrrrrr)rrrrrrrr	rrrrrrrrrrrrrrr$r%r&rrrrrrrrrrrrrrrrrr(rr_rdirrQrfryrrrrr1rrrr_picklerrrrrrrrargparseArgumentParserparseradd_argumentZFileType
parse_argsrZtestrZ
print_helpZpprintrbrvrrrr<module>s"	

$*
};D
#