%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /lib/python3/dist-packages/duplicity/__pycache__/
Upload File :
Create Path :
Current File : //lib/python3/dist-packages/duplicity/__pycache__/diffdir.cpython-312.pyc

�

�2ee��X�dZddlZddlmZddlmZddlmZddl�dadZGd�de	�Z
d	�Zd
�Zd�Z
d�Zd&d
�Zd&d�Zd'd�Zd&d�Zd�Zd�Zd�Zd�Zd�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd �d!e�ZGd"�d#e�Zd$�Z d%�Z!y)(a
Functions for producing signatures and deltas of directories

Note that the main processes of this module have two parts.  In the
first, the signature or delta is constructed of a ROPath iterator.  In
the second, the ROPath iterator is put into tar block form.
�N)�progress)�
statistics)�util)�*c��eZdZy)�DiffDirExceptionN)�__name__�
__module__�__qualname__���3/usr/lib/python3/dist-packages/duplicity/diffdir.pyrr*s��r
rc��t|�S)z)
    Alias for SigTarBlockIter below
    )�SigTarBlockIter��	path_iters r�DirSigr.s���9�%�%r
c�@�t|tjd��S)a
    Return a tarblock full backup of items in path_iter

    A full backup is just a diff starting from nothing (it may be less
    elegant than using a standard tar file, but we can be sure that it
    will be easy to split up the tar and make the volumes the same
    sizes).
    �)�DirDelta�io�StringIOrs r�DirFullr5s���I�r�{�{�2��/�/r
c�B�t|tjd�|�S)zN
    Return full backup like above, but also write signature to sig_outfp
    r)�DirDelta_WriteSigrr)r�	sig_outfps  r�DirFull_WriteSigrAs���Y����B���C�Cr
c�p�tj�at|t�r#t|D�cgc]
}t
|���c}�}nt
|�}t||�}tjs.tjr)tjj�st|�St|�Scc}w)z�
    Produce tarblock diff given dirsig_fileobj_list and pathiter

    dirsig_fileobj_list should either be a tar fileobj or a list of
    those, sorted so the most recent is last.
    )r�StatsDeltaProcess�stats�
isinstance�list�combine_path_iters�sigtar2path_iter�get_delta_iter�config�dry_runr�tracker�has_collected_evidence�DummyBlockIter�DeltaTarBlockIter)r�dirsig_fileobj_list�x�sig_iter�
delta_iters     rrrHs���
�(�(�*�E��%�t�,�%�DW�&X�q�'7��':�&X�Y��#�$7�8���	�8�4�J�
�~�~�&�/�/�(�2B�2B�2Y�2Y�2[��j�)�)� ��,�,��'Ys�B3c���|r|j�}n|r|j�}nJd��tjtd�t	j
|�tj|�fz�y)zA
    Called by get_delta_iter, report error in getting delta
    z)Both new and sig are None for some reason�Error %s getting delta for %sN)�get_relative_path�log�Warn�_r�uexc�os�fsdecode)�exc�new_path�sig_path�sig_tar�index_strings     r�delta_iter_error_handlerr>\sa����1�1�3��	��1�1�3��=�=�=�q��H�H�Q�.�
/�4�9�9�S�>�2�;�;�|�C\�2]�
]�^�r
c�����|sJ��r|j��|j�|j�}tj	td�||fz����fd�}|j
�r�|r�|j
�r�|jdk(rud|_|jd�}t|jd��}�rt|||j��}|jtj||��n�d|_�r,dtj!dj#������_|j
�sA�r�j'��t(rpt(xj*|j�z
c_nHt|jd��}�rt|||j��}|j|�|j-|�|j.j0|j._|S)	zj
    Return new delta_path which, when read, writes sig to sig_fileobj,
    if sigTarFile is not None
    zGetting delta of %s and %sc����t|��_dtjdj	������_�j
�tj|��y)zG
        Callback activated when FileWithSignature read to end
        �
signature/�/N)	�len�sizer7r8�join�name�addfiler�BytesIO)�
sig_string�index�
sigTarFile�tis ���r�callbackz get_delta_path.<locals>.callbackvsJ����j�/����r�{�{�4�9�9�U�+;�<�=�>������2�r�z�z�*�5�6r
�	signature�diff�rb�snapshot�	snapshot/rB)�get_tarinforJ�
get_ropathr3�Debugr5�isreg�difftype�open�FileWithReadCounter�FileWithSignature�getsize�
setfileobj�librsync�	DeltaFiler7r8rErFrGr �SourceFileSize�copy_attribs�stat�st_size)	r:r;rK�
delta_pathrM�	old_sigfp�newfprJrLs	  `    @@r�get_delta_pathrfjs����
�O�8��
�
!�
!�
#�������$�$�&�J��I�I�a�,�-��8�0D�D�E�7��~�~��H����)9�h�>O�>O�S^�>^�$�
���M�M�$�'�	�#�H�M�M�$�$7�8���%�e�X�x�7G�7G�7I�J�E����h�0�0��E�B�C�(�
���!�"�+�+�d�i�i��.>�"?�!@�A�B�G��~�~����"�"�2�&���$�$�
�(:�(:�(<�<�$�'��
�
�d�(;�<�E��)�%��8�;K�;K�;M�N���!�!�%�(����*�%�&�m�m�3�3�J�O�O���r
c�l�|jdk(r�|r|r|j|�tjt	d�t
j
|j��ztjjtj|j���y|r|r|j|�tjt	d�t
j
|j��ztjjtj|j���y)zI
    Look at delta path and log delta.  Add stats if new_path is set
    rQzA %szM %sN)rW�add_new_filer3�Infor5r7r8r2�InfoCode�
diff_file_newr�escape�add_changed_file�diff_file_changed)rcr:r s   r�log_delta_pathro�s������j�(������x�(����
�f�I����Z�%A�%A�%C�D�E��L�L�&�&��K�K�
�4�4�6�7�	
����"�"�8�,����
�f�I����Z�%A�%A�%C�D�E��L�L�*�*��K�K�
�4�4�6�7�	
r
c	#��K�t||�}|rtjd|�}nd}|D�]\}}tj	td�|xrtj|j�|xrtj|j�fz�|r
|j�s,|s�~|j�s��|jdk7s��tjtd�tj|j��ztjjtj |j���|r[t#|j�j%�}dtj|j���|_|j)|�t*j-|�t#|j������|r||k7rVt.j1t2t4|||f�}|rt7||t*�|�����t*xj8dz
c_��t*j;|���t*j=�|r|j=�yy�w)a1
    Generate delta iter from new Path iter and sig Path iter.

    For each delta path of regular file type, path.difftype with be
    set to "snapshot", "diff".  sig_iter will probably iterate ROPaths
    instead of Paths.

    If sig_fileobj is not None, will also write signatures to sig_fileobj.
    �wNzComparing %s and %srzD %s�deleted/�)�
collate2itersr�make_tarfiler3rUr5�uindexrJ�type�existsrir7r8r2rj�diff_file_deletedrl�ROPathrSrFrGr �add_deleted_file�robust�check_common_errorr>rfro�Errors�add_unchanged_file�close)	�new_iterr.�sig_fileobj�collatedrKr:r;rLrcs	         rr%r%�s������X�x�0�H���&�&�s�K�8�
��
�&�(/���(��	�	�
�#�$��8�T�[�[����8��8�T�[�[����8��
�	
��x�}�}��H�O�O�-�(�.�.�B�2F�����f�I����X�-G�-G�-I�!J�K��L�L�2�2��K�K�� :� :� <�=��
�����/�;�;�=�B� (����X�^�^�)D�(E�F�B�G��&�&�r�*��&�&�x�0��X�^�^�,�,��X��1��2�2�(���8�Z�0��J�
��z�8�U�;� � �����!���$�$�X�.�Q(/�R
�K�K�M�������s�B'I0�*I0�;I0�F%I0c#�DK�tjd|�}d|_|D]�}tj|�}dD](}|j	|�s�|t|�d|dd}}nt
d|����ttj|�jd��}|ds|dd}t|�}||_|dk(s|d	k(rA|j|�|j�r |j|j!|��|����|j#�y�w)
zK
    Convert signature tar file object open for reading into path iter
    �rrs)rArRrrN���zBad tarinfo name rBrNrQ)rru�debug�get_tarinfo_name�
startswithrCr�tupler7�fsencode�splitrzrW�init_from_tarinforVr\�extractfiler�)	�	sigtarobj�tf�tarinfo�tiname�prefixrFrWrJ�ropaths	         rr$r$�s����
�	�	�3�	�	*�B��B�H�����&�&�w�/��@�	A�F�� � ��(�!'��F��
�!6��s���h���		A�#�%6�v�h�#?�@�@��b�k�k�$�'�-�-�d�3�4���R�y��#�2�J�E�����"����{�"�h�*�&<��$�$�W�-��|�|�~��!�!�"�.�.��"9�:���)�*�O�O��s
�AD �CD c#�^K�d\}}	|s	t|�}|j}|s	t|�}|j}kr	|df��d}n||k(r||f��d\}}nd|f��d}�\#t$r|rd|f��|D]}d|f���
YywxYw#t$r|r|df��|D]}|df���
YywxYw�w)a4
    Collate two iterators.

    The elements yielded by each iterator must be have an index
    variable, and this function returns pairs (elem1, elem2), (elem1,
    None), or (None, elem2) two elements in a pair will have the same
    index, and earlier indicies are yielded later than later indicies.
    �NNN��next�
StopIterationrJ)�riter1�riter2�relem1�relem2�index1�index2s      rrtrt	s���� �N�F�F�
��
��f����\�\�F��
��f����\�\�F��F�?��$�,���F�
�v�
��&�.� �'�N�F�F���,���F�?��!�
����,�&�$�'�F���,�&�'��
��!�
�� �$�,�&�$�'�F� �$�,�&�'��
�sI�	B-�A%�B-�B	�4B-�%B�B-�B�B-�	B*�'B-�)B*�*B-c
#���K��dd��j��fd���fd�}t�ttt	�����D�cgc]}|s�|��	}}|r&|j�|dd��||�|r�%yycc}w�w)a�
    Produce new iterator by combining the iterators in path_iter_list

    This new iter will iterate every path that is in path_iter_list in
    order of increasing index.  If multiple iterators in
    path_iter_list yield paths with the same index, combine_path_iters
    will discard all paths but the one yielded by the last path_iter.

    This is used to combine signature iters, as the output will be a
    full up-to-date signature iter.
    Nc�^��	t�|�}|j||fS#t$rYywxYw)zI
        Represent the next element as a triple, to help sorting
        Nr�)�
iter_index�path�path_iter_lists  �r�
get_triplez&combine_path_iters.<locals>.get_tripleDs>���	���z�2�3�D��z�z�:�t�+�+���	��	�s� �	,�,c���|dd}d}|t|�kr:||}|d|k(r�|d�}|r|||<|dz
}n||=ny|t|�kr�9yy)zK
        Update all elements with path_index same as first element
        rrsN)rC)�triple_list�
path_indexr��
old_triple�
new_tripler�s     �r�refresh_triple_listz/combine_path_iters.<locals>.refresh_triple_listNsy���!��^�A�&�
��
��3�{�+�+�$�Z�0�J��!�}�
�*�'�
�1�
�6�
��.8�K�
�+��!�O�J�#�J�/���3�{�+�+r
r�)�reverse�mapr"�rangerC�sort)r�r�r-r�r�s`   @rr#r#5s������$�A�&�N�����,��$"�*�d�5��^�9L�3M�.N�O�U��ST�1�U�K�U�
������!�n�Q����K�(���V�s�A	B	�
B�B�(B	�B	c�:�tj�at|t�rt|�}nt
|�}t|||�}tjs.tjr)tjj�st|�St|�S)a
    Like DirDelta but also write signature into sig_fileobj

    Like DirDelta, sig_infp_list can be a tar fileobj or a sorted list
    of those.  A signature will only be written to newsig_outfp if it
    is different from (the combined) sig_infp_list.
    )rrr r!r"�get_combined_path_iterr$r%r&r'rr(r)r*r+)r�
sig_infp_list�newsig_outfp�
sig_path_iterr/s     rrrgsr��
�(�(�*�E��-��&�.�}�=�
�(��7�
��	�=�,�G�J�
�~�~�&�/�/�(�2B�2B�2Y�2Y�2[��j�)�)� ��,�,r
c�P�t|D�cgc]
}t|���c}�Scc}w)zI
    Return path iter combining signatures in list of open sig files
    )r#r$)r�r-s  rr�r�|s#���M�J�q�/��2�J�K�K��Js�#c�$�eZdZdZd�Zdd�Zd�Zy)rYzH
    File-like object which also computes amount read as it is read
    c��||_y)zFileWithReadCounter initializerN)�infile)�selfr�s  r�__init__zFileWithReadCounter.__init__�s	����r
c�x�	|jj|�}tr"txjt|�z
c_|S#t$ri}d}tj	td�t
j|�tj|jj�fz�Yd}~��d}~wwxYw)Nr
r1)r��read�IOErrorr3r4r5rr6r7r8rFr r_rC)r��length�buf�exs    rr�zFileWithReadCounter.read�s���	j��+�+�"�"�6�*�C��� � �C��H�,� ��
���	j��C��H�H�Q�6�7�4�9�9�R�=�"�+�+�VZ�Va�Va�Vf�Vf�Jg�:h�h�i�i��	j�s�A�	B9�AB4�4B9c�6�|jj�S�N)r�r��r�s rr�zFileWithReadCounter.close�s���{�{� � �"�"r
N�r�)r	r
r�__doc__r�r�r�rr
rrYrY�s�����#r
rYc�(�eZdZdZdZd�Zdd�Zd�Zy)rZzF
    File-like object which also computes signature as it is read
    i�c��||c|_|_tjt	|��|_d|_||_y)au
        FileTee initializer

        The object will act like infile, but whenever it is read it
        add infile's data to a SigGenerator object.  When the file has
        been read to the end the callback will be called with the
        calculated signature, and any extra_args if given.

        filelen is used to calculate the block size of the signature.
        N)r�rMr]�SigGenerator�get_block_size�sig_gen�activated_callback�
extra_args)r�r�rM�filelenr�s     rr�zFileWithSignature.__init__�s:��&,�X�"���T�]��,�,�^�G�-D�E���"&���$��r
c�r�|jj|�}|jj|�|Sr�)r�r�r��update)r�r�r�s   rr�zFileWithSignature.read�s-���k�k���v�&�������C� ��
r
c�6�|jst|j|j�r	|j|j�r�d|_|j|jj�g|j���|jj�S)Nrs)	r�r��	blocksizerMr��getsigr�r�r�r�s rr�zFileWithSignature.close�so���&�&��)�)�D�N�N�+���)�)�D�N�N�+�&'�D�#��D�M�M�$�,�,�-�-�/�B�$�/�/�B��{�{� � �"�"r
Nr�)r	r
rr�r�r�r�r�rr
rrZrZ�s����I�%� �
#r
rZc��eZdZdZd�Zy)�TarBlockz5
    Contain information to add next file to tar
    c� �||_||_y)z8
        TarBlock initializer - just store data
        N)rJ�data)r�rJr�s   rr�zTarBlock.__init__�s����
���	r
N)r	r
rr�r�rr
rr�r��s���r
r�c�Z�eZdZdZd�Zdd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zy)�TarBlockIterz�
    A bit like an iterator, yield tar blocks given input iterator

    Unlike an iterator, however, control over the maximum size of a
    tarblock is available by passing an argument to next().  Also the
    get_footer() is available.
    c��||_d|_d|_d|_d|_d|_d|_d|_d|_d|_	y)z*
        TarBlockIter initializer
        rFN)
�
input_iter�offset�process_waiting�process_next_vol_number�previous_index�previous_block�
remember_next�remember_value�remember_block�queued_data)r�r�s  rr�zTarBlockIter.__init__�sR��%������$���'+��$�"���"���"���"���"�����r
c��t|�|_|jdtj��}t|jtj�\}}|dkDrdtj|z
z}nd}t|d|||fz�S)z<
        Make tarblock out of tarinfo and file data
        �replace)�errors�encodingr�r
s%s%s%s)	rCrD�tobufr&�
fsencoding�divmod�tarfile�	BLOCKSIZEr�)r�rJr��	file_data�headers�blocks�	remainder�filler_datas        r�tarinfo2tarblockzTarBlockIter.tarinfo2tarblock�s|���9�~����-�-�y�6�;L�;L�-�M��"�7�<�<��1B�1B�C���	��q�=��7�#4�#4�y�#@�A�K��K���y�G�Y��+L�L�M�Mr
c�4�|jrJ�td��)z?
        Turn next value of input_iter into a TarBlock
        z'process' not implemented.�r��NotImplementedError)r��vals  r�processzTarBlockIter.process�s���'�'�'�'�!�">�?�?r
