a
    còfÛz  ã                   @   sè  d Z dZdZddlZddlZddlZddlmZ ddlm	Z	 ddl
mZmZmZmZmZmZmZ dd	lmZmZmZmZmZmZ dd
lmZ ddlmZ ddlmZ ddlmZ  ddlm!Z" ddlm#Z$ ddlm%Z& ddl'm(Z(m)Z)m*Z* ddl+m,Z,m-Z-m.Z.m/Z/ e0e0dœdd„Z1G dd„ dƒZ2G dd„ dƒZ3G dd„ dƒZ4G dd„ dƒZ5G dd„ dƒZ6G d d!„ d!ƒZ7G d"d#„ d#ƒZ8G d$d%„ d%ƒZ9G d&d'„ d'ƒZ:eee0e;f d(œd)d*„Z<eee;e0f d(œd+d,„Z=ee;ef eee; e0ef d-œd.d/„Z>dS )0zb
Implementation of stream filters for PDF.

See TABLE H.1 Abbreviations for standard filter names
zMathieu Fenniakzbiziqe@mathieu.fenniak.neté    N)Ú	a85decode)ÚBytesIO)ÚAnyÚDictÚListÚOptionalÚTupleÚUnionÚcasté   )ÚWHITESPACES_AS_BYTESÚb_Údeprecate_with_replacementÚdeprecation_no_replacementÚlogger_warningÚord_)ÚCcittFaxDecodeParameters)ÚColorSpaces)ÚFilterTypeAbbreviations)ÚFilterTypes)ÚImageAttributes)ÚLzwFilterParameters)ÚStreamAttributes)ÚDeprecationErrorÚPdfReadErrorÚPdfStreamError)ÚArrayObjectÚDictionaryObjectÚIndirectObjectÚ
NullObject©ÚdataÚreturnc                    s´   zt  ˆ ¡W S  t jy®   zt  ¡  ˆ ¡W  Y S  t jy¨   t  t jdB ¡}d}‡ fdd„ttˆ ƒƒD ƒD ],}z|| |¡7 }W qn t jy˜   Y qn0 qn| Y  Y S 0 Y n0 dS )a^  
    Decompress the given data using zlib.

    This function attempts to decompress the input data using zlib. If the
    decompression fails due to a zlib error, it falls back to using a
    decompression object with a larger window size.

    Args:
        data: The input data to be decompressed.

    Returns:
        The decompressed data.
    é    ó    c                    s   g | ]}ˆ ||d  … ‘qS )r   © ©Ú.0Úi©r!   r%   úJ/home/httpd/docs/test/DocsMgr/lib/python3.9/site-packages/pypdf/filters.pyÚ
<listcomp>\   r$   zdecompress.<locals>.<listcomp>N)ÚzlibÚ
decompressÚerrorÚdecompressobjÚ	MAX_WBITSÚrangeÚlen)r!   ÚdZ
result_strÚbr%   r)   r*   r-   D   s    r-   c                   @   sZ   e Zd Zedeee eedœdd„ƒZeee	e	edœdd„ƒZ
edee	ed	œd
d„ƒZdS )ÚFlateDecodeN©r!   Údecode_parmsÚkwargsr"   c              	   K   sÔ  d|v rt dddƒ |d }t|tƒr.tdƒ‚t| ƒ}d}|rfz| dd¡}W n ttfyd   Y n0 |dk�rÐd}ztt	|t
j  ¡ ƒ}W n ttfy¦   d}Y n0 ztt	|t
j  ¡ ƒ}W n ttfyÚ   d}Y n0 ztt	|t
j  ¡ ƒ}W n ttf�y   |}Y n0 t || | d ¡d }	|dk�r–|	d8 }	|	| }
t|ƒ}tt|ƒƒD ]0}||	 |
k�rZ|| |||
   d	 ||< �qZt|ƒ}n:d
|  k�r®dk�rÂn nt |||	¡}ntd|›�ƒ‚|S )a/  
        Decode data which is flate-encoded.

        Args:
          data: flate-encoded data.
          decode_parms: a dictionary of values, understanding the
            "/Predictor":<int> key only

        Returns:
          The flate-decoded data.

        Raises:
          PdfReadError:
        ÚdecodeParmsÚ
parametersú4.0.0z*decode_parms as ArrayObject is depreciatedr   z
/Predictoré   é   é   é
   é   z"Unsupported flatedecode predictor )r   Ú
