Current File : //proc/self/root/usr/lib/python3.12/__pycache__/pickle.cpython-312.pyc
�

�4h���	�@�dZddlmZddlmZddlmZmZmZddlm	Z	ddl
mZddlZddlm
Z
dd	lmZmZddlZddlZddlZddlZgd
�Z	ddlmZej1d�d
ZeefZdZgd�ZdZ dZ!Gd�de"�Z#Gd�de#�Z$Gd�de#�Z%Gd�de"�Z&dZ'dZ(dZ)dZ*dZ+d Z,d!Z-d"Z.d#Z/d$Z0d%Z1d&Z2d'Z3d(Z4d)Z5d*Z6d+Z7d,Z8d-Z9d.Z:d/Z;d0Z<d1Z=d2Z>d3Z?d4Z@d5ZAd6ZBd7ZCd8ZDd9ZEd:ZFd;ZGd<ZHd=ZId>ZJd?ZKd@ZLdAZMdBZNdCZOdDZPdEZQdFZRdGZSdHZTdIZUdJZVdKZWdLZXdMZYdNZZdOZ[dPZ\dQZ]eMeWeXeYgZ^dRZ_dSZ`dTZadUZbdVZcdWZddXZedYZfdZZgd[Zhd\Zid]Zjd^Zkd_Zld`Zmej�eo�D�cgc]}ej�da|�s�|��c}�Gdb�dc�ZqGdd�de�Zrdf�Zsdg�Ztdh�Zudi�ZvGdj�dk�ZwGdl�dm�Zxd�d
ddn�do�Zyd�d
ddn�dp�Zzd
dqdrdds�dt�Z{d
dqdrdds�du�Z|	dd
lm#Z#m$Z$m%Z%m}Z}m~Z~mZm�Z�m�Z�m�Z�dv�Z�e�dwk(�rddl�Z�e��jdx�y�Z�e��jdzd{d|�}�e��jd~dd�d����e��jd�d�d����e��j�Z�e��jre��ye��jse��j�yddl�Z�e��jD]SZ�e�d�k(re�e�j �j"�Z�ne�e�d��5Z�e�e��Z�ddd�e��je���Uyy#e$rdZY���wxYwcc}w#e$rewexcZ}Z~eyeze{e|f\ZZ�Z�Z�Y��:wxYw#1swY�OxYw)�a�Create 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(bytes) -> object

Misc variables:

    __version__
    format_version
    compatible_formats

�)�FunctionType)�dispatch_table)�_extension_registry�_inverted_registry�_extension_cache)�islice)�partialN)�maxsize)�pack�unpack)	�PickleError�
PicklingError�UnpicklingError�Pickler�	Unpickler�dump�dumps�load�loads)�PickleBufferrTF�4.0)z1.0z1.1z1.2z1.3z2.0z3.0rz5.0��c��eZdZdZy)r
z6A common base class for the other pickling exceptions.N��__name__�
__module__�__qualname__�__doc__���/usr/lib/python3.12/pickle.pyr
r
Is��@�r!r
c��eZdZdZy)rz]This exception is raised when an unpicklable object is passed to the
    dump() method.

    Nrr r!r"rrMs���	r!rc��eZdZdZy)raThis 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.

    Nrr r!r"rrTs���	r!rc��eZdZd�Zy)�_Stopc��||_y�N)�value��selfr)s  r"�__init__z_Stop.__init__bs	����
r!N)rrrr,r r!r"r&r&as��r!r&�(�.�0�1�2�F�I�J�K�L�M�N�P�Q�R�S�T�U�V�X�a�b�c�d�}�e�g�h�i�j�l�]�o�p�q�r�s�t�)�u�GsI01
sI00
�������������������������B�C��������������������������z[A-Z][A-Z0-9_]+$c�:�eZdZdZdZd�Zd�Zd�Zd
d�Zd�Z	d�Z
y	)�_Framerric� �||_d|_yr()�
file_write�
current_frame)r+rts  r"r,z_Framer.__init__�s��$���!��r!c�6�tj�|_yr()�io�BytesIOru�r+s r"�
start_framingz_Framer.start_framing�s���Z�Z�\��r!c��|jr8|jj�dkDr|jd��d|_yyy)NrT��force)ru�tell�commit_framerys r"�end_framingz_Framer.end_framing�sC�����$�"4�"4�"9�"9�";�a�"?����D��)�!%�D��#@�r!c	�d�|jr�|j}|j�|jk\s|rx|j�}|j}t|�|jk\r"|ttdt|��z�||�tj�|_yyy)N�<Q)rur~�_FRAME_SIZE_TARGET�	getbufferrt�len�_FRAME_SIZE_MIN�FRAMErrwrx)r+r}�f�data�writes     r"rz_Framer.commit_frame�s�������"�"�A��v�v�x�4�2�2�2�e��{�{�}�������t�9�� 4� 4�4�
�%�$�t�S��Y�"7�7�8�
�d��&(�Z�Z�\��"�'7<�r!c�r�|jr|jj|�S|j|�Sr()rur�rt�r+r�s  r"r�z
_Framer.write�s1������%�%�+�+�D�1�1��?�?�4�(�(r!c�x�|j}|jr|jd��||�||�y)NTr|)rtrur)r+�header�payloadr�s    r"�write_large_bytesz_Framer.write_large_bytes�s5������������D��)�	�f�
�
�g�r!N)F)rrrr�r�r,rzr�rr�r�r r!r"rrrr�s+���O�"��"�*�&�
2�0)�
r!rrc�,�eZdZdd�Zd�Zd�Zd�Zd�Zy)�	_UnframerNc�.�||_||_d|_yr()�	file_read�
file_readlineru)r+r�r��	file_tells    r"r,z_Unframer.__init__s��"���*���!��r!c�>�|jrq|jj|�}|dk(r6t|�dk7r(d|_t|�}|j|�|dd|S|t|�krt	d��|St|�}|j|�|dd|S�Nr�$pickle exhausted before end of frame)ru�readintor�r�r)r+�buf�ns   r"r�z_Unframer.readintos�������"�"�+�+�C�0�A��A�v�#�c�(�a�-�%)��"���H������*��A�����3�s�8�|�%�:�<�<��H��C��A��^�^�A�&�C��F��Hr!c���|jrU|jj|�}|s|dk7rd|_|j|�St|�|krt	d��|S|j|�Sr�)ru�readr�r�r�r+r�r�s   r"r�z_Unframer.readsp������%�%�*�*�1�-�D��A��F�%)��"��~�~�a�(�(��4�y�1�}�%�:�<�<��K��>�>�!�$�$r!c���|jrH|jj�}|sd|_|j�S|ddk7rtd��|S|j�S)N����
r�)ru�readliner�rr�s  r"r�z_Unframer.readline&si������%�%�.�.�0�D��%)��"��)�)�+�+��B�x�8�#�%�:�<�<��K��%�%�'�'r!c��|jr(|jj�dk7rtd��tj|j|��|_y)Nr!z4beginning of a new frame before end of current frame)rur�rrwrxr��r+�
frame_sizes  r"�
load_framez_Unframer.load_frame3sM�����$�"4�"4�"9�"9�";�s�"B�!�F�H�
H��Z�Z����z�(B�C��r!r()rrrr,r�r�r�r�r r!r"r�r�s��"�
�"%�(�Dr!r�c���|jd�D]1}|dk(rtdj||���	|}t||�}�3|fS#t$rtdj||��d�wxYw)N�.z<locals>z&Can't get local attribute {!r} on {!r}z Can't get attribute {!r} on {!r})�split�AttributeError�format�getattr)�obj�name�subpath�parents    r"�
_getattributer�<s����:�:�c�?�	?���j� � �!I�"(�&��s�"3�5�
5�	?��F��#�w�'�C�
	?���;����	?� �!C�"(�&��s�"3�5�:>�
?�	?�s�A
�
&A0c���t|dd�}|�|Stjj�j	�D](\}}|dk(s|dk(s|��	t||�d|ur|cS�*y#t$rY�7wxYw)z$Find the module an object belong to.rN�__main__�__mp_main__r)r��sys�modules�copy�itemsr�r�)r�r��module_name�modules    r"�whichmoduler�Is����#�|�T�2�K����� #�{�{�/�/�1�7�7�9�	���V��:�%��m�+��~��	��V�T�*�1�-��4�"�"�5�
	����	��	�s�A*�*	A6�5A6c��|dk(ry|j�dz	dz}|j|dd��}|dkr|dkDr|dd	k(r|d
dzdk7r|dd}|S)
a�Encode 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'
    >>>
    rr!���littleT��	byteorder�signedr������N)�
bit_length�to_bytes)�x�nbytes�results   r"�encode_longr�\sp��*	�A�v���l�l�n��!�Q�
&�F�
�Z�Z��(�4�Z�
@�F��1�u��!���"�:���6�"�:��#4��":��C�R�[�F��Mr!c�2�tj|dd��S)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
    r�Tr�)�int�
from_bytes)r�s r"�decode_longr�zs��$�>�>�$�(�4�>�@�@r!c�v�eZdZd!ddd�d�Zd�Zd�Zd�Zd�Zd	�Zd"d
�Z	d�Z
d�Z		d#dd
�d�ZiZ
d�Zee
ed�<d�Zee
e<d�Zee
e<d�Zee
e<d�Zee
e<d�Zee
e<erd�Zee
e<d�Zee
e<d�Zee
e <d�Z!e!e
e"<dZ#d�Z$d�Z%e%e
e&<d�Z'd�Z(e(e
e)<d�Z*e*e
e+<d!d�Z,d �Z-e,e
e.<e-e
e<y)$�_PicklerNT��fix_imports�buffer_callbackc��|�t}|dkrt}n#d|cxkr	tksntdtz��|�|dkrtd��||_	|j|_t|j
�|_	|jj|_|jj|_i|_t|�|_|dk\|_d|_|xr|dk|_y#t$rtd��wxYw)	a!This 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, 4 and 5.
        The default protocol is 4. It was introduced in Python 3.4, and
        is incompatible with previous versions.

        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.

        If *buffer_callback* is None (the default), buffer views are
        serialized into *file* as part of the pickle stream.

        If *buffer_callback* is not None, then it can be called any number
        of times with a buffer view.  If the callback returns a false value
        (such as None), the given buffer is out-of-band; otherwise the
        buffer is serialized in-band, i.e. inside the pickle stream.

        It is an error if *buffer_callback* is not None and *protocol*
        is None or smaller than 5.
        Nrzpickle protocol must be <= %drz#buffer_callback needs protocol >= 5z"file must have a 'write' attributer�r�)�DEFAULT_PROTOCOL�HIGHEST_PROTOCOL�
ValueError�_buffer_callbackr��_file_writer��	TypeErrorrr�framerr��_write_large_bytes�memor��proto�bin�fastr�)r+�file�protocolr�r�s     r"r,z_Pickler.__init__�s���F��'�H��a�<�'�H��h�2�"2�2��<�?O�O�P�P��&�8�a�<��B�C�C� /���	B�#�z�z�D���d�.�.�/����[�[�&�&��
�"&�+�+�"?�"?�����	���]��
��q�=�����	�&�7�8�a�<�����	B��@�A�A�	B�s�C*�*C?c�8�|jj�y)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)r��clearrys r"�
clear_memoz_Pickler.clear_memo�s��	
�	�	���r!c��t|d�s#td|jj�d���|jdk\r,|jttd|j�z�|jdk\r|jj�|j|�|jt�|jj�y)z7Write a pickled representation of obj to the open file.r�z%Pickler.__init__() was not called by �.__init__()��<BrN)
�hasattrr�	__class__rr�r��PROTOrr�rz�save�STOPr��r+r�s  r"rz
_Pickler.dump�s����t�]�+��37�>�>�3J�3J�!M�N�
N��:�:��?��J�J�u�t�D�$�*�*�5�5�6��:�:��?��K�K�%�%�'��	�	�#���
�
�4�������!r!c���|jryt|�|jvsJ�t|j�}|j	|j|��||f|jt|�<y)zStore an object in the memo.N)r��idr�r�r��put)r+r��idxs   r"�memoizez_Pickler.memoize�s[���9�9���#�w�d�i�i�'�'�'��$�)�)�n���
�
�4�8�8�C�=�!� �#�X��	�	�"�S�'�r!c���|jdk\rtS|jr+|dkrtt	d|�zSt
t	d|�zStt|�jd�zdzS)Nr�r��<I�ascii�
)	r��MEMOIZEr��BINPUTr�LONG_BINPUT�PUT�repr�encode)r+r�s  r"r�z_Pickler.put�sa���:�:��?��N�
�X�X��S�y���T�3��/�/�"�T�$��_�4�4���c��)�)�'�2�2�U�:�:r!c��|jr+|dkrttd|�zSttd|�zStt|�j
d�zdzS)Nr�r�r�r�r�)r��BINGETr�LONG_BINGET�GETrr�r+�is  r"�getz_Pickler.getsO���8�8��3�w���T�1�
�-�-�"�T�$��]�2�2��T�!�W�^�^�G�,�,�u�4�4r!c��|jj�|j|�}|�|r|j|�y|jjt
|��}|�$|j|j|d��yt}t|dd�}|�||�}|tur�t|�}|jj|�}|�
|||�yt|dt�j|�}|�	||�}nvt|t�r|j|�yt|dd�}|�||j�}n2t|dd�}|�|�}nt!d|j"�d|����t%|t&�r|j||�yt%|t(�st!d|z��t+|�}	d	|	cxkrd
ksnt!d|z��|j,|d|i�y)
Nr�reducer_overrider�
__reduce_ex__�
__reduce__�
Can't pickle z	 object: z%s must return string or tupler��z2Tuple returned by %s must have two to six elementsr�)r�r�
persistent_id�	save_persr�rr�r��NotImplementedr��type�dispatchr�
issubclass�save_globalr�rr�
isinstance�str�tupler��save_reduce)
r+r��save_persistent_id�pidr��rv�reduce�tr��ls
          r"r�z