c�4�|jsJ�td��)z�
        Get more tarblocks

        If processing val above would produce more than one TarBlock,
        get the rest of them by calling process_continue.
        z$'process_continues' not implemented.r�r�s r�process_continuedzTarBlockIter.process_continued�s���#�#�#�#�!�"H�I�Ir
c��|j�|j}d|_|S|jr|j�}n$|jt	|j
��}|j}|xjt|j�z
c_|j|_||_|jr|j|_||_d|_
|S)z5
        Return next block and update offset
        NF)r�r�r�r�r�r�r�r�rCr�rJr�r�r�r�r�)r��result�block_numbers   r�__next__zTarBlockIter.__next__s������'��%�%�F�#�D���M�����+�+�-�F��\�\�$�t���"7�8�F��3�3�����s�6�;�;�'�'��$�l�l���*������"(�,�,�D��".�D��!&�D���
r
c��y)Nirr�s r�
get_read_sizezTarBlockIter.get_read_sizes��
r
c�2�|j|jfS)zM
        Return index of last tarblock, or None if no previous index
        )r�r�r�s r�get_previous_indexzTarBlockIter.get_previous_index#����"�"�D�$7�$7�7�7r
c��||_y)zW
        Next time next() is called, we will return data instead of processing
        N)r�)r�r�s  r�queue_index_datazTarBlockIter.queue_index_data)s�� ��r
c�.�d|_d|_d|_y)zL
        When called, remember the index of the next block iterated
        TN)r�r�r�r�s r�remember_next_indexz TarBlockIter.remember_next_index/s��"���"���"��r
c�2�|j|jfS)zD
        Retrieve index remembered with remember_next_index
        )r�r�r�s r�recall_indexzTarBlockIter.recall_index7rr
c��t|jtj�\}}d|_dtj|z
zS)zA
        Return closing string for tarfile, reset offset
        rr�)r�r�r��
RECORDSIZE)r�r�r�s   r�
get_footerzTarBlockIter.get_footer=s<��#�4�;�;��0B�0B�C���	������*�*�Y�6�7�7r
c��|Sr�rr�s r�__iter__zTarBlockIter.__iter__Es���r
N)r
)r	r
rr�r�r�r�r�r�rrrrr
r
rrr
rr�r��sF���
 �N�@�J��2�8� �#�8�8�r
r�c��eZdZdZd�Zy)r*z0
    TarBlockIter that does no file reading
    c��|j�}|j}|jr|js|j	||�St
rdt
xjdz
c_t
xj|j�z
c_tjdt
j�|j	||�S)z7
        Get a fake tarblock from delta_ropath
        rsN)rSrJrw�fileobjr�r �SourceFilesr_r[r3�Progress)r��delta_ropathrLrJs    rr�zDummyBlockIter.processNs����
%�
%�
'���"�"��� � ��(<�(<��(�(���3�3��
����"��� � �L�$8�$8�$:�:� ��L�L��u�3�3�4��$�$�U�B�/�/r
N�r	r
rr�r�rr
rr*r*Is���0r
r*c��eZdZdZd�Zy)rzK
    TarBlockIter that yields blocks of a signature tar from path_iter
    c��|j�}|j�r�tj|j	d�t|j
���}|j�}|j�ddj|j�z|_tj|j�|_|j|j||�Sddj|j�z|_tj|j�|_|j|j|�S)z@
        Return associated signature TarBlock from path
        rPs
signature/rBs	snapshot/)rSrVr]�SigFilerXr�r[r�r�rErJrFr7r8r�)r�r�rL�sfp�sigbufs     rr�zSigTarBlockIter.processgs����
�
�
���:�:�<��"�"�4�9�9�T�?�N�4�<�<�>�4R�S�C��X�X�Z�F��I�I�K�#�d�i�i��
�
�&;�;�B�G��k�k�"�'�'�*�B�G��(�(����R��@�@�"�T�Y�Y�t�z�z�%:�:�B�G��k�k�"�'�'�*�B�G��(�(����R�8�8r
Nrrr
rrrbs���9r
rc�"�eZdZdZd�Zd�Zd�Zy)r+z�
    TarBlockIter that yields parts of a deltatar file

    Unlike SigTarBlockIter, the argument to __init__ is a
    delta_path_iter, so the delta information has already been
    calculated.
    c���d�}|j�}|j}|jr|jsB|js