isinstancer   r   r-   ÚgetÚAttributeErrorÚ	TypeErrorr
   ÚintÚLZWÚCOLUMNSÚ
get_objectÚKeyErrorÚCOLORSZBITS_PER_COMPONENTÚmathÚceilÚ	bytearrayr1   r2   Úbytesr5   Ú_decode_png_predictionr   )r!   r7   r8   Zstr_dataZ	predictorZDEFAULT_BITS_PER_COMPONENTÚcolumnsÚcolorsZbits_per_componentÚ	rowlengthÚbppr(   r%   r%   r*   Údecodee   sZ    



þ
ÿ
 
ÿzFlateDecode.decode)r!   rP   rR   r"   c                 C   s€  t | ƒ| dkrtdƒ‚g }d| }|d | }tdt | ƒ|ƒD �]4}t| ||| … ƒ}|d }|dkrn�nî|dkrªt|d |ƒD ] }	||	 ||	|   d ||	< q„�n²|dkrÞtd|ƒD ]}	||	 ||	  d ||	< q¼�n~|dk�rdtd|d ƒD ]$}	||	 d }
||	 |
 d ||	< qöt|d |ƒD ]6}	||	|  }|||	  d }
||	 |
 d ||	< �q*nø|dk�rNtd|d ƒD ]&}	||	 }|}||	 | d ||	< �q|t|d |ƒD ]˜}	||	|  }||	 }||	|  }|| | }t|| ƒ}t|| ƒ}t|| ƒ}||k�r ||k�r |}n||k�r0|}n|}||	 | d ||	< �q²ntd	|›�ƒ‚t|ƒ}| |dd … ¡ q@t|ƒS )
Nr   zImage data is not rectangular)r   r   r>   r=   é   é   zUnsupported PNG filter )r2   r   r1   ÚlistÚabsÚtupleÚextendrN   )r!   rP   rR   ÚoutputZprev_rowdatarS   ÚrowZrowdataZfilter_byter(   ÚfloorÚleftÚupZpaethZup_leftÚpZ	dist_leftZdist_upZdist_up_leftr%   r%   r*   rO   ´   sb    "


ÿz"FlateDecode._decode_png_predictionéÿÿÿÿ)r!   Úlevelr"   c                 C   s   t  | |¡S )zõ
        Compress the input data using zlib.

        Args:
            data: The data to be compressed.
            level: See https://docs.python.org/3/library/zlib.html#zlib.compress

        Returns:
            The compressed data.
        )r,   Úcompress)r!   rb   r%   r%   r*   Úencodeó   s    zFlateDecode.encode)N)ra   )Ú__name__Ú
__module__Ú__qualname__ÚstaticmethodrN   r   r   r   rT   rE   rO   rd   r%   r%   r%   r*   r5   d   s    þüN>r5   c                   @   s6   e Zd ZdZedeeef ee	 e
edœdd„ƒZdS )ÚASCIIHexDecodez€
    The ASCIIHexDecode filter decodes data that has been encoded in ASCII
    hexadecimal form into a base-7 ASCII format.
    Nr6   c                 K   s¬   t | tƒr|  ¡ } d}d}d}|t| ƒkr6tdtƒ qœ| ||d … }|dkrRqœn| ¡ rd|d7 }q||7 }t|ƒdkr’|tt|dd�fƒ7 }d}|d7 }q|dks¨J ‚|S )	aô  
        Decode an ASCII-Hex encoded data stream.

        Args:
          data: a str sequence of hexadecimal-encoded values to be
            converted into a base-7 ASCII string
          decode_parms: a string conversion in base-7 ASCII, where each of its values
            v is such that 0 <= ord(v) <= 127.

        Returns:
          A string conversion in base-7 ASCII, where each of its values
          v is such that 0 <= ord(v) <= 127.

        Raises:
          PdfStreamError:
        r$   r   z4missing EOD in ASCIIHexDecode, check if output is OKr   ó   >r=   é   )Úbase)	rA   Ústrrd   r2   r   re   ÚisspacerN   rE   )r!   r7   r8   ÚretvalZhex_pairÚindexÚcharr%   r%   r*   rT     s.    