_Pickler.saves������ � �"�� � ��%���?�1��N�N�3���
�I�I�M�M�"�S�'�"���=��J�J�t�x�x��!��~�&��
����1�4�8�������B�
����S�	�A��
�
�!�!�!�$�A��}��$�����T�#3�^�D�H�H��K�F��!��C�[���a��&��$�$�S�)��!��o�t�<���%���
�
�+�B�$�S�,��=�F��)�#�X��+�-.�Z�Z��->�?�?��b�#�����S�"�%���"�e�$�� @�6� I�J�J�
��G���Q��!���!6�8>�!?�@�
@�	����2�&�S�&r!c��yr(r r�s  r"rz_Pickler.persistent_idWs��r!c��|jr)|j|d��|jt�y	|jtt|�j
d�zdz�y#t$rtd��wxYw)NF)rr�r��2persistent IDs in protocol 0 must be ASCII strings)	r�r�r��	BINPERSID�PERSIDrr�UnicodeEncodeErrorr�r+rs  r"rz_Pickler.save_pers[sq���8�8��I�I�c�e�I�4��J�J�y�!�
J��
�
�6�C��H�O�O�G�$<�<�u�D�E��%�
J�#�H�J�J�
J�s�3A+�+B�r�c	�(�t|t�std��t|�std��|j}|j
}	t
|dd�}
|jdk\r�|
dk(r�|\}}}t|d�stdj|
���|�(||jurtd	j|
���|jd
k\r%||�||�||�|	t�n�t|j|g|��i|��}||�|d�|	t�n�|jdk\r^|
dk(rY|d
}t|d�std��|�||jurtd��|dd}||�||�|	t�n||�||�|	t�|�`t!|�|j"vr8|	t$|j'|j"t!|�d
�z�n|j)|�|�|j+|�|�|j-|�|�T|�||�|	t.�y||�||�||�|	t0�|	t�|	t$�yy)Nz'args from save_reduce() must be a tuplez(func from save_reduce() must be callabler�r��
__newobj_ex__�__new__z#args[0] from {} args has no __new__z(args[0] from {} args has the wrong classrr �
__newobj__rz+args[0] from __newobj__ args has no __new__z0args[0] from __newobj__ args has the wrong classr�)rrr�callabler�r�r�r�r�r�r��	NEWOBJ_EXr	r+�REDUCE�NEWOBJr�r��POPrr��_batch_appends�_batch_setitems�BUILD�TUPLE2)
r+�func�args�state�	listitems�	dictitems�state_setterr�r�r��	func_name�cls�kwargss
             r"rz_Pickler.save_reducegsc���$��&�� I�J�J���~�� J�K�K��y�y���
�
���D�*�b�1�	��:�:��?�y�O�;� $��C��v��3�	�*�#�$I�%+�V�I�%6�8�8���3�c�m�m�#;�#�$N�%+�V�I�%6�8�8��z�z�Q���S�	��T�
��V���i� ��s�{�{�C�A�$�A�&�A���T�
��R���f�
�
�Z�Z�1�_��l�!:�6�q�'�C��3�	�*�#�A�C�C���3�c�m�m�#;�#�F�H�H����8�D���I���J��&�M���J���J��&�M��?��#�w�$�)�)�#��c�D�H�H�T�Y�Y�r�#�w�%7��%:�;�;�<����S�!�� ����	�*�� �� � ��+����#��U���e���\�"��S�	��U���f�
��f�
�
�c�
�'r!c�.�|jt�yr()r��NONEr�s  r"�	save_nonez_Pickler.save_none�s���
�
�4�r!c��|jdk\r#|j|rt�yt�y|j|rtnt
�y)Nr�)r�r��NEWTRUE�NEWFALSE�TRUE�FALSEr�s  r"�	save_boolz_Pickler.save_bool�s0���:�:��?��J�J�#�w�4�8�4��J�J�s�t��.r!c��|jr�|dk\rP|dkr#|jttd|�z�y|dkr#|jttd|�z�yd|cxkrdkr&nn#|jt
td|�z�y|jd	k\rgt|�}t|�}|d
kr&|jttd|�z|z�y|jttd|�z|z�yd|cxkrdkr7nn4|jtt|�jd�zdz�y|jtt|�jd�zd
z�y)Nrr�r���<Hi�i����<ir�r�r�r�sL
)r�r��BININT1r�BININT2�BININTr�r�r��LONG1�LONG4�INTrr�LONG)r+r��encodedr�s    r"�	save_longz_Pickler.save_long�s9���8�8�
�a�x��$�;��J�J�w��d�C��8�9���&�=��J�J�w��d�C��8�9���c�/�Z�/��
�
�6�D��s�O�3�4���:�:��?�!�#�&�G��G��A��3�w��
�
�5�4��a�=�0�7�:�;�
��
�
�5�4��a�=�0�7�:�;���#�+��+��J�J�s�T�#�Y�-�-�g�6�6��>�?��J�J�t�d�3�i�.�.�w�7�7�&�@�Ar!c���|jr#|jttd|�z�y|jtt|�j
d�zdz�y)N�>dr�r�)r�r��BINFLOATr�FLOATrrr�s  r"�
save_floatz_Pickler.save_floatsE���8�8��J�J�x�$�t�S�/�1�2��J�J�u�t�C�y�/�/��8�8�5�@�Ar!c�x�|jdkrJ|s|jtd|��y|jtjt|d�df|��yt
|�}|dkr&|jttd|�z|z�n�|dkDr3|jdk\r$|jttd	|�z|�nb||jjk\r$|jttd
|�z|�n%|jttd
|�z|z�|j|�y)Nr�r r'�latin1r�r����rr�r�)r�r�bytes�codecsrrr�r��SHORT_BINBYTESrr��	BINBYTES8r�r��BINBYTESr��r+r�r�s   r"�
save_bytesz_Pickler.save_bytess���:�:��>��� � ���� �4�
�� � ����"%�c�8�"4�h�!?�S�!�J����H����9��J�J�~��T�1�
�5��;�<�
��^��
�
�a���#�#�I��T�1�
�$=�s�C�
�$�+�+�0�0�
0��#�#�H�t�D�!�}�$<�c�B��J�J�x�$�t�Q�-�/�#�5�6����S�r!c��|jdkr>|s|jtd|��y|jtt|�f|��yt	|�}||j
jk\r$|jttd|�z|�n%|jttd|�z|z�|j|�y)Nrr r'r�)r�r�	bytearrayr]r�r�r�r��
BYTEARRAY8rr�r�rbs   r"�save_bytearrayz_Pickler.save_bytearray#s����:�:��>��� � ��B�C� �8�
�� � ��U�3�Z�M�s� �C����H������.�.�.��#�#�J��d�A��$>��D��J�J�z�D��q�M�1�C�7�8����S�r!c��|jdkrtd��|j�5}|jstd��d}|j�t|j	|��}|rL|jr |j|j��nV|j|j��n6|jt�|jr|jt�ddd�y#1swYyxYw)Nrz0PickleBuffer can only pickled with protocol >= 5zHPickleBuffer can not be pickled when pointing to a non-contiguous bufferT)
r�r�raw�
contiguousr��bool�readonlyrc�tobytesrgr��NEXT_BUFFER�READONLY_BUFFER)r+r��m�in_bands    r"�save_picklebufferz_Pickler.save_picklebuffer3s����z�z�A�~�#�%4�5�5�����
4�a��|�|�'�)N�O�O����(�(�4�"�4�#8�#8��#=�>�G���z�z�����	�	��4��+�+�A�I�I�K�8��J�J�{�+��z�z��
�
�?�3�%
4�
4�
4�s�CC8�8Dc�,�|jr�|jdd�}t|�}|dkr6|jdk\r'|j	t
t
d|�z|z��n|dkDr3|jdk\r$|jtt
d|�z|�n�||jjk\r$|jtt
d|�z|�n�|j	tt
d|�z|z�n�|jd	d
�}|jdd�}|jd
d�}|jdd�}|jdd�}|j	t|jd�zdz�|j|�y)N�utf-8�
surrogatepassr�rr�r\r�r��\z\u005c�z\u0000�
z\u000a�
z\u000d�z\u001a�raw-unicode-escaper�)r�rr�r�r��SHORT_BINUNICODErr��BINUNICODE8r�r��
BINUNICODE�replace�UNICODEr�)r+r�rSr��tmps     r"�save_strz_Pickler.save_strMsC���8�8��j�j��/�:�G��G��A��D�y�T�Z�Z�1�_��
�
�+�d�4��m�;�g�E�F��Z��D�J�J�!�O��'�'��d�4��m�(C�W�M��d�k�k�4�4�4��'�'�
�T�$��]�(B�G�L��
�
�:��T�1�
�5��?�@��+�+�d�I�.�C��+�+�d�I�.�C��+�+�d�I�.�C��+�+�d�I�.�C��+�+�f�i�0�C��J�J�w����,@�!A�A�E�I�J����S�r!c�>�|s?|jr|jt�y|jttz�yt|�}|j}|j}|dkr�|jdk\r�|D]
}||��t|�|vr<|j|t|�d�}|jt|z|z�y|jt|�|j|�y|j}|t�|D]
}||��t|�|vrR|j|t|�d�}|jr|t|z�y|t|dzz|z�y|t�|j|�y)Nr�r�rr�)r�r��EMPTY_TUPLE�MARK�TUPLEr�r�r�r�r�rr1�_tuplesize2coder��POP_MARK)r+r�r�r�r��elementrr�s        r"�
save_tuplez_Pickler.save_tupledsp����x�x��
�
�;�'�
��
�
�4�%�<�(����H���y�y���y�y����6�d�j�j�A�o��
���W�
�
��#�w�$���h�h�t�B�s�G�}�Q�/�0���
�
�3��7�S�=�)�
��
�
�?�1�-�.����S�!���
�
��
�d���	�G���M�	��c�7�d�?��(�(�4��3��=��+�,�C��x�x��h��n�%�
��c�Q�q�S�k�C�'�(��	�e�����S�r!c���|jr|jt�n|jttz�|j|�|j
|�yr()r�r��
EMPTY_LISTr��LISTr�r2r�s  r"�	save_listz_Pickler.save_list�s?���8�8��J�J�z�"��J�J�t�d�{�#����S�����C� r!i�c��|j}|j}|js|D]}||�|t��yt	|�}	tt
||j��}t|�}|dkDr(|t�|D]
}||��|t�n|r||d�|t�||jkry���Nr�r)r�r�r��APPEND�iter�listr�
_BATCHSIZEr�r��APPENDS)r+r�r�r�r��itr�r�s        r"r2z_Pickler._batch_appends�s����y�y���
�
���x�x��
���Q���f�
�
�
�
�%�[����v�b�$�/�/�2�3�C��C��A��1�u��d����A���G���g����S��V���f�
��4�?�?�"��r!c���|jr|jt�n|jttz�|j|�|j
|j��yr()r�r��
EMPTY_DICTr��DICTr�r3r�r�s  r"�	save_dictz_Pickler.save_dict�sE���8�8��J�J�z�"��J�J�t�d�{�#����S�����S�Y�Y�[�)r!c���|j}|j}|js'|D]!\}}||�||�|t��#yt	|�}	tt
||j��}t|�}|dkDr3|t�|D]\}}||�||��|t�n&|r$|d\}}||�||�|t�||jkry��r�)r�r�r��SETITEMr�r�rr�r�r��SETITEMS)	r+r�r�r��k�vr�r�r�s	         r"r3z_Pickler._batch_setitems�s����y�y���
�
���x�x��
���1��Q���Q���g��
�
�
�%�[����v�b�$�/�/�2�3�C��C��A��1�u��d����D�A�q���G���G���h����1�v���1��Q���Q���g���4�?�?�"��!r!c��|j}|j}|jdkr#|jtt|�f|��y|t�|j|�t|�}	tt||j��}t|�}|dkDr'|t�|D]
}||��|t�||jkry�g�Nrr'r)r�r�r�r�setr��	EMPTY_SETr�r�rr�r�r��ADDITEMS)r+r�r�r�r��batchr��items        r"�save_setz_Pickler.save_set�s����y�y���
�
���:�:��>����S�4��9�,�C��8��
�i�����S��
�#�Y������D�O�O�4�5�E��E�
�A��1�u��d��!��D���J���h���4�?�?�"��r!c	��|j}|j}|jdkr#|jtt|�f|��y|t�|D]
}||��t|�|jvr8|t|j|jt|�d�z�y|t�|j|�yr�)
r�r�r�r�	frozensetr�r�r�r�r�r�	FROZENSETr�)r+r�r�r�r�s     r"�save_frozensetz_Pickler.save_frozensets����y�y���
�
���:�:��>����Y��c���#��>��
�d���	�D���J�	��c�7�d�i�i��
�(�T�X�X�d�i�i��3��&8��&;�<�<�=��
�i�����S�r!c	�:�|j}|j}|�
t|dd�}|�|j}t	||�}	t|d��tj|}t||�\}}||urtd|�d|�d|����|jdk\rxtj||f�}	|	r_|	dkDsJ�|	d	kr|t t#d
|	�z�y|	dkr|t$t#d|	�z�y|t&t#d
|	�z�y|j)d�d}
||ur|
}|jdk\r/|j+|�|j+|�|t,�n�||ur|j/t||
f�n�|jdk\r-|t0t3|d�zdzt3|d�zdz�ns|j4r:t6j8}t6j:}||f|vr|||f\}}n	||vr||}	|t0t3|d�zdzt3|d�zdz�|j?|�y#tttf$rtd|�d|�d|���d�wxYw#t<$rtd|||jfz�d�wxYw)Nrr��levelr
z: it's not the same object as r�z: it's not found as r�r�r�rIrJrKrr�rtr�r�z?can't pickle global identifier '%s.%s' using pickle protocol %i) r�r�r�rr��
__import__r�r�r�r�ImportError�KeyErrorr�r�rr�EXT1r�EXT2�EXT4�
rpartitionr��STACK_GLOBALr�GLOBALr]r��_compat_pickle�REVERSE_NAME_MAPPING�REVERSE_IMPORT_MAPPINGr%r�)
r+r�r�r�r�r�r��obj2r��code�lastname�r_name_mapping�r_import_mappings
             r"rz_Pickler.save_globals����
�
���y�y���<��3���5�D��<��<�<�D�!�#�t�,��	.��{�!�,��[�[��-�F�(���6�L�D�&��3��#��+�t�-�.�.��:�:��?�&�*�*�K��+>�?�D���a�x��x��4�<��$��d�D�!1�1�2�
�	�V�^��$��d�D�!1�1�2���$��d�D�!1�1�2���?�?�3�'��*���V���D��:�:��?��I�I�k�"��I�I�d�O��,��
�6�
!����W�v�x�&8�9�
�Z�Z�1�_��&�5��g�6�6��>���g�&�'�).�/�
0����!/�!D�!D��#1�#H�#H� ���&�.�8�(6��T�7J�(K�%�K�� �$4�4�"2�;�"?�K�
Q��f�u�[�'�:�:�U�B��D�'�*�+�-2�3�4�	
���S���e�X�~�6�	4���k�4�)�*�/3�
4�	4��Z&�
Q�#�)�,2�D�$�*�*�+E�F�G�LP�Q�
Q�s�/I�	,I4�*I1�4&Jc��|td�ur|jtd|��S|tt�ur|jttf|��S|td�ur|jtd|��S|j|�S)Nr(r'.).)rrrrr�s  r"�	save_typez_Pickler.save_typeZs����$�t�*���#�#�D�'�s�#�;�;�
�D��(�
(��#�#�D�>�*;��#�E�E�
�D��I�
��#�#�D�&�c�#�:�:�����$�$r!r()T)NNNN)/rrrr,r�rr�r�rr�rrrrrArrGrkrTr�rY�floatrcr]rgre�_HAVE_PICKLE_BUFFERrrrr�rr�rr�r�r�r2r��dictr3r�r�r�r�rr�rr r!r"r�r��si��78�4�!%�78�r�
"�&�.	;�5�D'�L�
J�=A�15�q�>B�q�j�H��$�H�T�$�Z��/�
�H�T�N�B�:�H�S�M�B�
!�H�U�O��$!�H�U�O��)�H�Y���	4�0"3�����*�H�S�M�/�b!�H�U�O�!��H�T�N��J��6*��H�T�N��>�,�H�S�M��*)�H�Y��@�D%�)�H�\���H�T�Nr!r�c�$�eZdZddddd�d�Zd�Zd�Zd	�ZiZd
�Zeee	d<d�Z
e
eed<d
�Zeee
d<d�Zeeed<d�Zeeed<d�Zeeed<d�Zeeed<d�Zeeed<d�Zeeed<d�Zeeed<d�Zeeed<d�Zeeed<d�Z e ee!d<d�Z"e"ee#d<d�Z$e$ee%d<d�Z&e&ee'd<d�Z(d�Z)e)ee*d<d�Z+e+ee,d<d�Z-e-ee.d<d�Z/e/ee0d<d �Z1e1ee2d<d!�Z3e3ee4d<d"�Z5e5ee6d<d#�Z7e7ee8d<d$�Z9e9ee:d<d%�Z;e;ee<d<d&�Z=e=ee>d<d'�Z?e?ee@d<d(�ZAeAeeBd<d)�ZCeCeeDd<d*�ZEeEeeFd<d+�ZGeGeeHd<d,�ZIeIeeJd<d-�ZKeKeeLd<d.�ZMeMeeNd<d/�ZOeOeePd<d0�ZQeQeeRd<d1�ZSeSeeTd<d2�ZUeUeeVd<d3�ZWeWeeXd<d4�ZYd5�ZZeZee[d<d6�Z\e\ee]d<d7�Z^e^ee_d<d8�Z`e`eead<d9�Zbebeecd<d:�Zdedeeed<d;�Zfefeegd<d<�Zheheeid<d=�Zjejeekd<d>�Zld?�Zmd@�Zneneeod<dA�Zpepeeqd<dB�Zrereesd<dC�Zteteeud<dD�Zveveewd<dE�Zxexeeyd<dF�Zzezee{d<dG�Z|e|ee}d<dH�Z~e~eed<dI�Z�e�ee�d<dJ�Z�e�ee�d<dK�Z�e�ee�d<dL�Z�e�ee�d<dM�Z�e�ee�d<dN�Z�e�ee�d<dO�Z�e�ee�d<dP�Z�e�ee�d<dQ�Z�e�ee�d<dR�Z�e�ee�d<y)S�
_UnpicklerT�ASCII�strictN�r��encoding�errors�buffersc��|�t|�nd|_|j|_|j|_i|_||_||_d|_	||_
y)a�This 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.

        If *buffers* is not None, it should be an iterable of buffer-enabled
        objects that is consumed each time the pickle stream references
        an out-of-band buffer view.  Such buffers have been given in order
        to the *buffer_callback* of a Pickler object.

        If *buffers* is None (the default), then the buffers are taken
        from the pickle stream, assuming they are serialized there.
        It is an error for *buffers* to be None if the pickle stream
        was produced with a non-None *buffer_callback*.

        Other optional 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 these 8-bit string instances as bytes objects.
        Nr)r��_buffersr��_file_readliner��
_file_readr�r�r�r�r�)r+r�r�r�r�r�s      r"r,z_Unpickler.__init__ksR��N*1�)<��W�
�$��
�"�m�m����)�)�����	� ��
������
�&��r!c��t|d�s#td|jj�d���t	|j
|j�|_|jj|_|jj|_	|jj|_
g|_g|_|jj|_
d|_|j}|j}		|d�}|st �t#|t$�sJ�||d|��1#t&$r}|j(cYd}~Sd}~wwxYw)z�Read a pickled object representation from the open file.

        Return the reconstituted object hierarchy specified in the file.
        r�z'Unpickler.__init__() was not called by r�rr�N)r�rr�rr�r�r��	_unframerr�r�r��	metastack�stack�appendr�r�EOFErrorr�bytes_typesr&r))r+r�r�key�stopinsts     r"rz_Unpickler.load�s���t�\�*�!�59�^�^�5L�5L�#O�P�
P�"�4�?�?�D�4G�4G�H����N�N�'�'��	����/�/��
����/�/��
������
��j�j�'�'�����
��y�y���=�=��	"���1�g���"�N�!�#�{�3�3�3� ���Q�� ��&����	"��>�>�!��	"�s�/2D!�!	E�*D;�5E�;Ec��|j}|jj�|_|jj|_|Sr()r�r��popr��r+r�s  r"�pop_markz_Unpickler.pop_mark�s5���
�
���^�^�'�'�)��
��j�j�'�'����r!c��td��)Nz%unsupported persistent id encountered)rr&s  r"�persistent_loadz_Unpickler.persistent_load�s���E�F�Fr!c�x�|jd�d}d|cxkr	tksntd|z��||_y)Nr�rzunsupported pickle protocol: %d)r�r�r�r�)r+r�s  r"�
load_protoz_Unpickler.load_proto�s9���	�	�!��Q����E�-�-�-��>��F�G�G���
r!rc��td|jd��\}|tjkDrt	d|z��|j
j
|�y)Nr��zframe size > sys.maxsize: %d)rr�r�r
r�r�r�r�s  r"r�z_Unpickler.load_frame�sG���T�4�9�9�Q�<�0��
�����#��;�j�H�I�I����!�!�*�-r!c��	|j�ddjd�}|j	|j|��y#t$rtd��wxYw)Nr�r�r")r��decode�UnicodeDecodeErrorrr�r�r&s  r"�load_persidz_Unpickler.load_persid�sc��	F��-�-�/�#�2�&�-�-�g�6�C�	
���D�(�(��-�.��"�	F�!�D�F�
F�	F�s�"A�Ac�x�|jj�}|j|j|��yr()r�r�r�r�r&s  r"�load_binpersidz_Unpickler.load_binpersid�s)���j�j�n�n������D�(�(��-�.r!c�&�|jd�yr(�r�rys r"�	load_nonez_Unpickler.load_none�������D�r!c�&�|jd�y)NFr�rys r"�
load_falsez_Unpickler.load_false�s�����E�r!c�&�|jd�y)NTr�rys r"�	load_truez_Unpickler.load_true�r�r!c��|j�}|tddk(rd}n|tddk(rd}nt|d�}|j	|�y)Nr�FTr)r�rFrEr�r�)r+r��vals   r"�load_intz_Unpickler.load_int�sJ���}�}����5���9���C�
�T�!�"�X�
��C��d�A�,�C����C�r!c�^�|jtd|jd��d�y)NrKrr�r�rr�rys r"�load_binintz_Unpickler.load_binint��"�����F�4����1��.�q�1�2r!c�J�|j|jd�d�yr�)r�r�rys r"�load_binint1z_Unpickler.load_binint1�s�����D�I�I�a�L��O�$r!c�^�|jtd|jd��d�y)NrJr�rr�rys r"�load_binint2z_Unpickler.load_binint2r�r!c�~�|j�dd}|r
|ddk(r|dd}|jt|d��y)Nr��Lr)r�r�r�)r+r�s  r"�	load_longz_Unpickler.load_longs?���m�m�o�c�r�"���3�r�7�g�%��c�r�(�C����C��Q�K� r!c��|jd�d}|j|�}|jt|��yr�)r�r�r�r�s   r"�
load_long1z_Unpickler.load_long1s1���I�I�a�L��O���y�y��|�����K��%�&r!c��td|jd��\}|dkrtd��|j|�}|jt	|��y)NrKrrz#LONG pickle has negative byte count)rr�rr�r�r�s   r"�
load_long4z_Unpickler.load_long4sI��
�D�$�)�)�A�,�
'����q�5�!�"G�H�H��y�y��|�����K��%�&r!c�Z�|jt|j�dd��y�Nr�)r�r�r�rys r"�
load_floatz_Unpickler.load_floats �����E�$�-�-�/�#�2�.�/�0r!c�^�|jtd|jd��d�y)NrVr�rr�rys r"�
load_binfloatz_Unpickler.load_binfloatr�r!c�p�|jdk(r|S|j|j|j�S)Nr])r�r�r�r*s  r"�_decode_stringz_Unpickler._decode_string"s.���=�=�G�#��L��<�<��
�
�t�{�{�;�;r!c��|j�dd}t|�dk\r|d|dk(r
|ddvr|dd}ntd��|j|j	tj|�d��y)Nr�r�rs"'r�z)the STRING opcode argument must be quoted)r�r�rr�r
r^�
escape_decoder�s  r"�load_stringz_Unpickler.load_string+sw���}�}��s��#���t�9��>�d�1�g��b��1�d�1�g��6G���"�:�D�!�"M�N�N����D�'�'��(<�(<�T�(B�1�(E�F�Gr!c��td|jd��\}|dkrtd��|j|�}|j|j	|��y)NrKrrz(BINSTRING pickle has negative byte count)rr�rr�r
�r+r�r�s   r"�load_binstringz_Unpickler.load_binstring5sO���d�D�I�I�a�L�)�����7�!�"L�M�M��y�y��~�����D�'�'��-�.r!c��td|jd��\}|tkDrtdtz��|j	|j|��y)Nr�rz2BINBYTES exceeds system's maximum size of %d bytes�rr�r
rr��r+r�s  r"�
load_binbytesz_Unpickler.load_binbytes>�M���d�D�I�I�a�L�)�����=�!�#0�29�#:�;�
;����D�I�I�c�N�#r!c�\�|jt|j�ddd��y)Nr�r{)r�rr�rys r"�load_unicodez_Unpickler.load_unicodeFs#�����C��
�
����,�.B�C�Dr!c���td|jd��\}|tkDrtdtz��|j	t|j|�dd��y)Nr�rz4BINUNICODE exceeds system's maximum size of %d bytesrtru�rr�r
rr�rrs  r"�load_binunicodez_Unpickler.load_binunicodeJ�V���d�D�I�I�a�L�)�����=�!�#0�29�#:�;�
;����C��	�	�#����A�Br!c���td|jd��\}|tkDrtdtz��|j	t|j|�dd��y)Nr�r�z5BINUNICODE8 exceeds system's maximum size of %d bytesrtrurrs  r"�load_binunicode8z_Unpickler.load_binunicode8Rrr!c��td|jd��\}|tkDrtdtz��|j	|j|��y)Nr�r�z3BINBYTES8 exceeds system's maximum size of %d bytesrrs  r"�load_binbytes8z_Unpickler.load_binbytes8Zrr!c���td|jd��\}|tkDrtdtz��t	|�}|j|�|j
|�y)Nr�r�z4BYTEARRAY8 exceeds system's maximum size of %d bytes)rr�r
rrer�r�)r+r��bs   r"�load_bytearray8z_Unpickler.load_bytearray8bsY���d�D�I�I�a�L�)�����=�!�#0�29�#:�;�
;��c�N���
�
�a�����A�r!c��|j�td��	t|j�}|j	|�y#t$rtd��wxYw)NzLpickle stream refers to out-of-band data but no *buffers* argument was givenznot enough out-of-band buffers)r�r�next�
StopIterationr�)r+r�s  r"�load_next_bufferz_Unpickler.load_next_bufferlsb���=�=� �!�#H�I�
I�	D��t�}�}�%�C�	
���C����	D�!�"B�C�C�	D�s�A�Ac��|jd}t|�5}|js|j�|jd<ddd�y#1swYyxYwr)r��
memoryviewrl�
toreadonly)r+r�rps   r"�load_readonly_bufferz_Unpickler.load_readonly_bufferwsG���j�j��n��
��_�	0���:�:�!"�����
�
�2��	0�	0�	0�s�*A�Ac��|jd�d}|j|�}|j|j|��yr�)r�r�r
rs   r"�load_short_binstringz_Unpickler.load_short_binstring~s7���i�i��l�1�o���y�y��~�����D�'�'��-�.r!c�l�|jd�d}|j|j|��yr�)r�r�rs  r"�load_short_binbytesz_Unpickler.load_short_binbytes�s'���i�i��l�1�o�����D�I�I�c�N�#r!c��|jd�d}|jt|j|�dd��y)Nr�rrtru)r�r�rrs  r"�load_short_binunicodez _Unpickler.load_short_binunicode�s0���i�i��l�1�o�����C��	�	�#����A�Br!c�X�|j�}|jt|��yr()r�r�rr�s  r"�
load_tuplez_Unpickler.load_tuple�s���
�
������E�%�L�!r!c�&�|jd�y)Nr r�rys r"�load_empty_tuplez_Unpickler.load_empty_tuple��
�����B�r!c�>�|jdf|jd<yr�r�rys r"�load_tuple1z_Unpickler.load_tuple1�s���*�*�R�.�*��
�
�2�r!c�\�|jd|jdfg|jddy)Nr�r�r7rys r"�load_tuple2z_Unpickler.load_tuple2�s)�� �J�J�r�N�D�J�J�r�N�;�<��
�
�2�3�r!c�x�|jd|jd|jdfg|jddy)N���r�r�r7rys r"�load_tuple3z_Unpickler.load_tuple3�s3�� �J�J�r�N�D�J�J�r�N�D�J�J�r�N�K�L��
�
�2�3�r!c�&�|jg�yr(r�rys r"�load_empty_listz_Unpickler.load_empty_list�r5r!c�&�|ji�yr(r�rys r"�load_empty_dictionaryz _Unpickler.load_empty_dictionary�r5r!c�6�|jt��yr()r�r�rys r"�load_empty_setz_Unpickler.load_empty_set�s�����C�E�r!c�X�|j�}|jt|��yr()r�r�r�r�s  r"�load_frozensetz_Unpickler.load_frozenset�s���
�
������I�e�$�%r!c�F�|j�}|j|�yr()r�r�r�s  r"�	load_listz_Unpickler.load_list�s���
�
������E�r!c��|j�}tdt|�d�D�cic]}||||dz��}}|j|�ycc}w)Nrr�r�)r��ranger�r�)r+r�r�ds    r"�	load_dictz_Unpickler.load_dict�sX���
�
����A�s�5�z�1�-�
/���1�X�u�Q�q�S�z�
!�
/��
/����A���
/s�Ac	��|st|t�rt|d�r	||�}n|j|�}|j|�y#t$r4}td|j�dt|���|j��d}~wwxYw)N�__getinitargs__zin constructor for z: )	rrr�r�rr�
__traceback__r+r�)r+�klassr7r)�errs     r"�_instantiatez_Unpickler._instantiate�s����
�5�$�/��E�,�-�
O��t���
�M�M�%�(�E����E����
O��!&����S��!;�<?�<M�<M�O�O��
O�s�A	�		B�/B�Bc���|j�ddjd�}|j�ddjd�}|j||�}|j||j	��y)Nr�r�)r�r��
find_classrQr��r+r�r�rOs    r"�	load_instz_Unpickler.load_inst�sb�������"�%�,�,�W�5���}�}��s��#�*�*�7�3�������-�����%�����1r!c�j�|j�}|jd�}|j||�y�Nr)r�r�rQ)r+r7r=s   r"�load_objz_Unpickler.load_obj�s*���}�}����h�h�q�k�����#�t�$r!c��|jj�}|jj�}|j|g|���}|j|�yr(�r�r�r+r�)r+r7r=r�s    r"�load_newobjz_Unpickler.load_newobj�sC���z�z�~�~����j�j�n�n����c�k�k�#�%��%�����C�r!c���|jj�}|jj�}|jj�}|j|g|��i|��}|j|�yr(rZ)r+r>r7r=r�s     r"�load_newobj_exz_Unpickler.load_newobj_ex�sX�������!���z�z�~�~����j�j�n�n����c�k�k�#�/��/��/�����C�r!c���|j�ddjd�}|j�ddjd�}|j||�}|j|�y)Nr�rt)r�r�rSr�rTs    r"�load_globalz_Unpickler.load_global�sX�������"�%�,�,�W�5���}�}��s��#�*�*�7�3�������-�����E�r!c��|jj�}|jj�}t|�tust|�turt	d��|j|j
||��y)NzSTACK_GLOBAL requires str)r�r�rrrr�rS)r+r�r�s   r"�load_stack_globalz_Unpickler.load_stack_global�s\���z�z�~�~��������!����:�S� �D��L��$;�!�"=�>�>����D�O�O�F�D�1�2r!c�N�|jd�d}|j|�yr�)r��
get_extension�r+r�s  r"�	load_ext1z_Unpickler.load_ext1�s!���y�y��|�A������4� r!c�`�td|jd��\}|j|�y)NrJr��rr�rcrds  r"�	load_ext2z_Unpickler.load_ext2�&���t�T�Y�Y�q�\�*������4� r!c�`�td|jd��\}|j|�y)NrKrrgrds  r"�	load_ext4z_Unpickler.load_ext4rir!c��g}tj||�}||ur|j|�ytj|�}|s|dkrt	d��td|z��|j|�}|t|<|j|�y)NrzEXT specifies code <= 0zunregistered extension code %d)rrr�rrr�rS)r+r��nilr�r�s     r"rcz_Unpickler.get_extensions������"�"�4��-���c�>��K�K���� �$�$�T�*����q�y�%�&?�@�@��=��D�E�E��d�o�o�s�#��!$�������C�r!c��tjd||�|jdkr^|jrR||ftj
vrtj
||f\}}n%|tjvrtj|}t|d��|jdk\r ttj||�dSttj||�S)Nzpickle.find_classr�rr�r)r��auditr�r�r��NAME_MAPPING�IMPORT_MAPPINGr�r�r�r�)r+r�r�s   r"rSz_Unpickler.find_classs����	�	�%�v�t�4��:�:��>�d�.�.���~��!<�!<�<�-�:�:�F�D�>�J�����>�8�8�8�'�6�6�v�>���6��#��:�:��?� ����V�!4�d�;�A�>�>��3�;�;�v�.��5�5r!c�V�|j}|j�}|d}||�|d<yr�r�r�)r+r�r7r6s    r"�load_reducez_Unpickler.load_reduce*s,���
�
���y�y�{���R�y���$�K��b�	r!c�X�|jr|jd=y|j�yr)r�r�rys r"�load_popz_Unpickler.load_pop1s���:�:��
�
�2���M�M�Or!c�$�|j�yr()r�rys r"�
load_pop_markz_Unpickler.load_pop_mark8s���
�
�r!c�@�|j|jd�yr)r�r�rys r"�load_dupz_Unpickler.load_dup<s�����D�J�J�r�N�#r!c��t|j�dd�}	|j|j|�y#t$rd|��}t|�d�wxYw)Nr��Memo value not found at index )r�r�r�r�r�r)r+r�msgs   r"�load_getz_Unpickler.load_get@sZ����
�
����$�%��	1��K�K��	�	�!��%���	1�2�1�#�6�C�!�#�&�D�0�	1�s	�=�Ac��|jd�d}	|j|j|�y#t$r}d|��}t	|�d�d}~wwxYw)Nr�rr|)r�r�r�r�r�r+r�excr}s    r"�load_bingetz_Unpickler.load_bingetIsU���I�I�a�L��O��	1��K�K��	�	�!��%���	1�2�1�#�6�C�!�#�&�D�0��	1�s�5�	A�A�Ac��td|jd��\}	|j|j|�y#t$r}d|��}t|�d�d}~wwxYw)Nr�rr|)rr�r�r�r�rr�s    r"�load_long_bingetz_Unpickler.load_long_bingetRsZ��
�D�$�)�)�A�,�
'���	1��K�K��	�	�!��%���	1�2�1�#�6�C�!�#�&�D�0��	1�s�>�	A�A�Ac��t|j�dd�}|dkrtd��|jd|j|<y)Nr�rznegative PUT argument)r�r�r�r�r�rs  r"�load_putz_Unpickler.load_put[sA����
�
����$�%���q�5��4�5�5��z�z�"�~��	�	�!�r!c��|jd�d}|dkrtd��|jd|j|<y)Nr�rznegative BINPUT argumentr�)r�r�r�r�rs  r"�load_binputz_Unpickler.load_binputbs;���I�I�a�L��O���q�5��7�8�8��z�z�"�~��	�	�!�r!c��td|jd��\}|tkDrtd��|jd|j
|<y)Nr�rznegative LONG_BINPUT argumentr�)rr�r
r�r�r�rs  r"�load_long_binputz_Unpickler.load_long_binputis@��
�D�$�)�)�A�,�
'����w�;��<�=�=��z�z�"�~��	�	�!�r!c�R�|j}|jd|t|�<yr)r�r�r�)r+r�s  r"�load_memoizez_Unpickler.load_memoizeps ���y�y���*�*�R�.��S��Y�r!c�h�|j}|j�}|d}|j|�yr)r�r�r�)r+r�r)r�s    r"�load_appendz_Unpickler.load_appendus+���
�
���	�	����R�y�����E�r!c���|j�}|jd}	|j}||�y#t$rYnwxYw|j}|D]
}||��yr)r�r��extendr�r�)r+r��list_objr�r�r�s      r"�load_appendsz_Unpickler.load_appends|si���
�
����:�:�b�>��	��_�_�F�
�5�M���	�	��	�������	�D��4�L�	s�6�	A�Ac�p�|j}|j�}|j�}|d}|||<yrrs)r+r�r)r�r�s     r"�load_setitemz_Unpickler.load_setitem�s3���
�
���	�	����i�i�k���R�y����S�	r!c��|j�}|jd}tdt|�d�D]}||dz|||<�y)Nr�rr�r�)r�r�rIr�)r+r�r�rs    r"�
load_setitemsz_Unpickler.load_setitems�sK���
�
����z�z�"�~���q�#�e�*�a�(�	*�A�"�1�q�5�\�D��q��N�	*r!c��|j�}|jd}t|t�r|j	|�y|j
}|D]
}||��yr)r�r�rr��update�add)r+r��set_objr�r�s     r"�
load_additemsz_Unpickler.load_additems�sO���
�
����*�*�R�.���g�s�#��N�N�5�!��+�+�C��
���D�	�
r!c��|j}|j�}|d}t|dd�}|�	||�yd}t|t�rt|�dk(r|\}}|rV|j}tj}|j�D]'\}}	t|�tur|	|||�<�#|	||<�)|r&|j�D]\}}	t|||	��yy)Nr��__setstate__r�)
r�r�r�rrr��__dict__r��internr�rr�setattr)
r+r�r8�inst�setstate�	slotstate�	inst_dictr�r�r�s
          r"�
load_buildz_Unpickler.load_build�s����
�
���	�	����R�y���4���6�����U�O���	��e�U�#��E�
�a��$��E�9���
�
�I��Z�Z�F����
�
%���1���7�c�>�+,�I�f�Q�i�(�#$�I�a�L�	
%�
�!���)�
$���1���a��#�
$�r!c��|jj|j�g|_|jj|_yr()r�r�r�rys r"�	load_markz_Unpickler.load_mark�s0�������d�j�j�)���
��j�j�'�'��r!c�L�|jj�}t|��r()r�r�r&r*s  r"�	load_stopz_Unpickler.load_stop�s���
�
��� ���E�l�r!)�rrrr,rr�r�rr�r�r�r�r�r$r�r#r�r@r�rDr�rCr�rQr�rNr�rLr�rMr�rRrrOrrPrrXrrWr
r
�STRINGr�	BINSTRINGrrarr�rr~rr}rr`r"rfr&rnr*ror,�SHORT_BINSTRINGr.r_r0r|r2r�r4r�r8�TUPLE1r:r5r=�TUPLE3r?r�rAr�rCr�rEr�rGr�rKr�rQrU�INSTrX�OBJr[r0r]r.r_r�rar�rer�rhr�rkr�rcrSrtr/rvr1rxr�rz�DUPr~rr�rr�rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r4r�r�r�r�r r!r"r�r�is���,0�!�(�D�.'�`"�>�G��H��
$�H�U�1�X��.�
$�H�U�1�X��/�&�H�V�A�Y��/�,�H�Y�q�\���!�H�T�!�W���&�H�X�a�[���$�H�W�Q�Z��� �H�S��V��3�%�H�V�A�Y��%�'�H�W�Q�Z��3�'�H�W�Q�Z��!�
"�H�T�!�W��'�$�H�U�1�X��'�$�H�U�1�X��1�#�H�U�1�X��3�)�H�X�a�[��<�H�&�H�V�A�Y��/�,�H�Y�q�\��$�*�H�X�a�[��E�'�H�W�Q�Z��C�.�H�Z��]��C� 0�H�[��^��$�,�H�Y�q�\���.�H�Z��]��� 0�H�[��^��0�
$8�H�_�Q�
� �/�$8�H�_�Q�
� �$�#6�H�^�A�
��C�%:�H�
�a�
 �!�"�$�H�U�1�X���/�H�[��^��+�%�H�V�A�Y��=�%�H�V�A�Y��M�%�H�V�A�Y���-�H�Z��]���3�H�Z��]���+�H�Y�q�\��&�,�H�Y�q�\���"�H�T�!�W���
"�H�T�!�W��
�2�
"�H�T�!�W��%�
 �H�S��V���
&�H�V�A�Y���,�H�Y�q�\���
&�H�V�A�Y��3�!2�H�\�!�_��!�"�H�T�!�W��!�"�H�T�!�W��!�"�H�T�!�W��� 6� �
&�H�V�A�Y���
 �H�S��V���)�H�X�a�[��$��H�S��V��1� �H�S��V��1�&�H�V�A�Y��1� 0�H�[��^��&�
 �H�S��V��&�
&�H�V�A�Y��&�
 0�H�[��^��)�(�H�W�Q�Z���
&�H�V�A�Y��� (�H�W�Q�Z���(�H�W�Q�Z��*�
*�H�X�a�[���*�H�X�a�[��$�,$�H�U�1�X��(�"�H�T�!�W���"�H�T�!�W�r!r�r�c�@�t||||��j|�y�Nr�)r�r)r�r�r�r�r�s     r"�_dumpr��s���T�8��,�.�.2�d�3�ir!c��tj�}t||||��j|�|j	�}t|t�sJ�|Sr�)rwrxr�r�getvaluerr�)r�r�r�r�r��ress      r"�_dumpsr��sG��
�
�
��A��Q��k�,�.�.2�d�3�i�
�*�*�,�C��c�;�'�'�'��Jr!r�r�r�c�>�t|||||��j�S)N�r�r�r�r�)r�r)r�r�r�r�r�s     r"�_loadr��s!���d��W�&�v�7�7;�t�v�>r!c��t|t�rtd��tj|�}t|||||��j
�S)Nz%Can't load pickle from unicode stringr�)rrr�rwrxr�r)�sr�r�r�r�r�s      r"�_loadsr��sD���!�S���?�@�@�
�:�:�a�=�D��d��W�'��8�8<���?r!c�*�ddl}|j�SrW)�doctest�testmod)r�s r"�_testr��s����?�?��r!r�z$display contents of the pickle files)�description�pickle_file�*zthe pickle file)�nargs�helpz-tz--test�
store_truezrun self-test suite)�actionr�z-vz)run verbosely; only affects self-test run�-�rbr()�r�typesr�copyregrrrr�	itertoolsr�	functoolsr	r�r
�structrr�rerwr^r��__all__�_picklerr�r�r�r]rer��format_version�compatible_formatsr�r��	Exceptionr
rrr&r�r�r1r�r�rXrQrNrLrRrMr@r$r#r/r�r�r�r�r~r�r4r�r�r�r�rrr�rr�r�r�r�r�r�r�r�r�r�rWrErFr�r0r�r�r�r�r5r�rCrDrOrPr�rar_r|r}r`r�r�r�r.r�r�r�rfrnror��dir�matchrrr�r�r�r�r�r�r�r�r�r�r�rrrrrrr�r�argparse�ArgumentParser�parser�add_argument�
parse_argsr7�testr��
print_help�pprint�fn�stdin�bufferr��openr�)r�s0r"�<module>r�s[���2�"�M�M���
���	�	�
��:�� �$��N�N�>�"����i� ��������
��	�)�	�	�K�	�		�k�		��I�����������������������������	������	������
����������
��������������
���������������������������������������������������7�����������	��	����	��	��������
��������3�5�D�a�H�B�H�H�-?��$C��D�E�<�<�~6D�6D�v��&�<A�.S�S�p`	"�`	"�J8�4��8��d�D�� $�g�h��>�
!%�w�x��?�<�
�
�
� ��z���
$�X�
$�
$�:�<�F�
�����)��+�����h�|�
"��$�����\�
8��:�����D��y�y�
�����������&�&�
#����9��s�y�y�/�/�0�C��b�$��&�1�"�1�g��&���
�
�c�"�

