%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__/selection.cpython-312.pyc

�

�2e�r��Z�ddlZddlmZddlmZddlmZmZmZddl	�	Gd�de
�Zy)�N)�dedent)�diffdir)�
GlobbingError�FilePrefixError�select_fn_from_glob)�*c��eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
dd
�Zd�Zdd�Zd�Zdd�Zd�Zdd�Zd�Zdd�Zdd�Zd�Zdd�Zy)�SelectavIterate appropriate Paths in given directory

    This class acts as an iterator on account of its next() method.
    Basically, it just goes through all the files in a directory in
    order (depth-first) and subjects each file to a bunch of tests
    (selection functions) in order.  The first test that includes or
    excludes the file means that the file gets included (iterated) or
    excluded.  The default is include, so with no tests we would just
    iterate all the files in the directory in order.

    The one complication to this is that sometimes we don't know
    whether or not to include a directory until we examine its
    contents.  For instance, if we want to include all the **.py
    files.  If /home/ben/foo.py exists, we should also include /home
    and /home/ben, but if these directories contain no **.py files,
    they shouldn't be included.  For this reason, a test may not
    include or exclude a directory, but merely "scan" it.  If later a
    file in the directory gets included, so does the directory.

    As mentioned above, each test takes the form of a selection
    function.  The selection function takes a path, and returns:

    None - means the test has nothing to say about the related file
    0 - the file is excluded by the test
    1 - the file is included
    2 - the test says the file (must be directory) should be scanned

    Also, a selection function f has a variable f.exclude which should
    be true if f could potentially exclude some file. This is used
    to signal an error if the last function only includes, which would
    be redundant and presumably isn't what the user intends.
    c��t|t�sJt|���g|_||_|jj
|_d|_y)z/Initializer, called with Path of root directoryN)�
isinstance�Path�str�selection_functions�rootpath�uc_name�prefix�
files_from)�self�paths  �5/usr/lib/python3/dist-packages/duplicity/selection.py�__init__zSelect.__init__MsB���$��%�0�s�4�y�0�%�#%�� ���
��m�m�+�+������c��|S�N��rs r�__iter__zSelect.__iter__Us���rc�,�t|j�Sr)�next�iterrs r�__next__zSelect.__next__Xs���D�I�I��rc�z�|jj�|j|j�|_|S)z)Initialize generator, prepare to iterate.)r�setdata�Iterater rs r�set_iterzSelect.set_iter[s-��	
�
�
�����L�L����/��	��rc#�:��K�d����fd�}|js,tjtd�|jz�ytjtd�|jz�|��|j
�sy||�g}g}|r�	t|d�\}}|r)|j|�|j||��n�|r<|D]2}tjtd�|jzd�|���4|dd�=tjtd�|jz�|��|j
�r|j||��|r��yy#t$r&|j�|r|j�Y��wxYw�w)aReturn iterator yielding paths in path

        This function looks a bit more complicated than it needs to be
        because it avoids extra recursion (and no extra function calls
        for non-directory files) while still doing the "directory
        scanning" bit.

        c�8�tjj|j|�}	tj	|�tj
}tj
|�rbtjtd�tj|�ztjjtj|��ytjtd�tj|�ztj j"tj|��	y#t$$rdtjtd�tj|�ztj j&tj|��YywxYw)NzSkipping socket %szError initializing file %s�'Error accessing possibly locked file %s)�osr�join�name�stat�ST_MODE�S_ISSOCK�log�Info�_�fsdecode�InfoCode�skipping_socket�util�escape�Warn�WarningCode�cannot_iterate�OSError�cannot_stat)�excr�filename�fullpath�modes     r�
error_handlerz%Select.Iterate.<locals>.error_handlerms���w�w�|�|�D�I�I�x�8�H�
��w�w�x�(����6���=�=��&��H�H��.�/�"�+�+�h�2G�G����4�4����H�-��"��H�H��6�7�"�+�+�h�:O�O����6�6����H�-����
�
�����?�@�2�;�;�x�CX�X��O�O�/�/��K�K��)��
�

�s�BD,�	A!D,�,A*F�Fc3�P�K�ddlm}�j�|j|�}n3|j�jvr�j|j}ny|D�]D}|j�tj||f�}|s�*�j|�}|jdvr�tj|jtj�s�|dk(s|dk(r�tjt!d�|jztj"j$t&j)|j��t*j,s��t*j,xj.dz
c_��|dk(r|df����&|dk(s��-|j1�s��?|d	f����Gy�w)
a&Generator of files to be included under from filesystems

            Yields (subpath, scan) where scan indicates that path is a
            directory and should be included *if* something inside is
            subsequently included (i.e. generated later)

            This generator applies the configured selection functions and
            so will not yield paths which are to be excluded.

            If --files-from has been specified, this will yield paths from
            that filelist only, subject to any selection functions.

            r)�robustN)�reg�dir��r(FT)�	duplicityrBr�listpathr�check_common_errorr
�appendr
�typer)�accessr+�R_OKr/r7r1r8�cannot_readr5r6r�stats�Errors�isdir)rrB�filesr=�new_path�sr@rs      ��r�dir_scannerz#Select.Iterate.<locals>.dir_scanner�sA�����
)����&�����-��������0�������5���!�
-��!�4�4�]�D�K�K�RV�X`�Qa�b������H�-�A� �
�
��7��	�	�(�-�-�Y[�Y`�Y`�@a��Q��!�q�&�����G�H�8�K[�K[�[��O�O�7�7� �K�K��
�
�6��
#�=�=�#�M�M�0�0�A�5�0��a��&��o�-��a��H�N�N�$4�&��n�,�+
-�s�BF&�C	F&�7F&�
F&�
F&z*Warning: base %s doesn't exist, continuingNzSelecting %s����)rKr/r7r1r�DebugrQr�
StopIteration�poprJ�Log)	rrrU�dirs_to_scan�
dirs_deferred�subpath�scan�delayed_pathr@s	`       @rr$zSelect.Iteratebse�����	�0-	-�^�y�y��H�H�Q�C�D�t�|�|�S�T���	�	�!�N�#�d�l�l�2�3��
��z�z�|��#�D�)�*���
��
� $�\�"�%5� 6�
�����$�$�W�-��#�#�K��$8�9� �(5�+������.� 1�L�4H�4H� H�!�L�*�*�+�&�a�(��	�	�!�N�+�g�o�o�=�>��
��=�=�?� �'�'��G�(<�=�)��!�
�� � �"� �!�%�%�'��	
�s1�BF�E)�%CF�'F�)+F�F�F�Fc��tjd|j���|jstjd�yd}|jD]M}||�}tjdt	|�d�d|j
���|dk(rd	}�B|d
k(s|dk(s�Mn|rdk7rd}�d}|d
k(rtjd�|S|dk(rtjd�|S|dk(sJ�tjd
�|S)zARun through the selection functions and return dominant val 0/1/2zSelection: examining path z8Selection:     + no selection functions found. IncludingrEFzSelection:     result: �4z from function: rFTrzSelection:     - excluding filezSelection:     + including filez/Selection:     ? scanning directory for matches)r/rXrrrr+)rr�scan_pending�sf�results     rr
z
Select.Select�s��	�	�	�.�t�|�|�n�=�>��'�'��I�I�P�Q�����*�*�		�B���X�F��I�I�/��F��A��>N�r�w�w�i�X�Y���{� $���1���!���		��F�a�K��F��>��F��Q�;��I�I�7�8��
�
�q�[��I�I�7�8�
�
��Q�;��;��I�I�G�H��
rc	���|ra|ddjd�rJtjtt	d��|ddfztj
j�td�|D��}d�|rgt�fd�|D��rStjtt	d��d	j|�fztj
j�d}d
}d}	|D�]\}}|dk(r%|j|j|d||�
���1|dk(r$|j|j|d�d���Z|dk(r"|j|j�d����|dk(r4|j||d|||�D]}	|j|	��|dz
}��|dk(r!|j|j!d����|dk(r$|j|j#|d|����	|dk(r"|j|j%|����0|dk(rd}��9|dk(rd
}��B|dk(rd}��K|dk(rd}��T|dk(rd}��]|dk(r|j'|||�|dz
}��~|dk(r%|j|j|d||�����|d k(r5|j||d|||�D]}	|j|	��|dz
}���|d!k(r$|j|j#|d|����Jd"|����	|t-|�k(sJ�|j/�y##t($r}
|j+|
�Yd#}
~
�@d#}
~
wwxYw)$aCCreate selection functions based on list of tuples

        The tuples are created when the initial commandline arguments
        are read.  They have the form (option string, additional
        argument) except for the filelist tuples, which should be
        (option-string, (additional argument, filelist_fp)).

        rVr�	--filter-z�                The last file selection option is the filter option %s, which will have no
                effect as there are no subsequent file selection options. Exiting because
                this probably isn't what you meant.c3�PK�|]}|djd�s�|d��� y�w)rrgN)�
startswith)�.0�opts  r�	<genexpr>z#Select.ParseArgs.<locals>.<genexpr>s%����R�s�3�q�6�3D�3D�[�3Q�C��F�R�s�&�
&)�--filter-globbing�--filter-strictcasec3�&�K�|]}|�v���
y�wrr)rjrk�f_defs  �rrlz#Select.ParseArgs.<locals>.<genexpr>s�����7�#����7�s�z�                Only these filter mode options were specified:
                    %s
                Case sensitive globbing is the default behaviour and so this has no effect.
                Exiting because this probably isn't what you meant.z, �globbingFz	--exclude)�ignore_casez--exclude-if-presentT)�add_to_startz--exclude-device-filesz--exclude-filelistrEz--exclude-other-filesystemsz--exclude-regexpz--exclude-older-thanrnrmz--filter-ignorecasez--filter-literal�literalz--filter-regexp�regexz--files-fromz	--includez--include-filelistz--include-regexpzBad selection option N)rir/�
FatalErrorrr1�	ErrorCode�trailing_filter�set�allr*�redundant_filter�add_selection_func�general_get_sf�present_get_sf�devfiles_get_sf�filelist_general_get_sfs�other_filesystems_get_sf�
regexp_get_sf�exclude_older_get_sf�parse_files_fromr�parse_catch_error�len�parse_last_excludes)r�	argtuples�	filelists�f_opt�filelists_indexr?�no_caserk�argrd�erps           @r�	ParseArgszSelect.ParseArgs�s������2��q�)�4�4�[�A��N�N���7����R�=��#�%�&��
�
�-�-�
��R�i�R�R��<���S�7��7�7��N�N���G����9�9�U�#�%�	&��
�
�.�.�
�������*	&�%�'
<���S��+�%��+�+�D�,?�,?��Q��Za�,?�,b�c��2�2��+�+�D�,?�,?��Q�,G�VZ�+�[��4�4��+�+�D�,@�,@�,B�QU�+�V��0�0�"�;�;�I�o�<V�XY�[^�`d�fm�n�4���/�/��3�4�#�q�(�O��9�9��+�+�D�,I�,I�!�,L�M��.�.��+�+�D�,>�,>�s�A�w�,O�P��2�2��+�+�D�,E�,E�c�,J�K��1�1�#�G��/�/�%�D��1�1�"�G��.�.�$�D��-�-�"�D��N�*��)�)�)�O�*D�c�J�#�q�(�O��K�'��+�+�D�,?�,?��Q��g�,V�W��0�0�"�;�;�I�o�<V�XY�[^�`d�fm�n�4���/�/��3�4�#�q�(�O��.�.��+�+�D�,>�,>�s�A�w�,O�P�;� 5�c�U�;�;�1�O'
<�T�#�i�.�0�0�0�� � �"���	&��"�"�1�%�%��	&�s�)HL#�#	M�,M�Mc�Z�t|t�rPtjt	td��||jfztjj�yt|t�r;tjtd�|ztjj�y�)zDeal with selection error exca8                Fatal Error: The file specification
                    %s
                cannot match any files in the base directory
                    %s
                Useful file specifications begin with the base directory or some
                pattern (such as '**') which matches the base directory.z*Fatal Error while processing expression
%sN)rrr/rvrr1rrw�file_prefix_errorr�globbing_error)rr<s  rr�zSelect.parse_catch_errorSs����c�?�+��N�N���L��
�����$�%��
�
�/�/�
���]�
+��N�N��B�C�c�I��
�
�,�,�
�

rc�:�tjtd�|z�tjxrdxsd}i}d}|j�j
|�D]�}|s�|jd�r|}n�|s�tjj
|�\}}tjj|jj|�jtjj�}	|	|vr
t�||	<t!|t"�r(||	j%tj'|��n||	j%|�|}|r�ߌ�|rDtj)t+td��|fztj,j.�|s@tj)t+td��tj,j0�|j3�D�
�cic]\}
}|
t5|���c}}
|_ycc}}
w)a�Loads an explicit list of files to backup from a filelist, building
        a dictionary of directories and their contents which can be used later
        to emulate a filesystem walk over the listed files only.

        Each specified path is unwound to identify the parents folder(s) as these
        are implicitly to be included.

        Paths read are not to be stripped, checked for comments, etc. Every
        character on each line is significant and treated as part of the path.
        z$Reading files to backup from list %s��
N�/z�                Files-from list contains the absolute path:
                    %s
                All paths specified in a files-from list must be given relative to the backup
                source path.z�                Files-from list specified which contains no files, the backup will be empty as
                a result. Exiting as this probably isn't what you meant,)r/�Noticer1�config�null_separator�read�splitrir)rr*rr�rstrip�sepryrr�add�fsencodervrrw�absolute_files_from�empty_files_from�items�sortedr)r�filelist_fp�	list_name�	separator�filelist�
absolute_path�line�dirname�basenamer�d�fs            rr�zSelect.parse_files_fromns���	�
�
�1�;�<�y�H�I��)�)�2�d�:�d�	����
��$�$�&�,�,�Y�7�	�D������s�#� $�
���$&�G�G�M�M�$�$7�!����w�w�|�|�D�M�M�$9�$9�7�C�J�J�2�7�7�;�;�W���x�'�%(�U�H�T�N��h��,��T�N�&�&�r�{�{�8�'<�=��T�N�&�&�x�0����
	�"��N�N��� ���!�"�	#��
�
�1�1�
���N�N���L����
�
�.�.�	
�5=�N�N�4D�E�D�A�q�1�f�Q�i�<�E����Es�7Hc��|jrv|jdjs\tjt	td��|jdjfztjj�yyy)z;Exit with error if last selection function isn't an excluderVa                Last selection expression:
                    %s
                only specifies that files be included.  Because the default is to
                include all files, the expression is redundant.  Exiting because this
                probably isn't what you meant.N)	r�excluder/rvrr1r+rw�redundant_inclusionrs rr�zSelect.parse_last_excludes�sw���#�#�D�,D�,D�R�,H�,P�,P��N�N���2��	��+�+�B�/�4�4�6�
7��
�
�1�1�

�-Q�#rNc�x�|r|jjd|�y|jj|�y)z6Add another selection function at the end or beginningrN)r�insertrJ)r�sel_funcrss   rr|zSelect.add_selection_func�s1����$�$�+�+�A�x�8��$�$�+�+�H�5rc�X�|j�}|sd|fS|jd�rd|fS|}|jd�rd}|dd}n|jd�rd}|dd}|jd�r|jd�s"|jd	�r|jd	�r|dd
}||fS)ar
        Sanitises lines of both normal and globbing filelists, returning
        (line, include) and line=None if blank/comment

        The aim is to parse filelists in a consistent way, prior to the
        interpretation of globbing statements. The function removes
        whitespace, comment lines and processes modifiers (leading +/-)
        and quotes.
        N�#z+ rErFz- r�'�"rV)�stripri�endswith)rr��include_default�includes    r�filelist_sanitise_linezSelect.filelist_sanitise_line�s����z�z�|�����(�(��?�?�3����(�(�!���?�?�4� ��G����8�D�
�_�_�T�
"��G����8�D��O�O�C� �T�]�]�3�%7�T�_�_�S�=Q�VZ�Vc�Vc�dg�Vh���"�:�D��W�}�rc#�vK�tjtd�||fz�tjxrdxsd}	|jd�|j�j|�D]0}|j||�\}}	|s�|j||	||����2y#t$r
}Yd}~�ad}~wwxYw�w)a Return list of selection functions by reading fileobj

        filelist_fp should be an open file object
        inc_default is true if this is an include list
        list_name is just the name of the list, used for logging
        mode indicates whether to glob, regex, or not

        zReading %s filelist %sr�r�rN)r/r�r1r�r��seek�	Exceptionr�r�r�r})
rr��inc_defaultr�r?rrr�r�r�r�s
          rr�zSelect.filelist_general_get_sfs�s�����	�
�
�1�-�.�$�	�1B�B�C��)�)�2�d�:�d�	�	����Q�� �$�$�&�,�,�Y�7�	H�D� �7�7��k�J�M�D�'����%�%�d�G�T�;�G�G�	H���	���	�s)�<B9�B#�AB9�#	B6�,B9�1B6�6B9c�����dk(s�dk(sJ�|jj����fd�}�|_d|_|S)z=Return selection function matching files on other filesystemsrrEc�P��|j�r|j��k7r�Syr)�exists�	getdevloc)rr��root_devlocs ��rr�z1Select.other_filesystems_get_sf.<locals>.sel_funcs"����{�{�}����!1�[�!@���rzMatch other filesystems)rr�r�r+)rr�r�r�s ` @rr�zSelect.other_filesystems_get_sf�sG����!�|�w�!�|�+�+��m�m�-�-�/��	� '�;���1��
��rc�2����dk(s�dk(sJ�d}|rtj}	tj||����fd�}�|_d�xrdxsd�d|xrd	xsd
�d|��|_|S#t$r#tjt
d�|z��wxYw)z0Return selection function given by regexp_stringrrEz%Error compiling regular expression %sc�@���j|j�r�Syr)�searchr)rr��regexps ��rr�z&Select.regexp_get_sf.<locals>.sel_funcs����}�}�T�\�\�*���rzregular expression r�r�� �no-��case: )	�re�
IGNORECASE�compiler�r/r7r1r�r+)r�
regexp_stringr�rr�flagsr�r�s  `   @rr�zSelect.regexp_get_sfs�����!�|�w�!�|�+�+�����M�M�E�	��Z�Z�
�u�5�F�
	� '�;���!�'�"7�i�"D�9�!E�Q��$�u�*��+�6�-��
B�	�
�����	��H�H�Q�>�?�-�O�P��	�s�A*�*,Bc�(�d�}d|_d|_|S)z4Return a selection function to exclude all dev filesc�&�|j�ryy�Nr)�isdev)rs rr�z(Select.devfiles_get_sf.<locals>.sel_func.s���z�z�|��rrEzExclude device files�r�r+)rr�s  rrzSelect.devfiles_get_sf*s��	����.��
��rc��|dk(s|dk(sJ�t|t�sJ�|dk(rR|j�jd�r3|t	d�d}t
j
|�j�}d}|dk(r|j|||�S|dk(r|j|||�S|dk(r|j|||�SJd	|����)
abReturn selection function given by a pattern string

        The selection patterns are interpretted in accordance with the mode
        argument, "globbing", "literal", or "regex".

        The 'ignorecase:' prefix is a legacy feature which historically lived on
        the globbing code path and was only ever documented as working for globs.
        rrErqzignorecase:NTrtruzBad selection mode )rr�lowerrir�r)r2�casefold�glob_get_sf�literal_get_sfr�)r�pattern_strr�r?rrs     rr}zSelect.general_get_sf8s����!�|�w�!�|�+�+��+�s�+�+�+��:��+�"3�"3�"5�"@�"@��"O�%�c�-�&8�&:�;�K��+�+�k�2�;�;�=�K��K��:���#�#�K��+�F�F�
�Y�
��&�&�{�G�[�I�I�
�W�_��%�%�k�7�K�H�H�2�+�D�6�2�2�1rc�����|dk(s|dk(sJ�ddlm���fd�}|dk(r|}n.tjdtjj
�|_d|xrdxsd�d	���|_|S)
zEReturn selection function given by existence of a file in a directoryrrE)rIc�`����j�r�fd�}�|�j�g�ryyy)Nc�0��tjtd��jztjj
tj�j��tjr#tjxjdz
c_
y)Nr(rEF)r/r7r1rr8rNr5r6rrOrP)�_exc�	_filenamers  �rr@zFSelect.present_get_sf.<locals>.exclude_sel_func.<locals>.error_handler`sa����H�H��C�D�t�|�|�S����3�3����D�L�L�1��
�}�}��
�
�,�,��1�,� rr)rQ�contains)rr@rIr=s` ��r�exclude_sel_funcz/Select.present_get_sf.<locals>.exclude_sel_func\s0����z�z�|�
!�&�m�T�]�]�X�J�O���)rz<--include-if-present not implemented (would it make sense?).z
Command-line zinclude-if-presentzexclude-if-presentz filename: )�duplicity.robustrIr/rvrw�not_implementedr�r+)rr=r�r�r�rIs `   @rr~zSelect.present_get_sfUs����!�|�w�!�|�+�+�7�	 �0�a�<�'�H��N�N�N��
�
�-�-�
�
 '�;���'��(H�4H�(`�L`�'a�al�mu�lv�w��
��rc�R��t|t�s-Jd|jtj�d��d���t|d|�|j�st|��|dk(r�fd�}n
t|�|�}�|_d�xrdxsd	�d
|xrdxsd�d
|��|_	|S)z+Return selection function based on glob_strzThe glob string �ignorez is not unicoderEz**c����Srr)rr�s �r�<lambda>z$Select.glob_get_sf.<locals>.<lambda>�s���G�rzshell glob r�r�r�r�r�r�)
rr�decode�sys�getfilesystemencodingrrrr�r+)r�glob_strr�rrr�s  `  rr�zSelect.glob_get_sf�s������c�
�	f�
�h�o�o�c�.G�.G�.I�8�T�U�Ud�e�	f�
�=�"�8�Q��<�T�]�]�K�!�(�+�+��t��+�H�*�8�W�k�J�H�&�;���%�g�&;�)�&H�y�%I��;�K`�[`�Kf�df�Jg�gm�nv�mw�x��
��rc���|j|d|�|j�st|��|j|||�}||_d|xrdxsd�d|xrdxsd�d|��|_|S)	z�Return a selection function that matches a literal string while
        still including the contents of any folders which are matched
        rEzliteral string r�r�r�r�r�r�)�select_fn_from_literalrrr�r+)r�lit_strr�rrr�s     rr�zSelect.literal_get_sf�s���D�t�*�*�7�A�{�C�D�M�M�R�!�'�*�*��.�.�w���M��&�;����g�3�)�@�y�A��{�G\�W\�Gb�`b�Fc�ci�jq�ir�s�	�
��rc�4���fd�}d|_d���|_|S)zEReturn selection function based on files older than modification datec���|j�sy	tjj|j��kry	y#t
$r
}Yd}~yd}~wwxYwr�)�isregr)r�getmtimer+r:)rr��dates  �rr�z-Select.exclude_older_get_sf.<locals>.sel_func�sT����:�:�<��
��7�7�#�#�D�I�I�.��5��6����
����
�s�,A�	A�ATzSelect older than r�)rr�r�s ` rr�zSelect.exclude_older_get_sf�s%���
	� ���,�T�F�3��
��rc������dk7r
�ddk(r�dd��r#tj��j�����fd�}|S)aReturn a function test_fn(path) which test where a path matches a
        literal string. See also select_fn_from_blog() in globmatch.py

        This function is separated from literal_get_sf() so that it can be used
        to test the prefix without creating a loop.

        r�rVNc�$���r.tj|j�j�}n|j}|�k(r�S|j	��r|t��dk(r�S�j	|�r�t|�dk(r�dk(ryy)Nr�rErF)r)r2rr�rir�)rrrrr�r�s  ���r�test_fnz.Select.select_fn_from_literal.<locals>.test_fn�s������+�+�d�l�l�3�<�<�>���,�,���'�!����#�#�G�,���W��1F�#�1M����#�#�G�,���W��1F�#�1M�RY�]^�R^��r)r)r2r�)rr�r�rrr�s ``` rr�zSelect.select_fn_from_literal�sH����c�>�g�b�k�S�0��c�r�l�G���k�k�'�*�3�3�5�G�	� �rr)rqF)F)�__name__�
__module__�__qualname__�__doc__rrr!r%r$r
r�r�r�r�r|r�r�r�r�rr}r~r�r�r�r�rrrr
r
+s����B����q>�f"�HX#�t�6<F�|�&6��@H�.� �8�3�:)�V�,� �& rr
)r��textwraprrGr�duplicity.globmatchrrr�duplicity.path�objectr
rrr�<module>rs2��0�����
��n
�V�n
r

Zerion Mini Shell 1.0