ÿ
zASCIIHexDecode.decode)N©re   rf   rg   Ú__doc__rh   r	   rm   rN   r   r   r   rT   r%   r%   r%   r*   ri     s    þ
üri   c                   @   s.   e Zd ZdZedeee eedœdd„ƒZ	dS )ÚRunLengthDecodeuA  
    The RunLengthDecode filter decodes data that has been encoded in a
    simple byte-oriented format based on run length.
    The encoded data is a sequence of runs, where each run consists of
    a length byte followed by 1 to 128 bytes of data. If the length byte is
    in the range 0 to 127,
    the following length + 1 (1 to 128) bytes are copied literally during
    decompression.
    If length is in the range 129 to 255, the following single byte is to be
    copied 257 âˆ’ length (2 to 128) times during decompression. A length value
    of 128 denotes EOD.
    Nr6   c                 K   s¶   g }d}|t | ƒkr tdtƒ q¬| | }|d7 }|dkrR|t | ƒk r¬tdƒ‚qªq¬q|dk r‚|d7 }| | ||| … ¡ ||7 }qd| }| t| | fƒ| ¡ |d7 }qd |¡S )a   
        Decode a run length encoded data stream.

        Args:
          data: a bytes sequence of length/data
          decode_parms: ignored.

        Returns:
          A bytes decompressed sequence.

        Raises:
          PdfStreamError:
        r   z5missing EOD in RunLengthDecode, check if output is OKr   é€   zearly EOD in RunLengthDecodeé  r$   )r2   r   re   r   ÚappendrN   Újoin)r!   r7   r8   Úlstrp   Úlengthr%   r%   r*   rT   H  s*    ÿ


zRunLengthDecode.decode)N)
re   rf   rg   rs   rh   rN   r   r   r   rT   r%   r%   r%   r*   rt   :  s    þürt   c                   @   s<   e Zd ZdZG dd„ dƒZedeee e	e
dœdd„ƒZdS )	Ú	LZWDecodezŠ
    Taken from:

    http://www.java2s.com/Open-Source/Java-Document/PDF/PDF-
    Renderer/com/sun/pdfview/decode/LZWDecode.java.htm
    c                   @   sF   e Zd Zeddœdd„Zddœdd„Zedœdd	„Zedœd
d„Z	dS )zLZWDecode.DecoderNr    c                 C   sR   d| _ d| _|| _d| _d| _dgd | _tdƒD ]}t|ƒ| j|< q2|  ¡  d S )Nrv   r>   r   Ú i   )	ÚSTOPÚ	CLEARDICTr!   ÚbyteposÚbitposÚdictr1   ÚchrÚ
reset_dict)Úselfr!   r(   r%   r%   r*   Ú__init__€  s    zLZWDecode.Decoder.__init__©r"   c                 C   s   d| _ d| _d S )Né  é	   )ÚdictlenÚbitspercode)r„   r%   r%   r*   rƒ   ‹  s    zLZWDecode.Decoder.reset_dictc                 C   s¬   | j }d}|dkr¨| jt| jƒkr&dS t| j| j ƒ}d| j }t||ƒ}||d| j | ? dd| ? @ || > O }||8 }|  j|7  _| jdkr
d| _| jd | _q
|S )Nr   ra   r<   éÿ   r   )rŠ   r   r2   r!   r   r€   Úmin)r„   ZfillbitsÚvalueZnextbitsZbitsfromherer%   r%   r*   Ú	next_code�  s(    


ÿý
zLZWDecode.Decoder.next_codec                 C   s  | j }d}|}|  ¡ }|dkr&tdƒ‚|| jkr6�qq
|| j krJ|  ¡  q
|| j krd|| j| 7 }q
|| jk r°|| j| 7 }| j| | j| d  }|| j| j< |  jd7  _n:| j| | j| d  }||7 }|| j| j< |  jd7  _| jd| j> d kr
| jdk r
|  jd7  _q
|S )a�  
            TIFF 6.0 specification explains in sufficient details the steps to
            implement the LZW encode() and decode() algorithms.

            algorithm derived from:
            http://www.rasip.fer.hr/research/compress/algorithms/fund/lz/lzw.html
            and the PDFReference

            Raises:
              PdfReadError: If the stop code is missing
            r|   ra   z"Missed the stop code in LZWDecode!r   r   é   )r~   rŽ   r   r}   rƒ   r�   r‰   rŠ   )r„   ZcWZbaosZpWr`   r%   r%   r*   rT   £  s6    