#�+��_6� ��� ��bE��j1�<�!�:��G�Y�$�f�e�V�;��D�%��u�<��D&�&�s<�K%�K3�K3�K8�=	L�%K0�/K0�8L�L�L	
¿Qué es la limpieza dental de perros? - Clínica veterinaria


Es la eliminación del sarro y la placa adherida a la superficie de los dientes mediante un equipo de ultrasonidos que garantiza la integridad de las piezas dentales a la vez que elimina en profundidad cualquier resto de suciedad.

A continuación se procede al pulido de los dientes mediante una fresa especial que elimina la placa bacteriana y devuelve a los dientes el aspecto sano que deben tener.

Una vez terminado todo el proceso, se mantiene al perro en observación hasta que se despierta de la anestesia, bajo la atenta supervisión de un veterinario.

¿Cada cuánto tiempo tengo que hacerle una limpieza dental a mi perro?

A partir de cierta edad, los perros pueden necesitar una limpieza dental anual o bianual. Depende de cada caso. En líneas generales, puede decirse que los perros de razas pequeñas suelen acumular más sarro y suelen necesitar una atención mayor en cuanto a higiene dental.


Riesgos de una mala higiene


Los riesgos más evidentes de una mala higiene dental en los perros son los siguientes:

  • Cuando la acumulación de sarro no se trata, se puede producir una inflamación y retracción de las encías que puede descalzar el diente y provocar caídas.
  • Mal aliento (halitosis).
  • Sarro perros
  • Puede ir a más
  • Las bacterias de la placa pueden trasladarse a través del torrente circulatorio a órganos vitales como el corazón ocasionando problemas de endocarditis en las válvulas. Las bacterias pueden incluso acantonarse en huesos (La osteomielitis es la infección ósea, tanto cortical como medular) provocando mucho dolor y una artritis séptica).

