Hacked By AnonymousFox

Current Path : /opt/cloudlinux/venv/lib/python3.11/site-packages/git/objects/submodule/__pycache__/
Upload File :
Current File : //opt/cloudlinux/venv/lib/python3.11/site-packages/git/objects/submodule/__pycache__/base.cpython-311.pyc

�

�܋fc���R�ddlmZddlZddlZddlZddlZddlZddlmZddl	m
Z
mZddlm
Z
mZmZddlmZmZmZmZddlmZmZddlmZdd	lmZmZmZmZmZm Z dd
lm!Z!ddl"m#Z$ddl%m&Z&m'Z'm(Z(m)Z)m*Z*dd
l+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1ddl+m2Z2m3Z3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9e0rddl:m;Z;ddl<m=Z=ddl>m?Z?ddgZ@ejAd��ZBeB�CejD����Gd�de��ZEeEjFZFeEjGZGeEjHZHeEjIZIeEjJZJGd�dee��ZKdS)�)�BytesION)�Git)�defenc�is_win)�SectionConstraint�GitConfigParser�cp)�InvalidGitRepositoryError�NoSuchPathError�RepositoryDirtyError�BadName)�IndexObject�Object)�TraversableIterableObj)�join_path_native�to_native_path_linux�RemoteProgress�rmtree�unbare_repo�IterableList)�HIDE_WINDOWS_KNOWN_ERRORS�)�mkhead�sm_name�
sm_section�SubmoduleConfigParser�find_first_remote_branch)�Callable�Dict�Mapping�Sequence�
TYPE_CHECKING�cast)�Any�Iterator�Union)�
Commit_ish�Literal�PathLike�TBD)�	IndexFile)�Repo)�Head�	Submodule�UpdateProgresszgit.objects.submodule.basec��eZdZUdZd�eejejdz��D��\ZZZ	ejdzZe
ed<dZdS)r/z�Class providing detailed progress information to the caller who should
    derive from it and implement the ``update(...)`` messagec��g|]}d|z��S)r�)�.0�xs  �k/builddir/build/BUILD/cloudlinux-venv-1.0.6/venv/lib/python3.11/site-packages/git/objects/submodule/base.py�
<listcomp>zUpdateProgress.<listcomp>Gs��u�u�u�!�q�A�v�u�u�u���
_num_op_codesr2N)
�__name__�
__module__�__qualname__�__doc__�rangerr9�CLONE�FETCH�	UPDWKTREE�int�__annotations__�	__slots__r2r7r5r/r/Bso�������@�@�v�u�u�u�^�5Q�Sa�So�rs�Ss�/t�/t�u�u�u��E�5�)�'�5��9�M�3�9�9�9��I�I�Ir7c�Z��eZdZUdZdZdZdZdZej	ej
zZdZe
ded<dZd	Z						d_ddd
edeed
fdeed
fdeed
fdeed
fdeed
fdeed
fdd
f�fd�
Zdedd
f�fd�Zedddedfd���Zededefd���Zdedefd�Z de!defd�Z"defd�Z#defd�Z$defd �Z%edddeed
fd!ede&fd"���Z'd`d#�Z(edede)fd$���Z*d!ede+fd%�Z,ed&ddededefd'���Z-e		dadddededed)ed*ed+eddfd,���Z.ed&ddedefd-���Z/ed.ed/edd
fd0���Z0e								dbdddededeed
fdeed
fd1ed2eed
fd3ee1eefd
fd4ee2e3d
fd)ed*eddfd5���Z4											dcd7ed8ed9ed:ed;d<ed=ed>ed3ee1eefd
fd4ee2e3d
fd)ed*eddfd?�Z5e6ddd@edAedBeddfdC���Z7e6				dedBed=edAed<eddf
dD���Z8dfdEeed
fdFeddfdG�Z9e6	dgdHedIdJede+dKfdL���Z:e6dMeddfdN���Z;e6dhdO���Z<defdP�Z=defdQ�Z>e?didS���Z@e?defdT���ZAe?defdU���ZBe?defdV���ZCe?djdX���ZDe?defdY���ZEde+e&fdZ�ZFdedfd[�ZGe	dkdddeeefd]ed+edeHdf
d^���ZI�xZJS)lr.avImplements access to a git submodule. They are special in that their sha
    represents a commit in the submodule's repository which is to be checked out
    at the path of this instance.
    The submodule type does not have a string type associated with it, as it exists
    solely as a marker in the tree and index.

    All methods work in bare and non-bare repositories.�name�.gitmodules�branch�master�	submodule�type)�_parent_commit�_url�_branch_path�_name�__weakref__��pathrMrNN�repor,�binsha�moderR�
parent_commit�url�branch_path�returnc	���tt|���||||��d|_||_|�||_|�||_|�	||_dSdS)a�Initialize this instance with its attributes. We only document the ones
        that differ from ``IndexObject``

        :param repo: Our parent repository
        :param binsha: binary sha referring to a commit in the remote repository, see url parameter
        :param parent_commit: see set_parent_commit()
        :param url: The url to the remote repository which is the submodule
        :param branch_path: full (relative) path to ref to checkout when cloning the remote repositoryrN)�superr.�__init__�sizerLrMrNrO)
�selfrSrTrUrRrFrVrWrX�	__class__s
         �r5r\zSubmodule.__init__msk���&	�i����'�'��f�d�D�A�A�A���	�+����?��D�I��"� +�D�����D�J�J�J��r7�attrc�V��|dvr�|���}	|�d��|_nX#tj$rF}|jj�0tdtj	|jjd��z��|�Yd}~nd}~wwxYw|�d��|_