ÿþzLZWDecode.Decoder.decode)
re   rf   rg   rN   r…   rƒ   rE   rŽ   rm   rT   r%   r%   r%   r*   ÚDecoder  s   r�   Nr6   c                 K   s   t  | ¡ ¡ S )zÜ
        Decode an LZW encoded data stream.

        Args:
          data: ``bytes`` or ``str`` text to decode.
          decode_parms: a dictionary of parameter values.

        Returns:
          decoded data.
        )r{   r�   rT   ©r!   r7   r8   r%   r%   r*   rT   Î  s    zLZWDecode.decode)N)re   rf   rg   rs   r�   rh   rN   r   r   r   rm   rT   r%   r%   r%   r*   r{   w  s   O þür{   c                   @   s6   e Zd ZdZedeeef ee	 e
edœdd„ƒZdS )ÚASCII85Decodez7Decodes string ASCII85-encoded data into a byte format.Nr6   c                 K   s*   t | tƒr|  ¡ } |  t¡} t| dtd�S )zà
        Decode an Ascii85 encoded data stream.

        Args:
          data: ``bytes`` or ``str`` text to decode.
          decode_parms: a dictionary of parameter values.

        Returns:
          decoded data.
        T)ÚadobeÚignorechars)rA   rm   rd   Ústripr   r   r‘   r%   r%   r*   rT   æ  s    

zASCII85Decode.decode)Nrr   r%   r%   r%   r*   r’   ã  s    þ
ür’   c                   @   s*   e Zd Zedeee eedœdd„ƒZdS )Ú	DCTDecodeNr6   c                 K   s   | S ©Nr%   r‘   r%   r%   r*   rT   ý  s    zDCTDecode.decode)N©	re   rf   rg   rh   rN   r   r   r   rT   r%   r%   r%   r*   r–   ü  s    þür–   c                   @   s*   e Zd Zedeee eedœdd„ƒZdS )Ú	JPXDecodeNr6   c                 K   s   | S r—   r%   r‘   r%   r%   r*   rT     s    zJPXDecode.decode)Nr˜   r%   r%   r%   r*   r™     s    þür™   c                   @   s8   e Zd ZdZd
eeeddœdd„Zeedœdd	„ƒZdS )ÚCCITParametersu;   Â§7.4.6, optional parameters for the CCITTFaxDecode filter.r   N)ÚKrP   Úrowsr"   c                 C   s.   || _ d | _d | _d | _|| _|| _d | _d S r—   )r›   Ú
EndOfBlockZ	EndOfLineZEncodedByteAlignrP   rœ   ZDamagedRowsBeforeError)r„   r›   rP   rœ   r%   r%   r*   r…     s    zCCITParameters.__init__r†   c                 C   s   | j dk rd}nd}|S )Nr   rV   rU   )r›   )r„   Z
CCITTgroupr%   r%   r*   Úgroup  s    
zCCITParameters.group)r   r   r   )re   rf   rg   rs   rE   r…   Úpropertyrž   r%   r%   r%   r*   rš     s   	rš   c                   @   sR   e Zd ZdZeedeeef e	e
dœdd„ƒZed
eee e	eedœdd	„ƒZdS )ÚCCITTFaxDecodeuì   
    Â§7.4.6, CCITTFaxDecode filter (ISO 32000).

    Either Group 3 or Group 4 CCITT facsimile (fax) encoding.
    CCITT encoding is bit-oriented, not byte-oriented.

    Â§7.4.6, optional parameters for the CCITTFaxDecode filter.
    N)r:   rœ   r"   c                 C   s”   d}d}| rˆt tttf |  ¡ ƒ}t|tƒr`|D ],}tj|v rH|tj }tj|v r0|tj }q0n(tj|v rt|tj }tj|v rˆ|tj }t	|||ƒS )Nr   iÀ  )
r
   r	   r   r   rH   rA   ÚCCITTrG   r›   rš   )r:   rœ   ÚkrP   Zparameters_unwrappedZdecode_parmr%   r%   r*   Ú_get_parameters3  s"    ÿ