¿Cómo se forma el sarro?

El sarro es la calcificación de la placa dental. Los restos de alimentos, junto con las bacterias presentes en la boca, van a formar la placa bacteriana o placa dental. Si la placa no se retira, al mezclarse con la saliva y los minerales presentes en ella, reaccionará formando una costra. La placa se calcifica y se forma el sarro.

El sarro, cuando se forma, es de color blanquecino pero a medida que pasa el tiempo se va poniendo amarillo y luego marrón.

Síntomas de una pobre higiene dental
La señal más obvia de una mala salud dental canina es el mal aliento.

Sin embargo, a veces no es tan fácil de detectar
Y hay perros que no se dejan abrir la boca por su dueño. Por ejemplo…

Recientemente nos trajeron a la clínica a un perro que parpadeaba de un ojo y decía su dueño que le picaba un lado de la cara. Tenía molestias y dificultad para comer, lo que había llevado a sus dueños a comprarle comida blanda (que suele ser un poco más cara y llevar más contenido en grasa) durante medio año. Después de una exploración oftalmológica, nos dimos cuenta de que el ojo tenía una úlcera en la córnea probablemente de rascarse . Además, el canto lateral del ojo estaba inflamado. Tenía lo que en humanos llamamos flemón pero como era un perro de pelo largo, no se le notaba a simple vista. Al abrirle la boca nos llamó la atención el ver una muela llena de sarro. Le realizamos una radiografía y encontramos una fístula que llegaba hasta la parte inferior del ojo.

