AlkantarClanX12

Your IP : 18.119.28.213


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

�

�܋fW�	���dZddlmZmZddlZddlmZmZmZddl	Z	ddl
mZddlm
Z
ddlZddlZddlmZmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!dd	l"m#Z#m$Z$m%Z%er7dd
l&m'Z'm(Z(ddl)m*Z*dd
l+m,Z,ddl-m.Z.ddl/m0Z0m1Z1ddl2m3Z3ddl4m5Z5ddl"m6Z6m7Z7neZ6d�Z7Gd�de��Z8edd���Z9e ee ddfdfZ:dZ;ed��Z<de e=e>fde?fd�Z@d e=de ed!ed"ed#ed$ffd%�ZAd&e>de?fd'�ZBd(e?de>fd)�ZCd*e>de>fd+�ZDGd,�d-e��ZEeEdd.��ZFd/eGd0eGdefd1�ZHd2e e>efdee?e?ffd3�ZIe	jJd4��ZKe	jJd5��ZLd6e>deee?e?ffd7�ZMGd8�d9eN��ZOe7Gd:�de6����ZPe7Gd;�d<e6����ZQGd=�deeP��ZRdS)>z$Module for general utility functions�)�ABC�abstractmethodN)�IterableList�IterableObj�Actor)�deque)�digits)�datetime�	timedelta�tzinfo)�Any�Callable�Deque�Iterator�Generic�
NamedTuple�overload�Sequence�
TYPE_CHECKING�Tuple�Type�TypeVar�Union�cast)�Has_id_attribute�Literal�_T)�BytesIO�StringIO�)�Commit)�Blob)�	TagObject)�Tree�TraversedTreeTup)�Popen)�	Submodule)�Protocol�runtime_checkablec��|S�N�)�fs �a/builddir/build/BUILD/cloudlinux-venv-1.0.6/venv/lib/python3.11/site-packages/git/objects/util.pyr)r)7s����c�F�eZdZUeed<eded<eded<dS)�
TraverseNT�depth��Traversabler"�item�r4N�srcN)�__name__�
__module__�__qualname__�int�__annotations__rr,r/r.r1r1;s?��������J�J�J�
�%�
&�&�&�&�	�"�	#�#�#�#�#�#r/r1�T_TIobj�TraversableIterableObj)�boundr6r4r%)�get_object_type_by_name�
parse_date�parse_actor_and_date�ProcessStreamAdapterr4�altz_to_utctz_str�
utctz_to_altz�verify_utctzr�tzoffset�utc�modestr�returnc���d}tt|dd�����D]D\}}tttt
f|��}|t|��|dzzz
}�E|S)a_
    :param modestr: string like 755 or 644 or 100644 - only the last 6 chars will be used
    :return:
        String identifying a mode compatible to the mode methods ids of the
        stat module regarding the rwx permissions for user, group and other,
        special flags and file system flags, i.e. whether it is a symlink
        for example.r���N�)�	enumerate�reversedrr�strr;)rI�mode�	iteration�chars    r.�mode_str_to_intrT]sk��
�D�$�X�g�b�c�c�l�%;�%;�<�<�+�+��	�4��E�#�s�(�O�T�*�*����D�	�	�Y��]�*�*����Kr/�object_type_namer!r#r$r"c���|dkr
ddlm}|jS|dkr
ddlm}|jS|dkr
ddlm}|jS|dkr
dd	lm}|jStd
|�
��z���)z�
    :return: type suitable to handle the given object type name.
        Use the type to create new instances.

    :param object_type_name: Member of TYPES

    :raise ValueError: In case object_type_name is unknownscommitr )�commitstag)�tagsblob)�blobstree)�treez%Cannot handle unknown object type: %s)�rWr!rXr#rYr"rZr$�
ValueError�decode)rUrWrXrYrZs     r.r@r@ms����9�$�$��������}��	�V�	#�	#��������}��	�W�	$�	$��������y��	�W�	$�	$��������y���@�CS�CZ�CZ�C\�C\�\�]�]�]r/�utctzc��t|��}t|��dzdzt|��dzdzz}|dkr|n|S)z�Convert a git timezone offset into a timezone offset west of
    UTC in seconds (compatible with time.altzone).

    :param utctz: git utc timezone string, i.e. +0200
    �d��<r)r;�abs)r^�	int_utctz�secondss   r.rErE�sM���E�
�
�I��I���#�%��-��Y���#�1E��0K�K�G��!�m�m�7�7�'��1r/�altzc��t|��dz}t|��dzdz}|dkrdnd}d�|||��S)z�Convert a timezone offset west of UTC in seconds into a git timezone offset string

    :param altz: timezone offset in seconds west of UTC
    rarb�-�+z{}{:02}{:02})rc�format)rf�hours�minutes�signs    r.rDrD�sR��

��I�I���E��4�y�y�4��B�&�G��"�*�*�3�3�#�D�� � ��u�g�6�6�6r/�offsetc���td|z��}t|��dkr|�|ddvr|�|dtvs-|dtvs|dtvs|dtvr|�|S)	z=:raise ValueError: if offset is incorrect
    :return: offsetz"Invalid timezone offset format: %s�rz+-r �rM�)r\�lenr	)rn�fmt_excs  r.rFrF�s����=��F�G�G�G�
�6�{�{�a����
�
�a�y�����
�
�a�y����&��)�6�"9�"9�V�A�Y�f�=T�=T�X^�_`�Xa�io�Xo�Xo��
��Mr/c���eZdZddededefddfd�Zdeedeeefffd�Z	dee
dfdefd�Zdee
dfdefd	�Z
dee
dfdefd
�ZdS)rGN�secs_west_of_utc�namerJc�D�t|���|_|pd|_dS)N)re�fixed)r�_offset�_name)�selfrvrws   r.�__init__ztzoffset.__init__�s'�� �*:�):�;�;�;����_�W��
�
�
r/c�R�t|j���|jffSr+)rGrz�
total_secondsr{�r|s r.�
__reduce__ztzoffset.__reduce__�s%���4�<�5�5�7�7�7���D�D�Dr/�dtc��|jSr+)rz�r|r�s  r.�	utcoffsetztzoffset.utcoffset�s
���|�r/c��|jSr+)r{r�s  r.�tznameztzoffset.tzname�s
���z�r/c��tSr+)�ZEROr�s  r.�dstztzoffset.dst�s���r/r+)r8r9r:�floatrrPr}rrr�r
rr�r�r�r,r/r.rGrG�s������%�%��%�e�D�#�I�6F�%�RV�%�%�%�%�E�E�$�z�"2�E�%��*�4E�"E�F�E�E�E�E��E�(�D�.�1��i�������x��~�.��3������e�H�d�N�+��	������r/rG�UTC�	timestamp�	tz_offsetc��tj|t��}	|�t	|����}|S#t
$r|cYSwxYw)zAConverts a timestamp + tz_offset into an aware datetime instance.)r
�
fromtimestamprH�
astimezonerGr\)r�r��utc_dt�local_dts    r.�from_timestampr��s]��
�
#�I�s�
3�
3�F���$�$�X�i�%8�%8�9�9����������
�
�
����s�#A�A�A�string_datec�v�t|t��r�|jr�tt|�����}t
|�����}t
|�t���
����|fStd|�����	|�d��dkr||�
d��dkrc|���\}}|�d��r
|dd�}t
|��}|t!t#|����fSd}|d	d
vr!t#|d	d���}|dd�}t!|��}g}d}d|vr+|�d
��|�
d��}n�|�d��|�d��|�d��|�d��|�
d��}|dkr|�
d��}|dksJ�||dzd�}|d|�}	t'j|d��}
|D]�}	t'j|	|��}t+j|j|j|j|
j|
j|
j|j|j|
jf	��}
t
|
��|fcS#t$rY��wxYwtd���#t@$r(}td|�dtC|������|�d}~wwxYw)a�
    Parse the given date as one of the following

        * aware datetime instance
        * Git internal format: timestamp offset
        * RFC 2822: Thu, 07 Apr 2005 22:13:13 +0200.
        * ISO 8601 2005-04-07T22:13:13
            The T can be a space as well

    :return: Tuple(int(timestamp_UTC), int(offset)), both in seconds since epoch
    :raise ValueError: If the format could not be understood
    :note: Date can also be YYYY.MM.DD, MM/DD/YYYY and DD.MM.YYYY.
    z,string_date datetime object without tzinfo, � r �:����@Nz+0000���z-+rL�,z%a, %d %b %Yz%Y-%m-%dz%Y.%m.%dz%m/%d/%Yz%d.%m.%Y�Tz%H:%M:%Szno format matchedz!Unsupported date format or type: z, type=)"�
isinstancer
rrrr�r;rr�rHr�r\�count�rfind�split�
startswithrErF�append�time�strptime�calendar�timegm�tm_year�tm_mon�tm_mday�tm_hour�tm_min�tm_sec�tm_wday�tm_yday�tm_isdst�	Exception�type)r�r�rnr��
offset_str�
timestamp_int�date_formats�splitter�	time_part�	date_part�tstruct�fmt�dtstruct�utctime�es               r.rArA�s����+�x�(�(�[���	[��Y��(=�(=�(?�(?�@�@�I��)�1�1�3�3�4�4�4�F��{�-�-�c�2�2�<�<�>�>�?�?��G�G��Y�K�Y�Y�Z�Z�Z�Em����S�!�!�Q�&�&�;�+<�+<�S�+A�+A�R�+G�+G�$/�$5�$5�$7�$7�!�I�z��#�#�C�(�(�
*�%�a�b�b�M�	��	�N�N�M� �-��Z�0H�0H�"I�"I�I�I� �J��2��$�&�&�)�+�b�c�c�*:�;�;�
�)�#�2�#�.��"�:�.�.�F��L��H��k�!�!��#�#�N�3�3�3�&�,�,�S�1�1����#�#�J�/�/�/��#�#�J�/�/�/��#�#�J�/�/�/��#�#�J�/�/�/�&�,�,�S�1�1���r�>�>�*�0�0��5�5�H��b�=�=�=�=�$�H�q�L�N�N�3�I�#�I�X�I�.�I��m�I�z�:�:�G�#�
�
���#�}�Y��<�<�H�&�o�$�,�$�O�$�,�#�O�#�N�#�N�$�,�$�,�#�,�
���G��w�<�<��/�/�/�/��!�����H������0�1�1�1���m�m�m��d�[�d�d�QU�Va�Qb�Qb�d�d�e�e�kl�l�����m���sE�4BL�	D+L�5A/K'�$L�'
K4�1L�3K4�4L�
L8�#L3�3L8z^.+? (.*) (\d+) ([+-]\d+).*$z
^.+? (.*)$�linec�D�d\}}}t�|��}|r|���\}}}n5t�|��}|r|�d��n|pd}tj|��t|��t|��fS)z�Parse out the actor (author or committer) info from a line like::

        author Tom Preston-Werner <tom@mojombo.com> 1191999972 -0700

    :return: [Actor, int_seconds_since_epoch, int_timezone_offset])r[�0r�r r[)	�_re_actor_epoch�search�groups�_re_only_actor�groupr�_from_stringr;rE)r��actor�epochrn�ms     r.rBrB3s���(��E�5�&����t�$�$�A��0� �x�x�z�z���u�f�f��!�!�$�'�'���/�����
�
�
�T�Z�R����u�%�%�s�5�z�z�=��3H�3H�I�Ir/c�:�eZdZdZdZdddeddfd�Zd	edefd
�ZdS)rCaClass wireing all calls to the contained Process instance.

    Use this type to hide the underlying process to provide access only to a specified
    stream. The process is usually wrapped into an AutoInterrupt class to kill
    it if the instance goes out of scope.)�_proc�_stream�processr&�stream_namerJNc�>�||_t||��|_dSr+)r��getattrr�)r|r�r�s   r.r}zProcessStreamAdapter.__init__Ss����
�!(��+�!>�!>����r/�attrc�,�t|j|��Sr+)r�r�)r|r�s  r.�__getattr__z ProcessStreamAdapter.__getattr__Ws���t�|�T�*�*�*r/)	r8r9r:�__doc__�	__slots__rPr}r
r�r,r/r.rCrCIsp������-�-�%�I�?��?�c�?�d�?�?�?�?�+��+��+�+�+�+�+�+r/rCc��eZdZdZdZeedededfd�����Z	edededefd���Z
	dd
edededee
dfd�Zedededefd
���Zd�d�ddddd	fdee
ddefegefdee
ddefegefdedededed
ede
ee
deeffd�ZdS)r4z�Simple interface to perform depth-first or breadth-first traversals
    into one direction.
    Subclasses only need to implement one function.
    Instances of the Subclass must be hashable

    Defined subclasses = [Commit, Tree, SubModule]
    r,r5rJc� �td���)a@
        Returns:
            Tuple of items connected to the given item.
            Must be implemented in subclass

        class Commit::     (cls, Commit) -> Tuple[Commit, ...]
        class Submodule::  (cls, Submodule) -> Iterablelist[Submodule]
        class Tree::       (cls, Tree) -> Tuple[Tree, ...]
        �To be implemented in subclass��NotImplementedError)�clsr5s  r.�_get_intermediate_itemsz#Traversable._get_intermediate_itemshs��"�"A�B�B�Br/�args�kwargsc�T�tjdtd���|j|i|��S)r�z�list_traverse() method should only be called from subclasses.Calling from Traversable abstract class will raise NotImplementedError in 3.1.20Builtin sublclasses are 'Submodule', 'Tree' and 'Commitrq��
stacklevel)�warnings�warn�DeprecationWarning�_list_traverse�r|r�r�s   r.�
list_traversezTraversable.list_traversevsE��	�
�
F�
��	
�	
�	
�	
�#�t�"�D�3�F�3�3�3r/F�as_edge)r!r'r$r"c���t|t��r|j}nd}|s3t|��}|�|j|d|i|����|St|j|i|����}|S)a
        :return: IterableList with the results of the traversal as produced by
            traverse()
            Commit -> IterableList['Commit']
            Submodule ->  IterableList['Submodule']
            Tree -> IterableList[Union['Submodule', 'Tree', 'Blob']]
        r[r�)r�r�_id_attribute_r�extend�traverse)r|r�r�r��id�out�out_lists       r.r�zTraversable._list_traverse�s����d�,�-�-�	��$�B�B��B��		�NZ�[]�N^�N^�C��J�J�}�t�}�t�F�W�F�v�F�F�G�G�G��J�
&2�-�$�-��2P��2P�2P�%Q�%Q�H��Or/c�T�tjdtd���|j|i|��S)r�z�traverse() method should only be called from subclasses.Calling from Traversable abstract class will raise NotImplementedError in 3.1.20Builtin sublclasses are 'Submodule', 'Tree' and 'Commitrqr�)r�r�r��	_traverser�s   r.r�zTraversable.traverse�sD��	�
�
F�
��	
�	
�	
�	
��t�~�t�.�v�.�.�.r/c��dS�NTr,��i�ds  r.�<lambda>zTraversable.<lambda>�s��dh�r/c��dS�NFr,r�s  r.r�zTraversable.<lambda>�s��`e�r/r�Tr �	predicater"�pruner2�branch_first�
visit_once�ignore_selfr3c
#���K�	t��}t��}	|	�td�d����dttdddt
dtddf
��fd	�}
|	r�|	���\}�}|r�|vr�!|r|����|r|�f}
n�}
||
|��r�N|o��u}|s||
|��r|
V�|d
z}|dkr||kr�x|
|	�||��|	��dSdS)aF:return: iterator yielding of items found when traversing self
        :param predicate: f(i,d) returns False if item i at depth d should not be included in the result

        :param prune:
            f(i,d) return True if the search should stop at item i at depth d.
            Item i will not be returned.

        :param depth:
            define at which level the iteration should not go deeper
            if -1, there is no limit
            if 0, you would effectively only get self, the root of the iteration
            i.e. if 1, you would only get the first level of predecessors/successors

        :param branch_first:
            if True, items will be returned branch first, otherwise depth first

        :param visit_once:
            if True, items will only be returned once, although they might be encountered
            several times. Loops are prevented that way.

        :param ignore_self:
            if True, self will be ignored and automatically pruned from
            the result. Otherwise it will be the first item to be returned.
            If as_edge is True, the source of the first edge is None

        :param as_edge:
            if True, return a pair of items, first being the source, second the
            destination, i.e. tuple(src, dest) with the edge spanning from
            source to destinationrN�stack�src_itemr4r�r2rJc�������������sdS|r$|���fd��D����dS���fd�tt���dz