zCCITTFaxDecode._get_parametersr   )r!   r7   Úheightr8   r"   c              (   K   s´   d|v rt dddƒ |d }t|tƒr2tddd� t ||¡}t| ƒ}d}t |dd	d
d
ddd|j	ddd|j
ddddddd|jdddddddt |¡ddd|j
ddd|d¡&}||  S )Nr9   r:   r;   z!decode_parms being an ArrayObjectz3.15.5)Z
removed_inz'<2shlhhhllhhllhhllhhllhhllhhllhhllhhllhs   IIé*   r<   r>   rV   r   rv   r‡   rU   i  i  r   i  i  i  )r   rA   r   r   r    r£   r2   ÚstructÚpackrP   rœ   rž   Úcalcsize)r!   r7   r¤   r8   ÚparamsZimg_sizeZtiff_header_structZtiff_headerr%   r%   r*   rT   M  sj    
ÿÿØ+zCCITTFaxDecode.decode)Nr   )re   rf   rg   rs   rh   r	   r   r   r   rE   rš   r£   rN   r   r   rT   r%   r%   r%   r*   r    )  s    	ý  ýûr    )Ústreamr"   c                 C   s¾  |   tjd¡}t|tƒr&tt| ¡ ƒ}t|tƒs6|f}|   tji ft	|ƒ ¡}t|t
tfƒsb|f}t| jƒ}|�rºt||ƒD �]:\}}t|tƒr”i }|tjtjfv r²t ||¡}q||tjtjfv rÎt |¡}q||tjtjfv rêt |¡}q||tjtjfv �r
t ||¡}q||tjtj fv �r(t! |¡}q||tj"k�r@t# |¡}q||tj$k�rXt% |¡}q||tj&k�r‚|   t'j(d¡}t) |||¡}q||dk�rªd|v �s d|v �r¸t*dƒ‚q|t*d|› �ƒ‚q||S )a  
    Decode the stream data based on the specified filters.

    This function decodes the stream data using the filters provided in the
    stream. It supports various filter types, including FlateDecode,
    ASCIIHexDecode, RunLengthDecode, LZWDecode, ASCII85Decode, DCTDecode, JPXDecode, and
    CCITTFaxDecode.

    Args:
        stream: The input stream object containing the data and filters.

    Returns:
        The decoded stream data.

    Raises:
        NotImplementedError: If an unsupported filter type is encountered.
    r%   z/Cryptz/Namez/Typez3/Crypt filter with /Name or /Type not supported yetzunsupported filter )+rB   ÚSAÚFILTERrA   r   r
   r   rH   ZDECODE_PARMSr2   rW   rY   r   Ú_dataÚzipr   ÚFTÚFLATE_DECODEÚFTAZFLr5   rT   ZASCII_HEX_DECODEZAHxri   ÚRUN_LENGTH_DECODEZRLrt   Ú
LZW_DECODErF   r{   ÚASCII_85_DECODEZA85r’   Ú
DCT_DECODEr–   Ú
JPX_DECODEr™   ÚCCITT_FAX_DECODEÚIAÚHEIGHTr    ÚNotImplementedError)rª   ÚfiltersZ
decodparmsr!   Zfilter_typer©   r¤   r%   r%   r*   Údecode_stream_dataŽ  sJ    




ÿr¼   c                 C   s   t dddƒ t| ƒS )z#Deprecated. Use decode_stream_data.ÚdecodeStreamDatar¼   r;   )r   r¼   )rª   r%   r%   r*   r½   Ë  s    r½   )Úx_object_objr"   c                    s–  ddl m}m}m}m}m}m}m} t| dƒrB| du rB| j	 
¡ }n|  
¡ }tt| tj ƒtt| tj ƒf}	|  ¡ }
t|
tƒr„|
 ¡ }