Le tuvimos que extraer la muela. Tras esto, el ojo se curó completamente con unos colirios y una lentilla protectora de úlcera. Afortunadamente, la úlcera no profundizó y no perforó el ojo. Ahora el perro come perfectamente a pesar de haber perdido una muela.

¿Cómo mantener la higiene dental de tu perro?
Hay varias maneras de prevenir problemas derivados de la salud dental de tu perro.

Limpiezas de dientes en casa
Es recomendable limpiar los dientes de tu perro semanal o diariamente si se puede. Existe una gran variedad de productos que se pueden utilizar:

Pastas de dientes.
Cepillos de dientes o dedales para el dedo índice, que hacen más fácil la limpieza.
Colutorios para echar en agua de bebida o directamente sobre el diente en líquido o en spray.

En la Clínica Tus Veterinarios enseñamos a nuestros clientes a tomar el hábito de limpiar los dientes de sus perros desde que son cachorros. Esto responde a nuestro compromiso con la prevención de enfermedades caninas.

Hoy en día tenemos muchos clientes que limpian los dientes todos los días a su mascota, y como resultado, se ahorran el dinero de hacer limpiezas dentales profesionales y consiguen una mejor salud de su perro.


Limpiezas dentales profesionales de perros y gatos

Recomendamos hacer una limpieza dental especializada anualmente. La realizamos con un aparato de ultrasonidos que utiliza agua para quitar el sarro. Después, procedemos a pulir los dientes con un cepillo de alta velocidad y una pasta especial. Hacemos esto para proteger el esmalte.