|�|jtj�|j����|_dS|dkrt%d���t't(|���|��dS)NrQrRz;This submodule instance does not exist anymore in '%s' filerGrWrOzCCannot retrieve the name of a submodule if it was not set initially)�
config_reader�getrRr	�NoSectionErrorrS�working_tree_dir�
ValueError�osp�joinrM�	get_value�
k_head_option�gitr-�to_full_path�k_head_defaultrN�AttributeErrorr[r.�_set_cache_)r^r`�reader�er_s    �r5rozSubmodule._set_cache_�s2����3�3�3�(,�(:�(:�(<�(<�F�
�"�J�J�v�.�.��	�	���$�
�
�
��9�-�9�$�U��(�4�9�#=�}�M�M�N�����:�9�9�9�9�����
�����
�
�5�)�)�D�I� &� 0� 0��1C�S�X�EZ�EZ�[_�[n�Eo�Eo� p� p�D����
�W�_�_� �!f�g�g�g��)�T�"�"�.�.�t�4�4�4�4�4s�6�B�<B�B�itemc��	|�|�����S#t$rtd��cYSwxYw)z4:return: all the submodules of our module repository�)�
list_items�moduler
r)�clsrrs  r5�_get_intermediate_itemsz!Submodule._get_intermediate_items�sP��	$��>�>�$�+�+�-�-�0�0�0��(�	$�	$�	$���#�#�#�#�#�	$���s�&)�A�Arkc�(�|jdd�dkS)Nr8)r��)�version_info)rwrks  r5�_need_gitfile_submodulesz"Submodule._need_gitfile_submodules�s�������#�y�0�0r7�otherc�"�|j|jkS)zCompare with another submodule�rO�r^r~s  r5�__eq__zSubmodule.__eq__�s��
�z�U�[�(�(r7c��||kS)z-Compare with another submodule for inequalityr2r�s  r5�__ne__zSubmodule.__ne__�s���E�M�"�"r7c�*�t|j��S)z4Hash this instance using its logical id, not the sha)�hashrO�r^s r5�__hash__zSubmodule.__hash__�s���D�J���r7c��|jS�Nr�r�s r5�__str__zSubmodule.__str__�s
���z�r7c�r�dt|��j�d|j�d|j�d|j�d|j�d�S)Nzgit.z(name=z, path=z, url=z, branch_path=�))rKr:rOrRrWrXr�s r5�__repr__zSubmodule.__repr__�sG�����J�J�����J�J�J��I�I�I��H�H�H�����
�	
r7�	read_onlyc��d}|�"	|jj|k}n#t$rYnwxYw|js)|r'|jr tj|j|j��}nP|�
Jd���	|�|��}n-#t$r }td|j�d|����|�d}~wwxYw|s|js|std���t||���S)a7:return: Config Parser constrained to our submodule in read or write mode
        :raise IOError: If the .gitmodules file cannot be found, either locally or in the repository
            at the given parent commit. Otherwise the exception would be delayed until the first
            access of the config parserTNz-need valid parent_commit in bare repositorieszCould not find z# file in the tree of parent commit z;Cannot write blobs of 'historical' submodule configurations�r�)�head�commitrf�barerergrh�k_modules_file�_sio_modules�KeyError�IOErrorr)rwrSrVr��parent_matches_head�	fp_modulerqs       r5�_config_parserzSubmodule._config_parser�s;��#���$�
�&*�i�&6�-�&G�#�#���
�
�
���
����
�y�		�0�		�T�5J�		����!6��8J�K�K�I�I� �,�,�.]�,�,�,�
��,�,�]�;�;�	�	���
�
�
��g�PS�Pb�Pb�Pb�dq�dq�r���������
�����	\�d�i�	\�/B�	\��Z�[�[�[�%�Y�)�D�D�D�Ds$��
$�$�$A:�:
B$�B�B$c�\�|jD]#}	t||���#t$rY� wxYwdSr�)�_cache_attrs�delattrrn)r^rFs  r5�_clear_cachezSubmodule._clear_cache�sV���%�	�	�D�
���d�#�#�#�#��!�
�
�
���
����	�	s��
)�)c��t|j|jj�����}|j|_|S)z]:return: Configuration file as BytesIO - we only access it through the respective blob's data)r�treer��data_stream�readrF)rwrV�sios   r5r�zSubmodule._sio_modules�s:���m�(��);�<�H�M�M�O�O�P�P���%����
r7c���	|j}n#t$rd}YnwxYw|�|j||��}|�|��t|t
|j����S)zI:return: Config Parser constrained to our submodule in read or write modeN)rVrfr�rS�
set_submodulerrrF)r^r��pc�parsers    r5�_config_parser_constrainedz$Submodule._config_parser_constrained�s~��	�,0�,>�B�B���	�	�	��B�B�B�	�����$�$�T�Y��I�>�>�����T�"�"�"� ���D�I�)>�)>�?�?�?s�
���parent_repoc���|�|j��rtj|jd|��S|jrtj|j|��St
���)N�modules)r}rkrgrh�git_dirre�NotADirectoryError)rwr�rRrFs    r5�_module_abspathzSubmodule._module_abspath	s_���'�'���8�8�	B��8�K�/��D�A�A�A��'�	@��8�K�8�$�?�?�?� �"�"�"r7F�allow_unsafe_options�allow_unsafe_protocols�kwargsc���|�|||��}|}	|�|j��rh||d<tj|��}
tj|
��st
j|
��tjt|j
��|��}	tjj||	f||d�|��}|�|j��r|�
|	|��|S)a�:return: Repo instance of newly cloned repository
        :param repo: our parent repository
        :param url: url to clone from
        :param path: repository - relative path to the submodule checkout location
        :param name: canonical of the submodule
        :param allow_unsafe_protocols: Allow unsafe protocols to be used, like ext
        :param allow_unsafe_options: Allow unsafe options to be used, like --upload-pack
        :param kwargs: additional arguments given to git.clone�separate_git_dir)r�r�)r�r}rkrg�dirname�isdir�os�makedirsrh�strrer,�
clone_from�!_write_git_file_and_module_config)rwrSrWrRrFr�r�r��module_abspath�module_checkout_path�module_abspath_dir�clones            r5�_clone_repozSubmodule._clone_repos��&�,�,�T�4��>�>��-���'�'���1�1�	N�)7�F�%�&�!$��^�!<�!<���9�/�0�0�
0���.�/�/�/�#&�8�C��0E�,F�,F��#M�#M� ���#�� �
�"6�#9�	
�
�
�
�
���'�'���1�1�	X��1�1�2F��W�W�W��r7c��t|��}|�d��r
|dd�}tj|��r�|jr�t|j��}|�|��st
d|�d|�d����|t|�d����dzd�}|st
d|z���|S)	z�:return: a path guaranteed  to be relative to the given parent - repository
        :raise ValueError: if path is not contained in the parent repository's working tree�/N���zSubmodule checkout path 'z0' needs to be within the parents repository at '�'rz?Absolute submodule path '%s' didn't yield a valid relative path)	r�endswithrg�isabsre�
startswithrf�len�rstrip)rwr�rR�working_tree_linuxs    r5�_to_relative_pathzSubmodule._to_relative_path;s���$�D�)�)���=�=����	�����9�D��9�T�?�?�		k�{�;�		k�!5�k�6R�!S�!S���?�?�#5�6�6�
� �j�)�)�)�4�4�4�1������.�5�5�c�:�:�;�;�a�?�A�A�B�D��
k� �!b�ei�!i�j�j�j��r7rer�c�V�tj|d��}tj||���}tr(tj|��rtj|��t|d��5}|�d|z�	t����ddd��n#1swxYwYttj|d��dd���5}|�d	d
ttj||�������ddd��dS#1swxYwYdS)a�Writes a .git file containing a(preferably) relative path to the actual git module repository.
        It is an error if the module_abspath cannot be made into a relative path, relative to the working_tree_dir
        :note: will overwrite existing files !
        :note: as we rewrite both the git file as well as the module configuration, we might fail on the configuration
            and will not roll back changes done to the git file. This should be a non - issue, but may easily be fixed
            if it becomes one
        :param working_tree_dir: directory to write the .git file into
        :param module_abspath: absolute path to the bare repository
        �.git)�start�wbz
gitdir: %sN�configF)r��merge_includes�core�worktree)rgrh�relpathr�isfiler��remove�open�write�encoderr�	set_valuer)rwrer��git_file�	rela_path�fp�writers       r5r�z+Submodule._write_git_file_and_module_configSs����8�,�f�5�5���K��6F�G�G�G�	��	$��z�(�#�#�
$��	�(�#�#�#�
�(�D�
!�
!�	@�R��H�H�l�Y�.�6�6�v�>�>�?�?�?�	@�	@�	@�	@�	@�	@�	@�	@�	@�	@�	@����	@�	@�	@�	@��S�X�n�h�?�?�5�af�
g�
g�
g�	�kq������$�S�[�1A��%X�%X�%X�Y�Y�
�
�
�	�	�	�	�	�	�	�	�	�	�	�	����	�	�	�	�	�	s$�+1B(�(B,�/B,�9D�D"�%D"�no_checkout�depth�env�clone_multi_optionsc���|jrtd���|�||��}|�t|��}|||j|j||d���}|���rt	|jjj	t|��}||_|S#t$r9|j
}
|
j|
�|d��}|j|_|cYSwxYwt#j|t"j�t|��p|j����}|���}|du}|rB|�@|d�|���jD��vrt1d|�d|j�d	����d}|�[|st1d
|z���|���}d�|jD��}|st1d|jz���|d}nXd
|i}|s
|j|d<|r*t7|t8��r||d<nt1d���|	r|	|d<|j||||f||
|d�|��}t=j|��}|j �!��5}|�"tG|��d|��ddd��n#1swxYwY|j j
}
|�!|
d���5}|�"d|��|�"d|��||_$|s,|�"|j%|j&��|j&|_'ddd��n#1swxYwY|r|jjj|_|
�(|gd���|S)ac
Add a new submodule to the given repository. This will alter the index
        as well as the .gitmodules file, but will not create a new commit.
        If the submodule already exists, no matter if the configuration differs
        from the one provided, the existing submodule will be returned.

        :param repo: Repository instance which should receive the submodule
        :param name: The name/identifier for the submodule
        :param path: repository-relative or absolute path at which the submodule
            should be located
            It will be created as required during the repository initialization.
        :param url: git-clone compatible URL, see git-clone reference for more information
            If None, the repository is assumed to exist, and the url of the first
            remote is taken instead. This is useful if you want to make an existing
            repository a submodule of anotherone.
        :param branch: name of branch at which the submodule should (later) be checked out.
            The given branch must exist in the remote repository, and will be checked
            out locally as a tracking branch.
            It will only be written into the configuration if it not None, which is
            when the checked out branch will be the one the remote HEAD pointed to.
            The result you get in these situation is somewhat fuzzy, and it is recommended
            to specify at least 'master' here.
            Examples are 'master' or 'feature/new'
        :param no_checkout: if True, and if the repository has to be cloned manually,
            no checkout will be performed
        :param depth: Create a shallow clone with a history truncated to the
            specified number of commits.
        :param env: Optional dictionary containing the desired environment variables.
            Note: Provided variables will be used to update the execution
            environment for `git`. If some variable is not specified in `env`
            and is defined in `os.environ`, value from `os.environ` will be used.
            If you want to unset some variable, consider providing empty string
            as its value.
        :param clone_multi_options: A list of Clone options. Please see ``git.repo.base.Repo.clone``
            for details.
        :param allow_unsafe_protocols: Allow unsafe protocols to be used, like ext
        :param allow_unsafe_options: Allow unsafe options to be used, like --upload-pack
        :return: The newly created submodule instance
        :note: works atomically, such that no change will be done if the repository
            update fails for instancez*Cannot add submodules to bare repositoriesNzinvalid-temporary�rWrc��g|]	}|j��
Sr2r��r3�rs  r5r6z!Submodule.add.<locals>.<listcomp>�s��>�>�>�Q�1�5�>�>�>r7zSpecified URL 'z6' does not match any remote url of the repository at 'r�z8A URL was not given and a repository did not exist at %sc��g|]	}|j��
Sr2r�r�s  r5r6z!Submodule.add.<locals>.<listcomp>�s��1�1�1�a�A�E�1�1�1r7z.Didn't find any remote url in repository at %s�n�br�zdepth should be an integer�
multi_options)r�r�r�rWF)�indexr�rRT�r�))r�r
r�r�NULL_BIN_SHA�k_default_mode�existsr�r�r�r�rOr�r��entries�	entry_keyrTrkr-rlrm�
module_existsrv�remotesrf�abspathrF�
isinstancerBr�r�
polish_urlrS�
config_writerr�rrMrjrRrN�add)rwrSrFrRrWrHr�r�r�r�r�r��smr��entry�br�
has_module�branch_is_default�mrepo�urlsr�r�s                      r5r�z
Submodule.addoss��n�9�	Z�+�,X�Y�Y�Y��$�$�T�4�0�0���?�&�s�+�+�C��S��������#�

�
�
���9�9�;�;�	�	
��Y�%�*�3�t�9�9�5������	���
�
�
��
���
�e�o�o�d�A�&>�&>�?��!�L��	��	�	�	�
�����X�d�C�H�1�1�#�f�+�+�2S��AS�T�T�
U�
U���%�%�'�'�
�"�d�N���	�#�/��>�>�"�)�)�+�+�*=�>�>�>�>�>� �j�dg�dg�dg�ik�is�is�is�t����$(���;��
d� �![�^b�!b�c�c�c��I�I�K�K�E�1�1�5�=�1�1�1�D��
`� �!Q�TV�T^�!^�_�_�_��q�'�C�C�HK�K�FX�F�$�
&� �g��s���
C��e�S�)�)�C�&+�F�7�O�O�$�%A�B�B�B�"�
>�*=���'�$�C�O�����		�
�%9�'=�	�	��	�	�E��n�S�!�!���W�
"�
"�
$�
$�	;�����Z��-�-�u�c�:�:�:�	;�	;�	;�	;�	;�	;�	;�	;�	;�	;�	;����	;�	;�	;�	;���
��
�
�
�E��
�
7�
7�	*�6����U�C�(�(�(����V�T�*�*�*��B�G�$�
*�� � ��!2�B�G�<�<�<�"$�'���	*�	*�	*�	*�	*�	*�	*�	*�	*�	*�	*����	*�	*�	*�	*��	1��
�)�0�B�I�
�	�	�2�$�d�	�#�#�#��	s8�.,B�AC�C�'%J�J�J�A"L4�4L8�;L8T�	recursive�init�to_latest_revision�progress)r/N�dry_run�force�
keep_goingc
�>�|jjr|S|�t��}d}|rd}|rd}
		|���}