t|
ƒ|	d |	d   dkr¸|
d dkr¸|
dd… }
|  dd¡}|  d	tƒ ¡ ¡ }t|tƒrøt|ƒdkrø|d  ¡ }tj| v �r| tj tjk�rd
}|  dd¡dk �rL||  dd¡› d�ddƒ\}}n4|||dk�rtt|tƒ�std|v�rtdn|dƒ\}}d}d}|  tjtƒ ¡ ¡ }t|tƒ�r°|d n|}|tjtj fv �rä||	|
||||ƒ\}}}}�nP|tj!tj"tj#fv �rX|tj!tj#fv �rd}d}nd}d}z|j$t%|
ƒdd�}W n  |�yT   |||	|
ƒ}Y n0 nÜ|tj&k�r€| $t%|
ƒ¡dd  }}}n´|tj'k�r¦||	|
|||ƒ\}}}}nŽ|tj#k�rÖ|j$t%|
ƒdd�dddf\}}}}n^|dk�rþ|||	|
ƒdddf\}}}}n6|dk�rt(d| › �ƒ‚n|||	|
ƒdddf\}}}}|  tj)|j*dk�rZ|tj&tj'fv �sl|�r€|j*dk�r€dd gt| +¡ ƒ nd¡‰ t|t,ƒ�r¨|d  ¡ d!k�r¨d‰ t|t,ƒ�rÚ|d  ¡ d"k�rÚdd gt| +¡ ƒ ‰ ˆ du�r\t-‡ fd#d$„t.tˆ ƒƒD ƒƒ�s\g }t.dtˆ ƒdƒD ]8}ˆ | ‰ˆ |d  ‰| /‡‡fd%d$„t.d&ƒD ƒ¡ �q| 0|¡}tj1| v �rt2| tj1 ƒd }|j3|j3k�ršt4d'|› �t5ƒ nN|j*dk�r°| 6d¡}|j*d(k�rÈ| 6d
¡}n|j*d)k�rÞ| 6d¡}| 7|¡ d|v �rüd*}d+}nd}d}t%ƒ }z|j8||d,� W n: t9�yV   | 6d-¡}d}d}t%ƒ }|j8||d,� Y n0 | :¡ }
z| $t%|
ƒ¡}W n t;�yŠ   d}Y n0 ||
|fS ).a  
    Users need to have the pillow package installed.

    It's unclear if pypdf will keep this function here, hence it's private.
    It might get removed at any point.

    Args:
      x_object_obj:

    Returns:
        Tuple[file extension, bytes, PIL.Image.Image]
    r   )ÚImageÚUnidentifiedImageErrorÚ_extended_image_frombytesÚ_get_imagemodeÚ_handle_flateÚ_handle_jpxÚmode_str_typeÚindirect_referenceNr   ra   r?   z/Colorsz/ColorSpaceÚRGBz/BitsPerComponentr<   Úbitr|   ZGrayr=   z.tiffÚTIFFz.pngÚPNG)rÉ   rÊ   )ÚformatsZJPEGz.jpg)rÉ   FZCMYKz.tifzColorSpace field not found in ÚLg      ð?g        z/Indexedz/Separationc                 3   s   | ]}ˆ | |d  kV  qdS )r=   Nr%   r&   )rT   r%   r*   Ú	<genexpr>`  r$   z!_xobj_to_image.<locals>.<genexpr>c                 3   s*   | ]"}t d |d  ˆ ˆ  ˆ  ƒV  qdS )g     ào@N)Úround)r'   Új)ÚdmaxÚdminr%   r*   rÍ   e  s   r>   z"image and mask size not matching: ÚPÚ1z.jp2ZJPEG2000)ÚformatZRGBA)<Z_xobj_image_helpersr¿   rÀ   rÁ   rÂ   rÃ   rÄ   rÅ   ÚhasattrrÆ   Ú__repr__r
   rE   r¸   ZWIDTHr¹   Úget_datarA   rm   rd   r2   rB   r   rH   rW   ZCOLOR_SPACEr   Z
DEVICE_RGBr«   r¬   r¯   r°   r²   r³   r´   r·   Úopenr   rµ   r¶   r   ZDECODEÚmodeZgetbandsr   Úallr1   rZ   ÚpointZS_MASKÚ_xobj_to_imageÚsizer   re   ÚconvertZputalphaÚsaveÚOSErrorÚgetvalueÚ	Exception)r¾   r¿   rÀ   rÁ   rÂ   rÃ   rÄ   rÅ   Zobj_as_textrÝ   r!   rQ   Zcolor_spacerÙ   Zinvert_colorÚ	extensionÚalphar»   ZlfiltersÚimgZimage_formatÚ_Zlutr(   Zimg_byte_arrZimg1r%   )rT   rÐ   rÑ   r*   rÜ   Ñ  s&   $ÿÿ 
(ÿþÿ
þüûõú
ÿü

ü

üþþýýù
ÿþÿþ*ÿ






rÜ   )?rs   Ú
__author__Ú__author_email__rK   r¦   r,   Úbase64r   Úior   Útypingr   r   r   r   r   r	   r
   Ú_utilsr   r   r   r   r   r   Ú	constantsr   r¡   r   r   r±   r   r¯   r   r¸   r   rF   r   r«   Úerrorsr   r   r   Zgenericr   r   r   r   rN   r-   r5   ri   rt   r{   r’   r–   r™   rš   r    rm   r¼   r½   rÜ   r%   r%   r%   r*   Ú<module>   s@   $   8=le=