||d�n|jdk(sJ�||d�|j||�S|j
d�}|j|�\}}tr"txjt|�z
c_	|rL|jdk(r
||d�n |jdk(r
||d�nJd��|j|||�Sd|j�d|j��}|�d	�|_||_||_
||_d
|_d|_|j|||�S)z2
        Get a tarblock from delta_ropath
        c�d�|jdk(r|�d�|_y|�d|j��|_y)z(Add prefix to the name of a tarinfo file�.�/N)rF)r�r�s  r�
add_prefixz-DeltaTarBlockIter.process.<locals>.add_prefix�s+���|�|�t�#�"(���|���+1�7�<�<�@��r
�deletedrQrPrOzUnknown difftype�	multivol_r z/1rsr�)rSrJrwrrWr�rX�get_data_blockr �RawDeltaSizerCrF�process_prefix�
process_fp�process_ropathr�r�)	r�rr!rLrJ�fpr��
last_block�	full_names	         rr�zDeltaTarBlockIter.process�sq��
	A��
%�
%�
'���"�"��� � ��(<�(<��$�$��2�z�*�#�,�,�
�:�:�:��2�{�+��(�(���3�3��
�
�t�
$���.�.�r�2���j�����#�d�)�+����$�$�
�2��2�{�+��&�&�&�0��2�w�'�,�,�,�q��(�(���D�9�9��*6�)>�)>����H�	��K�r�"���'������*��� ���'(��$��$�$�U�B��5�5r
c��|j�}|j|�}t|�|kr|j�rt	d��|dfS|dfS)zH
        Return pair (next data block, boolean last data block)
        zError closing fileTF)rr�rCr�r)r�r)�	read_sizer�s    rr$z DeltaTarBlockIter.get_data_block�sU���&�&�(�	��g�g�i� ���s�8�i���x�x�z�&�';�<�<���9����:�r
c���|jsJ�|j}|j�|j}}|j�dt|j���|_|j|j�\}}tr"txjt|�z
c_|r$d|_d|_	d|_d|_d|_n|xjdz
c_|j|||�S)zA
        Return next volume in multivol diff or snapshot
        r Nrs)r�r(rSrJr&�intr�rFr$r'r r%rCr�)r�r�rLrJr�r*s      rr�z#DeltaTarBlockIter.process_continued�s����#�#�#�#��$�$���&�&�(�&�,�,�E���(�(�)��3�t�/K�/K�+L�*M�N����.�.�t���?���j�����#�d�)�+���"&�D��"�D�O�"&�D��#'�D� �+/�D�(��(�(�A�-�(��$�$�U�B��5�5r
N)r	r
rr�r�r$r�rr
rr+r+ys���.6�`�6r
r+c�x�t|t�rt|jd�}nt|t�r
t|d�}n|}|D]}|j|j��|j|j��|j�rJ�t|t�r|j�yy)z<
    Write block_iter to filename, path, or file object
    �wbN)
r!�PathrXrF�str�writer�r
r��setdata)�
block_iter�out_objr)�blocks    r�write_block_iterr9�s����'�4� �
�'�,�,��
%��	�G�S�	!�
�'�4�
 ��
�����
���������H�H�Z�
"�
"�
$�%��x�x�z��>��'�4� �����!r
c�d�|dkryt|dz�dz}t|tj�S)z�
    Return a reasonable block size to use on files of length file_len

    If the block size is too big, deltas will be bigger than is
    necessary.  If the block size is too small, making deltas and
    patching can take a really long time.
    i�i)r/�minr&�
max_blocksize)�file_len�file_blocksizes  rr�r��s8���'����h�*�5�7�#�=���>�6�#7�#7�8�8r
r�r�)"r�r�	duplicityrrr�duplicity.pathr r(�	Exceptionrrrrrr>rfror%r$rtr#rr��objectrYrZr�r�r*rr+r9r�rr
r�<module>rCs���,�
�� ���	
��
��	�y�	�&�	0�D�-�(�+�\
�,:�z�<)�X/)�d-�*L�#�&�#�.##��##�L
�v�
�y�6�y�x0�\�0�29�l�9�.Y6��Y6�x�$
9r

Zerion Mini Shell 1.0