|
j}t|��}t
|��D]�\}}t}|dkr
|tz}|�	||||d|�d|j
��z��|s|�|���||dz
kr
|tz}|�	||||d	|j
zz�����nK#t$�r=d}
|s|cYS|j}|sOtj|��r;	t#j|��n%#t&$r}t'd
|z��|�d}~wwxYw|�	tt(zdd|d|j�d|�d
|j
��z��|s2|�|j|j|j|j
d||	|
|��	�	}
|�	tt(zdd|d|zz��|�s=	t1d|
��}
t3|
j|j��}t7|
|j��}|�t=|
|j����|
j �!|d|z���|
j j"�#|��n7#tHtf$r#tJ�&d|j��YnwxYw|j�'��5}|�(tS|j
��d|j��ddd��n#1swxYwYYnwxYw|j*}|j+}|
�|
j j,}|
��|r�d|
j-z}|s]|
j j"�.��}|�|j/}|j*}|j+}nBtJ�0d||
j j"��ntJ�0d|��|
���|
j j/j*|k�r�d}|
j j/j*|jkr�|
�1|
j j/|��}t|��dks|d�d|dj+|krS|r"d} | dz
} tJ�2| ��n/d} | |rdpd|
j |
fz} tJ�3| ��d}|r*|s(|
�4ddd���rtk|
d ���|�	ttlzdd|d!|j�d"|j
�d#|��z��|s>|r<|r|
j7�8||�$��n|
j �9|dd�%��|�	ttlzdd|d&|j
zz��nA#tt$r4}!|s�tJ�0tw|!����Yd}!~!nd}!~!wwxYw|rH|
�F|�<|�����D]}"|"�	|||||||�'���|S)(a}
Update the repository of this submodule to point to the checkout
        we point at with the binsha of this instance.

        :param recursive: if True, we will operate recursively and update child-
            modules as well.
        :param init: if True, the module repository will be cloned into place if necessary
        :param to_latest_revision: if True, the submodule's sha will be ignored during checkout.
            Instead, the remote will be fetched, and the local tracking branch updated.
            This only works if we have a local tracking branch, which is the case
            if the remote repository had a master branch, or of the 'branch' option
            was specified for this submodule and the branch existed remotely
        :param progress: UpdateProgress instance or None if no progress should be shown
        :param dry_run: if True, the operation will only be simulated, but not performed.
            All performed operations are read - only
        :param force:
            If True, we may reset heads even if the repository in question is dirty. Additinoally we will be allowed
            to set a tracking branch which is ahead of its remote branch back into the past or the location of the
            remote branch. This will essentially 'forget' commits.
            If False, local tracking branches that are in the future of their respective remote branches will simply
            not be moved.
        :param keep_going: if True, we will ignore but log all errors, and keep going recursively.
            Unless dry_run is set as well, keep_going could cause subsequent / inherited errors you wouldn't see
            otherwise.
            In conjunction with dry_run, it can be useful to anticipate all errors when updating submodules
        :param env: Optional dictionary containing the desired environment variables.
            Note: Provided variables will be used to update the execution
            environment for `git`. If some variable is not specified in `env`
            and is defined in `os.environ`, value from `os.environ` will be used.
            If you want to unset some variable, consider providing empty string
            as its value.
        :param clone_multi_options:  list of Clone options. Please see ``git.repo.base.Repo.clone``
            for details. Only take effect with `init` option.
        :param allow_unsafe_protocols: Allow unsafe protocols to be used, like ext
        :param allow_unsafe_options: Allow unsafe options to be used, like --upload-pack
        :note: does nothing in bare repositories
        :note: method is definitely not atomic if recurisve is True
        :return: selfNrtz	DRY-RUN: rzFetching remote z of submodule )rrz$Done fetching remote of submodule %rz:Module directory at %r does already exist and is non-emptyz