dd��D��}|�|��dS)Nc3�:�K�|]}t�|���V��dSr+�r1)�.0r�r2rs  ��r.�	<genexpr>z<Traversable._traverse.<locals>.addToStack.<locals>.<genexpr>�s/����� M� M�A��E�1�h�!?�!?� M� M� M� M� M� Mr/c3�F�K�|]}t��|���V��dSr+r)rr�r2�lstrs  ���r.rz<Traversable._traverse.<locals>.addToStack.<locals>.<genexpr>�s3�����d�d�1�:�e�S��V�X�>�>�d�d�d�d�d�dr/r r�)r��
extendleft�rangersr�)rrr�r2�reviterrr5r|s ` ` @��r.�
addToStackz)Traversable._traverse.<locals>.addToStack�s��������.�.�t�4�4�C��
��t��
&�� � � M� M� M� M� M�� M� M� M�M�M�M�M�M�d�d�d�d�d�d��c�RU�h�h�YZ�l�\^�`b�Hc�Hc�d�d�d�����W�%�%�%�%�%r/r r�)	�setrr�r1r�boolr;�pop�add)r|r�r�r2r�r�r�r��visitedrrr�r7�rval�
skipStartItem�ndr5s`               @r.r�zTraversable._traverse�s�������P		L��%�%��#(�7�7��
���Z��4��.�.�/�/�/�
	&���$�
	&�#�
	&��
	&��	
	&�
�
	&�
	&�
	&�
	&�
	&�
	&�
	&�"�	6� �9�9�;�;�L�A�t�S��
�d�g�o�o���
"����D�!�!�!��
��T�{������u�T�1�~�~�
��'�:�T�T�\�M� �
�Y�Y�t�Q�%7�%7�
��
�
�
��Q��B��r�z�z�b�5�j�j���J�u�d�L�"�5�5�5�7�	6�	6�	6�	6�	6r/N)F)r8r9r:r�r��classmethodrr
rr�r�rrrr�r�r�TraversedTupr;rr�r,r/r.r4r4[s����������I���
C�3�
C�8�M�3J�
C�
C�
C��^��[�
C��	4�3�	4�#�	4�#�	4�	4�	4��^�	4�$�����,/��;>��	�e�A�B�	C�����:�	/�c�	/�S�	/�S�	/�	/�	/��^�	/�Xi�Wh�Se�Se��!����c6�c6��U�=�&�,�#F�G��M�t�S�T�c6���}�f�l�B�C�S�I�4�O�P�c6��	c6�
�c6��
c6��c6��c6�
�x��3�4�5�x��7M�M�	N�c6�c6�c6�c6�c6�c6r/c�&�eZdZdZdZd	d�Zd	d�ZdS)
�SerializablezPDefines methods to serialize and deserialize objects from and into a data streamr,�streamrrJc� �td���)z�Serialize the data of this object into the given data stream
        :note: a serialized object would ``_deserialize`` into the same object
        :param stream: a file-like object
        :return: selfr�r��r|rs  r.�
_serializezSerializable._serializes��
"�"A�B�B�Br/c� �td���)z�Deserialize all information regarding this object from the stream
        :param stream: a file-like object
        :return: selfr�r�rs  r.�_deserializezSerializable._deserialize"s��"�"A�B�B�Br/N)rrrJr)r8r9r:r�r�rrr,r/r.rrsT������[�Z��I�C�C�C�C�C�C�C�C�C�Cr/rc�
��eZdZdZeeedfefZdededede	ef�fd�Z
ededeefd���Z
eded	eeeeeedfeffegefd
eeeeeedfeffegefdeded
ededdeddeefd���Z
eded	eeeeeedfeffegefd
eeeeeedfeffegefdeded
ededdeddeeeedfeffd���Z
eded	eeeefegefd
eeeefegefdeded
ededdeddeeeeffd���Z
d�d�dddddfded	eeeefegefd
eeeefegefdeded
edededeeeeeeefeeff�fd�
Z
�xZS)r>r,Nr|r�r�rJc�D��tt|��j|i|��Sr+)�superr>r�)r|r�r��	__class__s   �r.r�z$TraversableIterableObj.list_traverse.s&���A�u�+�T�2�2�A�4�R�6�R�R�Rr/c��dSr+r,r�s r.r�zTraversableIterableObj.traverse1s���r/r�r�r2r�r�r�Tr�Fc��dSr+r,�r|r�r�r2r�r�r�r�s        r.r�zTraversableIterableObj.traverse5�	��	�r/c��dSr+r,r%s        r.r�zTraversableIterableObj.traverseBr&r/c��dSr+r,r%s        r.r�zTraversableIterableObj.traverseOr&r/c��dSr�r,r�s  r.r�zTraversableIterableObj.<lambda>^s��UY�r/c��dSr�r,r�s  r.r�zTraversableIterableObj.<lambda>_s��QV�r/r�r c���	tttttttdtftfftt|���|||||||����S)z3For documentation, see util.Traversable._traverse()N)rrrr=rr!r>r�)	r|r�r�r2r�r�r�r�r"s	        �r.r�zTraversableIterableObj.traverse\st���	� ��(�7�#�X�e�E�$��-�4H�'�4Q�.R�%S�S�T��(�$�/�/�9�9��5�%��z�;�PW�
�
�
�
�	
r/)r8r9r:r�rrr=�TIobj_tupler
rr�rrr�rr;rr�
__classcell__)r"s@r.r>r>)s6��������I���g�t�m�,�g�5�6�K�S�G�S�C�S�3�S�<�PW�CX�S�S�S�S�S�S���w��8�G�#4�����X���
��
��U�7�E�%���
�2F��2O�,P�#P�Q�SV�W�Y]�]�^�
���w��e�G�T�M�.B�G�.K�(L�L�M�s�S�UY�Y�Z�
��	
�
�
��
��T�]�
����
�
�'�	�
�
�
��X�
��
��
��U�7�E�%���
�2F��2O�,P�#P�Q�SV�W�Y]�]�^�
���w��e�G�T�M�.B�G�.K�(L�L�M�s�S�UY�Y�Z�
��	
�
�
��
��U�^�
����
�
�%��g�t�m�,�g�5�6�	7�
�
�
��X�
��
��
��U�7�K�#7�8�#�>��D�E�
���w��3�4�c�:�D�@�A�
��	
�
�
��
��T�]�
����
�
�%���(�)�	*�
�
�
��X�
�IZ�HY�DV�DV��!����!
�!
��!
��U�7�K�#7�8�#�>��D�E�!
���w��3�4�c�:�D�@�A�!
��	!
�
�!
��
!
��!
��!
�
�x�� �(�5��'�1A�+B�"C�X�k�EZ�Z�	[�!
�!
�!
�!
�!
�!
�!
�!
�!
�!
r/)Sr��abcrrr��git.utilrrr�re�collectionsr�stringr	r�r�r
rr�typingr
rrrrrrrrrrrrr�	git.typesrrr�iorrrWr!rYr"rXr#rZr$r%�
subprocessr&�submodule.baser'r(r)r1r=r�__all__r��bytesrPr;rTr@rErDrFrGrHr�r�rA�compiler�r�rB�objectrCr4rr>r,r/r.�<module>r<sk��+�*�$�#�#�#�#�#�#�#�����5�5�5�5�5�5�5�5�5�5�	�	�	�	���������������������0�0�0�0�0�0�0�0�0�0���������������������������������"4�3�3�3�3�3�3�3�3�3���$�$�$�$�$�$�$�$�������������������,�,�,�,�,�,�,�,� � � � � � �)�)�)�)�)�)�5�5�5�5�5�5�5�5�5��H����$�$�$�$�$��$�$�$��'�)�#;�
<�
<�
<���	�%�#�
$�m�
3�4��������y��|�|��

�U�5�#�:�.�
�3�
�
�
�
� ^��^�
�4��>�4��,�d�6�l�D��L�H�I�^�^�^�^�<2��2��2�2�2�2�7�C�7�C�7�7�7�7��������������v����$�h�q�%�����e����(�����\m�E�#�x�-�0�\m�U�3��8�_�\m�\m�\m�\m�B�"�*�<�=�=�����M�*�*��
J�s�
J�u�U�C��_�'=�
J�
J�
J�
J�,+�+�+�+�+�6�+�+�+�$�r6�r6�r6�r6�r6�(�r6�r6���r6�l�C�C�C�C�C�8�C�C���C�,T
�T
�T
�T
�T
�[�+�T
�T
�T
�T
�T
r/