La frecuencia de limpiezas dentales necesaria varía mucho entre razas. En general, las razas grandes tienen buena calidad de esmalte, por lo que no necesitan hacerlo tan a menudo e incluso pueden pasarse la vida sin requerir una limpieza. Sin embargo, razas pequeñas como el Yorkshire o el Maltés, deben hacérselas todos los años desde cachorros si se quiere conservar sus piezas dentales.

Otro factor fundamental es la calidad del pienso. Algunas marcas han diseñado croquetas que limpian la superficie del diente y de la muela al masticarse.

Ultrasonido para perros

¿Se necesita anestesia para las limpiezas dentales de perros y gatos?

La limpieza dental en perros no es una técnica que pueda practicarse sin anestesia general , aunque hay veces que los propietarios no quieren anestesiar y si tiene poco sarro y el perro es muy bueno se puede intentar…… , pero no se va a poder pulir ni acceder a todas la zona de la boca …. Además los limpiadores dentales van a irrigar agua y hay riesgo de aspiración a vías respiratorias si no se realiza una anestesia correcta con intubación traqueal . En resumen , sin anestesia no se va hacer una correcta limpieza dental.

Tampoco sirve la sedación ya que necesitamos que el animal esté totalmente quieto, y el veterinario tenga un acceso completo a todas sus piezas dentales y encías.

Alimentos para la limpieza dental

Hay que tener cierto cuidado a la hora de comprar determinados alimentos porque no todos son saludables. Algunos tienen demasiado contenido graso, que en exceso puede causar problemas cardiovasculares y obesidad.

Los mejores alimentos para los dientes son aquellos que están elaborados por empresas farmacéuticas y llevan componentes químicos con tratamientos específicos para el diente del perro. Esto implica no solo limpieza a través de la acción mecánica de morder sino también un tratamiento antibacteriano para prevenir el sarro.

Conclusión

Si eres como la mayoría de dueños, por falta de tiempo , es probable que no estés prestando la suficiente atención a la limpieza dental de tu perro. Por eso te animamos a que comiences a limpiar los dientes de tu perro y consideres atender a su higiene bucal con frecuencia.

Estas simples medidas pueden conllevar a que tu perro tenga una vida más larga y mucho más saludable.

Si te resulta imposible introducir un cepillo de dientes a tu perro en la boca, pásate con él por clínica Tus Veterinarios y te explicamos cómo hacerlo.

Necesitas hacer una limpieza dental profesional a tu mascota?
Llámanos al 622575274 o contacta con nosotros

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

¡Hola!