Cloning url 'z' to 'z' in submodule T)r�r�r�r�r�zDone cloning to %sr,zsubmodule: attaching head to %s)�logmsgz%Failed to checkout tracking branch %srWz8Cannot update to latest revision in repository at %r as z6%s a tracking branch was not set for local branch '%s'z%%s there was no local tracking branchzNWill force checkout or reset on local branch that is possibly in the future ofzJthe commit it will be checked out to, effectively 'forgetting' new commitszRSkipping %s on branch '%s' of submodule repo '%s' as it contains un-pushed commits�checkout�resetF�r��working_tree�untracked_fileszCannot reset a dirty repositoryzUpdating working tree at z for submodule z
 to revision )r)r�r
z+Done updating working tree for submodule %r)rrrr)=rSr�r/rvr�r��	enumerater@�BEGIN�updaterF�fetch�ENDr
r�rgr�r��rmdir�OSErrorr?rWr�rRr#r�branch_namerrX�
set_objectrr�r��
set_reference�	reference�set_tracking_branch�
IndexError�log�warningr�r�rrT�hexsha�is_detached�working_dir�tracking_branchr��error�
merge_base�debug�info�is_dirtyrrArkr
r�	Exceptionr��
iter_items)#r^rrrrrrrr�r�r�r��prefixr��rmts�len_rmts�i�remote�op�checkout_module_abspathrq�
remote_branch�local_branchr�rTrr�msg_base�rref�rcommit�	may_reset�base_commit�msg�errrJs#                                   r5rzSubmodule.updates���f�9�>�	��K���%�'�'�H����	!� �F��	��E�L	 �j
Q����
�
���}���t�9�9��!*�4�����I�A�v��B��A�v�v��e����O�O��� ������QU�QZ�QZ�![�[�	���#�8����h��7�7�7��H�q�L�(�(��c�	���O�O��� ��!G�$�)�!S�S�	����)��6-�K
Q�K
Q�K
Q���� ��K�K�K�+/�,�'��!�3�9�-D�#E�#E�!�!���!8�9�9�9�9��"�!�!�!�%�X�[r�r��� �!�����!��������E�M����F�DH�H�H�H�Ne�Ne�Ne�gk�gp�gp�q�r�	����� �,�,��	����	��	���&9�-A�/E�-�
�
�E�����%�K����1�4K�K�K�	����Q�_� $�V�U� 3� 3��(@���PT�P`�(a�(a�
�'-�e�T�5E�'F�'F��%�/�/��u�d�>O�0P�0P�Q�Q�Q��
�0�0�(�#D�|�#S�1�����
�,�@�@��O�O�O�O��&�(A�B�_�_�_����$K�T�M]�^�^�^�^�^�_������0�0�2�2�Q�f��(�(��D�I�)>�)>��t�x�P�P�P�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q����Q�Q�Q�Q���UK
Q����b�[�F��[�F�� �#�j�4��� �%7� �U�X]�Xi�i��"�Q� �:�/�?�?�A�A�D��'�"&�+��!(���!(�����	�	�T�$�!�J�0������I�I�E�x�P�P�P�� �U�Z�%6�%=��%G�%G�
!�	��:�$�+�t�/@�@�@�"'�"2�"2�5�:�3D�f�"M�"M�K��;�'�'�1�,�,��Q��1K�P[�\]�P^�Pe�io�Po�Po� �.�"r�C��#o�o�C��I�I�c�N�N�N�N�"v�C�� +� :�
� E�g� %�
� %�$��C�
 �H�H�S�M�M�M�(-�I�!�]��]�5�>�>��[_�qu�>�3v�3v�]�2�5�:[�\�\�\�
����I�%����F�W[�W`�W`�W`�bf�bk�bk�bk�ms�ms�t�u�	����P�9�P�"�P�
�	�*�*�6��*�?�?�?�?��
�(�(��t�$�(�O�O�O�����)�O����J�T�Y�V�V�	������	 �	 �	 ��
���I�I�c�#�h�h�������������	 �����	�� �!%��������!?�!?�	�	�I��$�$�!��*�!)� '�#�#-�%������s��C
C7�5V�7L?�V�
L?�(D=�<L?�=
E�E�E�B L?�B%J&�%L?�&1K�L?�K�L?�6/L1�%L?�1L5	�5L?�8L5	�9L?�<V�>L?�?IV�
W�*W�W�module_path�
configurationrvc�.�||zdkrtd���|�|j|��}||jkr|St	t|jj��|��}tj|��rtd|z���|jj	}|�
|d��}|r||jvrtd���|r�tj|��rnttj|����rtd���tj|��rtj|��ntj|��n	|j}d}	|r�tj|��rztj||��d}	tjtj|d	����r<|�|j|j|j��}
|�||
��|j}	|r�	|�
|jd��}|j|}
|j|=t3j|
d
d�|fz|
dd
�z��}||j|<n*#t6$r}t9d
|jz��|�d
}~wwxYw|�|���5}|�d|��||_d
d
d
��n#1swxYwYn&#t>$r|	rtj||���wxYw||jkr|� |��|S)a�Move the submodule to a another module path. This involves physically moving
        the repository at our current path, changing the configuration, as well as
        adjusting our index entry accordingly.

        :param module_path: the path to which to move our module in the parent repostory's working tree,
            given as repository - relative or absolute path. Intermediate directories will be created
            accordingly. If the path already exists, it must be empty.
            Trailing(back)slashes are removed automatically
        :param configuration: if True, the configuration will be adjusted to let
            the submodule point to the given path.
        :param module: if True, the repository managed by this submodule
            will be moved as well. If False, we don't move the submodule's checkout, which may leave
            the parent repository in an inconsistent state.
        :return: self
        :raise ValueError: if the module path existed and was not empty, or was a file
        :note: Currently the method is not atomic, and it could leave the repository
            in an inconsistent state if a sub - step fails for some reason
        rzRYou must specify to move at least the module or the configuration of the submodulez&Cannot move repository onto a file: %srz-Index entry for target path did already existz*Destination module directory was not emptyFTr�Nr8�z%Submodule's entry at %r did not exist)r�rR)!rfr�rSrRrr�rergr�r�r�r�r�r�r��listdir�islinkr�rr��renamesrhr�rFr�rk�
IndexEntryr�r
r�r�r'�rename)r^r9r:rvr��module_checkout_abspathr��tekey�cur_path�renamed_moduler��previous_sm_path�ekeyr��nentryrqr�s                 r5�movezSubmodule.moveFs���(�M�!�A�%�%��q�r�r�r� $�5�5�d�i��M�M�� �4�9�,�,��K�#3�3�t�y�7Q�3R�3R�Th�"i�"i���:�-�.�.�	a��E�H_�_�`�`�`��	������ 4�a�8�8���	N�U�e�m�3�3��L�M�M�M��	��z�1�2�2�

��r�z�"9�:�:�;�;�S�$�%Q�R�R�R��:�5�6�6�6��I�5�6�6�6�6��H�4�5�5�5�5�
�
�<�����	`�c�j��*�*�	`��J�x�!8�9�9�9�!�N��z�#�(�#:�F�C�C�D�D�
`�!%�!5�!5�d�i���D�I�!V�!V���6�6�7N�P^�_�_�_� �9��	��
5�r� �?�?�4�9�a�8�8�D�!�M�$�/�E��
�d�+� �^�E�"�1�"�I�9M�8O�,O�RW�XY�XZ�XZ�R[�,[�\�\�F�+1�E�M�%�(�(���r�r�r�3�4[�_c�_h�4i�j�j�pq�q�����r����
�'�'�e�'�4�4�5���$�$�V�-A�B�B�B� 4�D�I�5�5�5�5�5�5�5�5�5�5�5����5�5�5�5����	�	�	��
>��
�2�H�=�=�=��		�����t�y�(�(��K�K�,�-�-�-��sU�0K�3A%I�K�
J�#I;�;J�K�K�7K�K�K�
K�K�#K2c��|s|std���d}|���D] }|dz
}|�||||��~�!|r<|s:|dkr4|���j�d|jz��|�rk|����rV|���}|j}|r||j	}	d}
tj|	��r
tj}
n?tj
|	��rt}
n#tj|	��rt!d���|s|
sJ�|
|	���nS|�ddd���rt%d	|jz���|jD]�}d}|j}
|
D]0}|t-|j�|����dkz
}�1t-|
��r*|t-|
��krt%d
|jz���t-|
��r~~
~��|s�|���|j}~ddl}|���	tt9|����n?#t:$r2}t<r%ddlm }|d�!|����|��d}~wwxYw|shtj
|��rT|���	t|��n/#t:$r"}t<rddlm }|d
|����|��d}~wwxYw|s|���|r�|s�|j"j}	|j#|�$|j%d��=n#tL$rYnwxYw|�'��|j"�(��5}|�)tU|j����ddd��n#1swxYwY|�(��5}|�)��ddd��n#1swxYwY|S)a�Remove this submodule from the repository. This will remove our entry
        from the .gitmodules file and the entry in the .git / config file.

        :param module: If True, the module checkout we point to will be deleted
            as well. If the module is currently on a commit which is not part
            of any branch in the remote, if the currently checked out branch
            working tree, or untracked files,
            is ahead of its tracking branch, if you have modifications in the
            In case the removal of the repository fails for these reasons, the
            submodule status will not have been altered.
            If this submodule has child - modules on its own, these will be deleted
            prior to touching the own module.
        :param force: Enforces the deletion of the module even though it contains
            modifications. This basically enforces a brute - force file system based
            deletion.
        :param configuration: if True, the submodule is deleted from the configuration,
            otherwise it isn't. Although this should be enabled most of the times,
            this flag enables you to safely delete the repository of your submodule.
        :param dry_run: if True, we will not actually do anything, but throw the errors
            we would usually throw
        :return: self
        :note: doesn't work in bare repositories
        :note: doesn't work atomically, as failure to remove any part of the submodule will leave
            an inconsistent state
        :raise InvalidGitRepositoryError: thrown if the repository cannot be deleted
        :raise OSError: if directories or files could not be removedzCNeed to specify to delete at least the module, or the configurationrrz-Removed at least one of child-modules of '%s'NzKCannot forcibly delete repository as it was neither a link, nor a directoryTrzLCannot delete module at %s with any modifications, unless force is specifiedz3Cannot delete module at %s as there are new commits)�SkipTestz'FIXME: fails with: PermissionError
  {}z%FIXME: fails with: PermissionError
  )+rf�childrenr�rvr�r�rFr�r�r�rgr>r�r�rr��AssertionErrorr&r
rer��refsr�rk�cherryr��gc�collectr�r'r�unittestrK�formatrSr�r�rRr�r�r��remove_sectionr)r^rvrr:r�nc�csm�modr��mp�methodr-�num_branches_with_new_commits�rrefsr3�wtdrP�exrK�parent_index�
gcp_writer�	sc_writers                      r5r�zSubmodule.remove�sN��D�	d�-�	d��b�c�c�c����=�=�?�?�	�	�C��!�G�B��J�J�v�u�m�W�=�=�=����	d��	d�R�!�V�V�
�K�K�M�M��&�&�'V�Y]�Yb�'b�c�c�c�
�T	�d�(�(�*�*�T	��+�+�-�-�C��k�G��C
��\��BF���:�b�>�>�x��Y�F�F��Y�r�]�]�x�#�F�F��Z��^�^�x�(�)v�w�w�w���!�M�M�6��F�2�J�J�J���<�<�d��t�<�T�T��3�f��.�/����"�k���F�45�1�"�K�E� %�X�X��5��S�W�^�^�D�=Q�=Q�9R�9R�VW�9W�W�5�5��5�z�z��&C�s�5�z�z�&Q�&Q�7�Q�TW�Th�h�����5�z�z�!� �������%�%�'�'�'��.�C���I�I�I��J�J�L�L�L���s�3�x�x�(�(�(�(��$����4�j�9�9�9�9�9�9�"*�(�+U�+\�+\�]_�+`�+`�"a�"a�gi�i�����������

�s�y��1�1�

��!�!�#�#�#���7�O�O�O�O�� ����0��5�5�5�5�5�5�&�h�'T�PR�'T�'T�U�U�[]�]������
�����	 ��������	+��	+��9�?�L�
� �(��)?�)?��	�1�)M�)M�N�N���
�
�
���
����
��� � � �
��(�(�*�*�
A�j��)�)�*�T�Y�*?�*?�@�@�@�
A�
A�
A�
A�
A�
A�
A�
A�
A�
A�
A����
A�
A�
A�
A��#�#�%�%�
+���(�(�*�*�*�
+�
+�
+�
+�
+�
+�
+�
+�
+�
+�
+����
+�
+�
+�
+��sf�1I�
J
�-J�J
�8K�
K4�K/�/K4�!M�
M
�M
�=(N1�1N5�8N5�O1�1O5�8O5r��checkc�F�|�	d|_|S|j�|��}|j}|j|vrtd|�d|j�d����|j}||_|rj|�|j|jd���}|�t|j	����s!||_td|j
�d|�����	|t|j
��j|_n#t$r|j|_YnwxYw|���|S)	a_Set this instance to use the given commit whose tree is supposed to
        contain the .gitmodules blob.

        :param commit:
            Commit'ish reference pointing at the root_tree, or None to always point to the
            most recent commit
        :param check:
            if True, relatively expensive checks will be performed to verify
            validity of the submodule.
        :raise ValueError: if the commit's tree didn't contain the .gitmodules blob.
        :raise ValueError:
            if the parent commit didn't store this submodule under the current path
        :return: selfNzTree of commit z did not contain the z fileTr�zSubmodule at path z  did not exist in parent commit )rLrSr�r�r�rfr��has_sectionrrFrRr�rTr�r�r�)r^r�ra�pcommit�pctree�prev_pcr�s       r5�set_parent_commitzSubmodule.set_parent_commit\sM���>�"&�D���K��)�"�"�6�*�*�������f�,�,��*�PV�PV�PV�X\�Xk�Xk�Xk�l�m�m�m��%��%����	q��(�(���D�4G�SW�(�X�X�F��%�%�j���&;�&;�<�<�
q�&-��#� �j�]a�]f�]f�]f�hn�hn�!o�p�p�p�	,� ��T�Y���0�7�D�K�K���	,�	,�	,��+�D�K�K�K�	,����	
�������s�$C1�1D
�	D
r�)r+Nr�rc�f�|�d���}|�||j_||j_|S)aH:return: a config writer instance allowing you to read and write the data
            belonging to this submodule into the .gitmodules file.

        :param index: if not None, an IndexFile instance which should be written.
            defaults to the index of the Submodule's parent repository.
        :param write: if True, the index will be written each time a configuration
            value changes.
        :note: the parameters allow for a more efficient writing of the index,
            as you can pass in a modified index on your own, prevent automatic writing,
            and write yourself once the whole operation is complete
        :raise ValueError: if trying to get a writer on a parent_commit which does not
            match the current head commit
        :raise IOError: If the .gitmodules file/blob could not be readFr�)r�r��_index�_auto_write)r^r�r�r�s    r5r�zSubmodule.config_writer�s9��"�0�0�5�0�A�A����#(�F�M� �$)��
�!��
r7�new_namec�:�|j|kr|S|j���5}|�t	|j����r5|�t	|j��t	|����ddd��n#1swxYwY|�d���j5}|�t	|j��t	|����ddd��n#1swxYwY||_|���}|�	��r�|�
|j|j|��}|j}t|���t|j����rV|�
|j|jttj������}t#j||��|}t#j||��|jr|�|j|��|S)a�Rename this submodule
        :note: This method takes care of renaming the submodule in various places, such as

            * $parent_git_dir / config
            * $working_tree_dir / .gitmodules
            * (git >= v1.8.0: move submodule repository to new name)

        As .gitmodules will be changed, you would need to make a commit afterwards. The changed .gitmodules file
        will already be added to the index

        :return: this submodule instance
        NTr�)rFrSr�rcr�rename_sectionr�rOrv�has_separate_working_treer�rRr�r�r��uuid�uuid4r�r?rer�)r^rk�pw�cwrW�destination_module_abspath�
source_dir�tmp_dirs        r5rAzSubmodule.rename�sw���9�� � ��K��Y�
$�
$�
&�
&�	O�"��~�~�j���3�3�4�4�
O��!�!�*�T�Y�"7�"7��H�9M�9M�N�N�N�		O�	O�	O�	O�	O�	O�	O�	O�	O�	O�	O����	O�	O�	O�	O��
�
�d�
�
+�
+�
2�	K�b����j���3�3�Z��5I�5I�J�J�J�	K�	K�	K�	K�	K�	K�	K�	K�	K�	K�	K����	K�	K�	K�	K���
��k�k�m�m���(�(�*�*�	i�)-�)=�)=�d�i���T\�)]�)]�&���J��-�.�.�9�9�#�c�k�:J�:J�K�K�
%��.�.�t�y�$�)�S�����EV�EV�W�W���
�:�w�/�/�/�$�
��J�z�#=�>�>�>��#�
i��6�6�s�7K�Mg�h�h�h��s$�AB�B�B�66C8�8C<�?C<c���|j}	tj|��}||jkr|S	t	d|z���#tt
f$r}t	d|z��|�d}~wwxYw)z�:return: Repo instance initialized from the repository at our submodule path
        :raise InvalidGitRepositoryError: if a repository was not available. This could
            also mean that it was not yet initializedz(Repository at %r was not yet checked outzNo valid repository at %sN)r�rkr,rSr
r)r^rBrSrqs    r5rvzSubmodule.module�s���#'�,��	r��8�3�4�4�D��t�y� � ���!�,�,V�Yp�,p�q�q�q��*�?�;�	j�	j�	j�+�,G�Ja�,a�b�b�hi�i�����	j���s� =�A&�A!�!A&c�R�	|���dS#t$rYdSwxYw)zU:return: True if our module exists and is a valid git repository. See module() methodTF)rvr'r�s r5r�zSubmodule.module_exists�s;��	��K�K�M�M�M��4���	�	�	��5�5�	���s��
&�&c	��t��}|jD]B}	t||��rt||��||<�'#tjtf$rY�?wxYw|���		|j	|jD]}||vrt||||���dS#t$r)Y|jD]}||vrt||||���dSwxYw#|jD]}||vrt||||���wxYw)z�
        :return: True if the submodule exists, False otherwise. Please note that
            a submodule may exist ( in the .gitmodules file) even though its module
            doesn't exist on diskTF)�localsr��hasattr�getattrr	rdrfr�rR�setattrr')r^�locr`s   r5r�zSubmodule.exists�ss���h�h���%�	�	�D�
��4��&�&�4� '��d� 3� 3�C��I����%�z�2�
�
�
���
����	
������
	3�
��	�	��
�)�
3�
3���3�;�;��D�$��D�	�2�2�2��
3�
3��	�
�
�
���)�
3�
3���3�;�;��D�$��D�	�2�2�2��
3�
3�	
������)�
3�
3���3�;�;��D�$��D�	�2�2�2��
3���s3�#=�A�A�/B�
C�(C�C�C�'C;r-c�P�t|���|j��S)z�:return: The branch instance that we are to checkout
        :raise InvalidGitRepositoryError: if our module is not yet checked out)rrvrNr�s r5rHzSubmodule.branchs���d�k�k�m�m�T�%6�7�7�7r7c��|jS)zu
        :return: full(relative) path as string to the branch we would checkout
            from the remote and track)rNr�s r5rXzSubmodule.branch_paths
��
� � r7c�J�tj|j|j��jS)zK:return: the name of the branch, which is the shortest possible branch name)rkr-rSrNrFr�s r5rzSubmodule.branch_name s��
�x��	�4�#4�5�5�:�:r7c��|jS)zJ:return: The url to the repository which our module - repository refers to)rMr�s r5rWz
Submodule.url's���y�r7r'c�P�|j�|j���S|jS)z�:return: Commit instance with the tree containing the .gitmodules file
        :note: will always point to the current head's commit if it was not set explicitly)rLrSr�r�s r5rVzSubmodule.parent_commit,s*����&��9�#�#�%�%�%��"�"r7c��|jS)a~:return: The name of this submodule. It is used to identify it within the
            .gitmodules file.
        :note: by default, the name is the path at which to find the submodule, but
            in git - python it should be a unique identifier similar to the identifiers
            used for remotes, which allows to change the path of the submodule
            easily
        r�r�s r5rFzSubmodule.name4s���z�r7c�.�|�d���S)a�
        :return: ConfigReader instance which allows you to qurey the configuration values
            of this submodule, as provided by the .gitmodules file
        :note: The config reader will actually read the data directly from the repository
            and thus does not need nor care about your working tree.
        :note: Should be cached by the caller and only kept as long as needed
        :raise IOError: If the .gitmodules file/blob could not be readTr�)r�r�s r5rbzSubmodule.config_reader?s���.�.��.�>�>�>r7c�,�|�|��S)z�
        :return: IterableList(Submodule, ...) an iterable list of submodules instances
            which are children of this submodule or 0 if the submodule is not checked out)rxr�s r5rLzSubmodule.childrenIs���+�+�D�1�1�1r7�HEAD�Argsc/�K�	|�|��}|�||d���}n&#ttf$rt	g��cYSwxYw|���D�]Z}t
|��}|�|d��}	|�|d��}
|j}|�	||j
��r(t|�||j
����}|j}	|j
}
|
|	}ne#t$rX	|j|�|	d��}t#||j|j|j��}n#t$rYY��wxYwYnwxYw||_||���kr||_t.j�|��|_|
|_|V���\dS)zP:return: iterator yielding Submodule instances available in the given repositoryTr�rRrWrN)r�r�r�r
�iter�sectionsrrcrm�
has_optionrjr�r�r�r�r�r�r.rTrUrRrOrLrkr-rlrNrM)rwrSrVr�r�r�r��smsr��p�ur�r��rtr�r�s                r5r(zSubmodule.iter_itemsSs�����	����]�+�+�B��'�'��b�D�'�A�A�F�F����!�	�	�	���8�8�O�O�O�	�����?�?�$�$�"	�"	�C�����A��
�
�3��'�'�A��
�
�3��&�&�A��"�A�� � ��c�&7�8�8�
<���
�
�3��(9�:�:�;�;���J�E�
��W����U�����
�
�
��!�M�%�/�/�!�Q�*?�*?�@�E�"�4���u�z�5�:�N�N�B�B�������H�H������B�	
�����B�H��T�[�[�]�]�"�"�$&��!�!�h�3�3�A�6�6�B�O��B�G��H�H�H�H�E"	�"	sF�-2� A�A�<D�
E.�AE�E.�
E(�$E.�'E(�(E.�-E.)NNNNNN)rYN)FF)NNFNNNFF)FTFNFFFNNFF)TT)TFTF)T)NT)rYr,)rYr-)rYr')r�)Kr:r;r<r=�_id_attribute_r�rjrm�stat�S_IFDIR�S_IFLNKr�rKr(rCrDr��bytesr&rBr)r�r'r\ro�classmethodrrxr�boolr}r$r��objectr�r�r�r�rr�r�rr�rr�r�r�r�r�r r!r*r�rrrIr�rgr�rArvr�r��propertyrHrXrrWrVrFrbrLr%r(�
__classcell__)r_s@r5r.r.Wsy	��������;�;��N�"�N��M��N��\�D�L�0�N�"-�D�'�+�
�,�,�,�R�I�3�L�"&�&*�!%�15� $�-1��������C��I��	�
�H�d�N�#���C��I��
��Z��-�.���3��9�
���8�T�>�*��
�������<5��5��5�5�5�5�5�5�,�$�;�$�<��;T�$�$�$��[�$��1�3�1�4�1�1�1��[�1�)�C�)�D�)�)�)�)�#�F�#�t�#�#�#�#� �#� � � � �������
�#�
�
�
�
��!E��!E�*/�
�D�0@�*A�!E�NR�!E�	�!E�!E�!E��[�!E�F�������������[��	@�D�	@�=N�	@�	@�	@�	@��#�&�#��#��#�PX�#�#�#��[�#��&+�',�&�&��&��&��	&�
�&�#�
&�!%�&��&�
�&�&�&��[�&�P��F��(��x�����[��.����[c��hl�����[��6�!%�#'�!�"&�.2�:>�%*�',�l�l��l��l��	l�
�3��9�
�l��c�4�i� �
l��l��S�$�Y��l��7�3��8�$�d�*�
+�l�#�8�C�=�$�#6�7�l�#�l�!%�l�
�l�l�l��[�l�` ��#(�26��� �.2�:>�%*�',�f�f��f��f�!�	f�
�.�/�f��
f��f��f��7�3��8�$�d�*�
+�f�#�8�C�=�$�#6�7�f�#�f�!%�f�
�f�f�f�f�P	�j�j��j��j�d�j�^i�j�j�j��[�j�X���"��f�f��f��f��	f�
�f�
�
f�f�f��[�f�P-�-��j�$�.>�(?�-��-�Xc�-�-�-�-�^�DH����,�-��=A��	�2�	3�����[��,�-�s�-�{�-�-�-��[�-�f�r�r�r��[�r�"�t�����3��3�3�3�3�D�8�8�8��X�8�
�!�X�!�!�!��X�!��;�S�;�;�;��X�;���S�����X���#�#�#��X�#���c�����X��?�0�1F�G�?�?�?�?�2�,�{�3�2�2�2�2��17�1�1��1��Z��_�-�1��	1�
�1�
�+�	�
1�1�1��[�1�1�1�1�1r7)L�ior�loggingr�r�rork�git.cmdr�
git.compatrr�
git.configrrr	�git.excr
rrr
�git.objects.baserr�git.objects.utilr�git.utilrrrrrrr�os.pathrRrg�utilrrrrr�typingrrr r!r"r#r$r%r&�	git.typesr'r(r)r*�	git.indexr+�git.repor,�git.refsr-�__all__�	getLoggerr�
addHandler�NullHandlerr/rrr?r@rAr.r2r7r5�<module>r�sJ������������	�	�	�	���������
�
�
�
���������������>�=�=�=�=�=�=�=�=�=�������������1�0�0�0�0�0�0�0�3�3�3�3�3�3�����������������/�.�.�.�.�.���������������������J�I�I�I�I�I�I�I�I�I�I�I�I�I�I�I�'�'�'�'�'�'�'�'�'�'�8�8�8�8�8�8�8�8�8�8�8�8���#�#�#�#�#�#�������������
�(�
)���g��4�5�5�����"�w�"�$�$�%�%�%������^����	�������������$�	�n�n�n�n�n��3�n�n�n�n�nr7

Hacked By AnonymousFox1.0, Coded By AnonymousFox