HEX
Server: LiteSpeed
System: Linux us-phx-web1284.main-hosting.eu 4.18.0-553.109.1.lve.el8.x86_64 #1 SMP Thu Mar 5 20:23:46 UTC 2026 x86_64
User: u300739242 (300739242)
PHP: 8.2.30
Disabled: system, shell_exec, passthru, mysql_list_dbs, ini_alter, dl, symlink, link, chgrp, leak, popen, apache_child_terminate, virtual, mb_send_mail
Upload Files
File: //opt/alt/python311/lib/python3.11/site-packages/botocore/__pycache__/signers.cpython-311.pyc
�

/�;f�x���ddlZddlZddlZddlZddlZddlZddlmZmZddl	m
Z
ddlmZm
Z
mZddlmZmZddlmZGd�d��ZGd	�d
��Zd�Zdd�ZGd
�d��Zd�Z	dd�Zd�Z	dd�Zd�ZdS)�N)�create_request_object�prepare_request_dict)�OrderedDict)�UnknownClientMethodError�UnknownSignatureVersionError� UnsupportedSignatureVersionError)�	ArnParser�datetime2timestamp)�fix_s3_hostc��eZdZdZ	dd�Zed���Zed���Zed���Zdd�Z					dd	�Z
d
�Zd�Z		dd�Z
e
Z			dd�ZdS)�
RequestSignera0
    An object to sign requests before they go out over the wire using
    one of the authentication mechanisms defined in ``auth.py``. This
    class fires two events scoped to a service and operation name:

    * choose-signer: Allows overriding the auth signer name.
    * before-sign: Allows mutating the request before signing.

    Together these events allow for customization of the request
    signing pipeline, including overrides, request path manipulation,
    and disabling signing per operation.


    :type service_id: botocore.model.ServiceId
    :param service_id: The service id for the service, e.g. ``S3``

    :type region_name: string
    :param region_name: Name of the service region, e.g. ``us-east-1``

    :type signing_name: string
    :param signing_name: Service signing name. This is usually the
                         same as the service name, but can differ. E.g.
                         ``emr`` vs. ``elasticmapreduce``.

    :type signature_version: string
    :param signature_version: Signature name like ``v4``.

    :type credentials: :py:class:`~botocore.credentials.Credentials`
    :param credentials: User credentials with which to sign requests.

    :type event_emitter: :py:class:`~botocore.hooks.BaseEventHooks`
    :param event_emitter: Extension mechanism to fire events.
    Nc��||_||_||_||_||_||_t
j|��|_dS�N)	�_region_name�
_signing_name�_signature_version�_credentials�_auth_token�_service_id�weakref�proxy�_event_emitter)�self�
service_id�region_name�signing_name�signature_version�credentials�
event_emitter�
auth_tokens        �C/opt/alt/python311/lib/python3.11/site-packages/botocore/signers.py�__init__zRequestSigner.__init__DsN��(���)���"3���'���%���%���&�m�M�:�:�����c��|jSr)r�rs r!rzRequestSigner.region_nameXs��� � r#c��|jSr)rr%s r!rzRequestSigner.signature_version\s���&�&r#c��|jSr)rr%s r!rzRequestSigner.signing_name`s���!�!r#c�.�|�||��Sr)�sign)r�operation_name�request�kwargss    r!�handlerzRequestSigner.handlerds��
�y�y���1�1�1r#�standardc	�N�|}|�|j}|�|j}|�|||j��}|j�d�|j���|��|||j|||���|tj
k�r|||d�}	|�||	d<|j�di��}
|s |
�d��r|
d|	d<|
�d	��r|
d	|	d	<|
�d
��r|
d
|	d
<|
�d���#|�|	|
d|
d��	|j
di|	��}n*#t$r}|d
krt|����|�d}~wwxYw|�|��dSdS)a<Sign a request before it goes out over the wire.

        :type operation_name: string
        :param operation_name: The name of the current operation, e.g.
                               ``ListBuckets``.
        :type request: AWSRequest
        :param request: The request object to be sent over the wire.

        :type region_name: str
        :param region_name: The region to sign the request for.

        :type signing_type: str
        :param signing_type: The type of signing to perform. This can be one of
            three possible values:

            * 'standard'     - This should be used for most requests.
            * 'presign-url'  - This should be used when pre-signing a request.
            * 'presign-post' - This should be used when pre-signing an S3 post.

        :type expires_in: int
        :param expires_in: The number of seconds the presigned url is valid
            for. This parameter is only valid for signing type 'presign-url'.

        :type signing_name: str
        :param signing_name: The name to use for the service when signing.
        Nzbefore-sign.{}.{})r+rrr�request_signerr*)rrr�expires�signing�regionrr�request_credentials�identity_cache�	cache_keyr.�r�)rr�_choose_signer�contextr�emit�formatr�	hyphenize�botocore�UNSIGNED�get�_resolve_identity_cache�get_auth_instancerr�add_auth)
rr*r+r�signing_type�
expires_inr�explicit_region_namerr,�signing_context�auth�es
             r!r)zRequestSigner.signksB��F +�����+�K����-�L� �/�/��L�'�/�
�
��
	
�� � ��&�&�� �*�*�,�,�n�
�
��%��)�/��)�	!�
	
�
	
�
	
��� 1�1�1� ,�*�%6���F�
�%�$.��y�!�%�o�1�1�)�R�@�@�O�'�
B�O�,?�,?��,I�,I�
B�(7��(A��}�%��"�"�>�2�2�
I�)8��)H��~�&��"�"�#8�9�9�
�0?�)�1��,�-��"�"�#3�4�4�@��,�,��#�$4�5�#�K�0����

�-�t�-�7�7��7�7����/�
�
�
��:�-�-�:�*;������G�����

����
�M�M�'�"�"�"�"�"�C2�1s�
E$�$
F�.F�Fc��||d<||d<dS)Nr5r6r8)rr,�cacher6s    r!rAz%RequestSigner._resolve_identity_cache�s��#(��� �'��{���r#c�N�ddd�}|�|d��}|�d��p|j}|�di��}|�d|j��}|�d|j��}	|tjur|�|��s||z
}|j�d	�	|j
���|��||	||�
��\}
}|�*|}|tjur|�|��s||z
}|S)ai
        Allow setting the signature version via the choose-signer event.
        A value of `botocore.UNSIGNED` means no signing will be performed.

        :param operation_name: The operation to sign.
        :param signing_type: The type of signing that the signer is to be used
            for.
        :return: The signature version to sign with.
        z
-presign-postz-query)�presign-post�presign-url��	auth_typer2rr3zchoose-signer.{}.{})rrrr:)r@rrrr>r?�endswithr�emit_until_responser<rr=)rr*rDr:�signing_type_suffix_map�suffixrr2rrr-�responses            r!r9zRequestSigner._choose_signer�sY��,�#�#
�#
��)�,�,�\�2�>�>��$�K�K��4�4�O��8O���+�+�i��,�,���{�{�>�4�3E�F�F���k�k�(�D�,=�>�>���X�%6�6�6�%�.�.�v�6�6�
7�
��'�� �/�C�C�!�(�(�� �*�*�,�,�n�
�
�&�#�/��D�
�
������ (��"��):�:�:�)�2�2�6�:�:�;�"�V�+�!� � r#c�2�|�|j}tjj�|��}|�t|����|jdur/d}|j�|j���}||��}|S|p|j	}	t|dd��dur(|d}
|d}|
�|��}	|d=d}|	�|	���}||d<|j
r/|j�tj����||d<||d	<|d
i|��}|S)a�
        Get an auth instance which can be used to sign a request
        using the given signature version.

        :type signing_name: string
        :param signing_name: Service signing name. This is usually the
                             same as the service name, but can differ. E.g.
                             ``emr`` vs. ``elasticmapreduce``.

        :type region_name: string
        :param region_name: Name of the service region, e.g. ``us-east-1``

        :type signature_version: string
        :param signature_version: Signature name like ``v4``.

        :rtype: :py:class:`~botocore.auth.BaseSigner`
        :return: Auth instance to sign a request.
        Nr7T�REQUIRES_IDENTITY_CACHEr5r6rr�service_namer8)rr>rH�AUTH_TYPE_MAPSr@r�REQUIRES_TOKENr�get_frozen_tokenr�getattr�get_credentials�get_frozen_credentials�REQUIRES_REGIONr�
exceptions�
NoRegionError)
rrrrr4r,�cls�frozen_tokenrHrrK�key�frozen_credentialss
             r!rBzRequestSigner.get_auth_instance�sc��4�$� $� 7���m�*�.�.�/@�A�A���;�.�"3����
����%�%��L���+�#�/�@�@�B�B���3�|�$�$�D��K�)�>�T�->���3�1�4�8�8�D�@�@��+�,�E���%�C��/�/��4�4�K��{�#�"���"�!,�!C�!C�!E�!E�� 2��}����	2�� �(��)�7�7�9�9�9�$/�F�=�!�%1�F�>�"��s�}�}�V�}�}���r#�c��t|��}|�|||d||��|���|jS)a�Generates a presigned url

        :type request_dict: dict
        :param request_dict: The prepared request dictionary returned by
            ``botocore.awsrequest.prepare_request_dict()``

        :type operation_name: str
        :param operation_name: The operation being signed.

        :type expires_in: int
        :param expires_in: The number of seconds the presigned url is valid
            for. By default it expires in an hour (3600 seconds)

        :type region_name: string
        :param region_name: The region name to sign the presigned url.

        :type signing_name: str
        :param signing_name: The name to use for the service when signing.

        :returns: The presigned url
        rN)rr)�prepare�url)r�request_dictr*rErrr+s       r!�generate_presigned_urlz$RequestSigner.generate_presigned_urlCsS��:(��5�5���	�	�������
	
�	
�	
�	�������{�r#r�NN)Nr.NN)rfNN)�__name__�
__module__�__qualname__�__doc__r"�propertyrrrr-r)rAr9rB�get_authrkr8r#r!r
r
!s&������ � �T�;�;�;�;�(�!�!��X�!��'�'��X�'��"�"��X�"�2�2�2�2�����\#�\#�\#�\#�|(�(�(�0!�0!�0!�l� �?�?�?�?�D!�H����
(�(�(�(�(�(r#r
c�6�eZdZdZd�Zdd�Zd�Z	dd�Zd�ZdS)	�CloudFrontSignera�A signer to create a signed CloudFront URL.

    First you create a cloudfront signer based on a normalized RSA signer::

        import rsa
        def rsa_signer(message):
            private_key = open('private_key.pem', 'r').read()
            return rsa.sign(
                message,
                rsa.PrivateKey.load_pkcs1(private_key.encode('utf8')),
                'SHA-1')  # CloudFront requires SHA-1 hash
        cf_signer = CloudFrontSigner(key_id, rsa_signer)

    To sign with a canned policy::

        signed_url = cf_signer.generate_signed_url(
            url, date_less_than=datetime(2015, 12, 1))

    To sign with a custom policy::

        signed_url = cf_signer.generate_signed_url(url, policy=my_policy)
    c�"�||_||_dS)a�Create a CloudFrontSigner.

        :type key_id: str
        :param key_id: The CloudFront Key Pair ID

        :type rsa_signer: callable
        :param rsa_signer: An RSA signer.
               Its only input parameter will be the message to be signed,
               and its output will be the signed content as a binary string.
               The hash algorithm needed by CloudFront is SHA-1.
        N)�key_id�
rsa_signer)rrvrws   r!r"zCloudFrontSigner.__init__�s�����$����r#Nc�T�|duo|du}|duo|du}|s|rd}t|���|�|�||��}t|t��r|�d��}|�!dtt
|����zg}n,d|�|���d��zg}|�	|��}|�
d|�|���d����d|j��g��|�||��S)a�Creates a signed CloudFront URL based on given parameters.

        :type url: str
        :param url: The URL of the protected object

        :type date_less_than: datetime
        :param date_less_than: The URL will expire after that date and time

        :type policy: str
        :param policy: The custom policy, possibly built by self.build_policy()

        :rtype: str
        :return: The signed URL.
        Nz=Need to provide either date_less_than or policy, but not both�utf8z
Expires=%sz	Policy=%sz
Signature=zKey-Pair-Id=)
�
ValueError�build_policy�
isinstance�str�encode�intr
�_url_b64encode�decoderw�extendrv�
_build_url)	rri�date_less_than�policy�both_args_supplied�neither_arg_suppliedrI�params�	signatures	         r!rkz'CloudFrontSigner.generate_presigned_url�sQ��,�4�7�N�F�$�<N��-��5�H�&�D�.���	 �!5�	 �O�A��Q�-�-���%��&�&�s�N�;�;�F��f�c�"�"�	+��]�]�6�*�*�F��%�"�S�);�N�)K�)K�%L�%L�L�M�F�F�!�D�$7�$7��$?�$?�$F�$F�v�$N�$N�N�O�F��O�O�F�+�+�	��
�
�L�T�0�0��;�;�B�B�6�J�J�L�L�,�t�{�,�,�
�	
�	
�	
����s�F�+�+�+r#c�H�d|vrdnd}||zd�|��zS)N�?�&)�join)r�base_url�extra_params�	separators    r!r�zCloudFrontSigner._build_url�s/���(�?�?�C�C��	��)�#�c�h�h�|�&<�&<�<�<r#c�.�tt|����}tdd|ii��}|rd|vr|dz
}d|i|d<|r#tt|����}d|i|d<d|fd	|fg}d
t|��gi}tj|d���S)
a0A helper to build policy.

        :type resource: str
        :param resource: The URL or the stream filename of the protected object

        :type date_less_than: datetime
        :param date_less_than: The URL will expire after the time has passed

        :type date_greater_than: datetime
        :param date_greater_than: The URL will not be valid until this time

        :type ip_address: str
        :param ip_address: Use 'x.x.x.x' for an IP, or 'x.x.x.x/x' for a subnet

        :rtype: str
        :return: The policy in a compact string.
        �DateLessThanz
AWS:EpochTime�/z/32zAWS:SourceIp�	IpAddress�DateGreaterThan�Resource�	Condition�	Statement)�,�:)�
separators)rr
r�json�dumps)	r�resourcer��date_greater_than�
ip_address�moment�	condition�ordered_payload�
custom_policys	         r!r{zCloudFrontSigner.build_policy�s���:�'��7�7�8�8����/�6�1J� K�L�L�	��	B��*�$�$��e�#�
�&4�j�%A�I�k�"��	E��+�,=�>�>�?�?�F�,;�V�+D�I�'�(�&��1�K��3K�L��$�{�?�'C�'C�&D�E�
��z�-�J�?�?�?�?r#c��tj|���dd���dd���dd��S)N�+�-�=�_�/�~)�base64�	b64encode�replace)r�datas  r!r�zCloudFrontSigner._url_b64encode�sD��
��T�"�"�
�W�T�4�
 �
 �
�W�T�4�
 �
 �
�W�T�4�
 �
 �		
r#rl)	rmrnrorpr"rkr�r{r�r8r#r!rtrtns���������.
%�
%�
%�$,�$,�$,�$,�L=�=�=�
LP�(@�(@�(@�(@�T
�
�
�
�
r#rtc��t|d<dS)N�generate_db_auth_token)r���class_attributesr,s  r!�add_generate_db_auth_tokenr�����1G��-�.�.�.r#c���|}|�|jj}d|d�}ddi|dd�}d}|�|�d	|��}	t||	��|j�d||d
d���}
|
t|��d�S)
aGenerates an auth token used to connect to a db with IAM credentials.

    :type DBHostname: str
    :param DBHostname: The hostname of the database to connect to.

    :type Port: int
    :param Port: The port number the database is listening on.

    :type DBUsername: str
    :param DBUsername: The username to log in as.

    :type Region: str
    :param Region: The region the database is in. If None, the client
        region will be used.

    :return: A presigned url which can be used as an auth token.
    N�connect)�Action�DBUserr�rO�GET)�url_path�query_string�headers�body�methodzhttps://r�i�zrds-db)r*rjrrEr)�metarr�_request_signerrk�len)r�
DBHostname�Port�
DBUsername�Regionr3r�rj�scheme�endpoint_url�
presigned_urls           r!r�r��s���$�F�
�~���&������F��������L��F��1�j�1�1�4�1�1�L���|�4�4�4��(�?�?� �!����@���M���V�����'�'r#c�$�eZdZd�Z				dd�ZdS)�S3PostPresignerc��||_dSr)r�)rr0s  r!r"zS3PostPresigner.__init__/s��-����r#Nrfc��|�i}|�g}i}tj���}|tj|���z}|�tjj��|d<g|d<|D]}	|d�|	���t|��}
||
j	d<||
j	d<|j
�d|
|d��|
j|d	�S)
a�Generates the url and the form fields used for a presigned s3 post

        :type request_dict: dict
        :param request_dict: The prepared request dictionary returned by
            ``botocore.awsrequest.prepare_request_dict()``

        :type fields: dict
        :param fields: A dictionary of prefilled form fields to build on top
            of.

        :type conditions: list
        :param conditions: A list of conditions to include in the policy. Each
            element can be either a list or a structure. For example:
            [
             {"acl": "public-read"},
             {"bucket": "mybucket"},
             ["starts-with", "$key", "mykey"]
            ]

        :type expires_in: int
        :param expires_in: The number of seconds the presigned post is valid
            for.

        :type region_name: string
        :param region_name: The region name to sign the presigned post to.

        :rtype: dict
        :returns: A dictionary with two elements: ``url`` and ``fields``.
            Url is the url to post to. Fields is a dictionary filled with
            the form fields and respective values to use when submitting the
            post. For example:

            {'url': 'https://mybucket.s3.amazonaws.com
             'fields': {'acl': 'public-read',
                        'key': 'mykey',
                        'signature': 'mysignature',
                        'policy': 'mybase64 encoded policy'}
            }
        N)�seconds�
expiration�
conditionszs3-presign-post-fieldszs3-presign-post-policy�	PutObjectrM)ri�fields)
�datetime�utcnow�	timedelta�strftimer>rH�ISO8601�appendrr:r�r)ri)rrjr�r�rErr��datetime_now�expire_dater�r+s           r!�generate_presigned_postz'S3PostPresigner.generate_presigned_post2s��^�>��F����J��� �(�/�/�1�1��"�X�%7�
�%K�%K�%K�K��*�3�3�H�M�4I�J�J��|�� "��|��#�	3�	3�I��<� �'�'�	�2�2�2�2�(��5�5��4:���0�1�4:���0�1���!�!���+�~�	
�	
�	
��{�f�5�5�5r#)NNrfN)rmrnror"r�r8r#r!r�r�.sK������.�.�.�����
K6�K6�K6�K6�K6�K6r#r�c��t|d<dS)Nrk)rkr�s  r!�add_generate_presigned_urlr��r�r#rfc��|}|}|�i}|}|}dt|��d�}	|j}
	|j|}n#t$rt	|����wxYw|jj�|��}|�|||	���}tj
|�dd����}
|�|||	|
���\}}}|�
||||	|d	�
��}|�||d<|
�|||���S)
axGenerate a presigned url given a client, its method, and arguments

    :type ClientMethod: string
    :param ClientMethod: The client method to presign for

    :type Params: dict
    :param Params: The parameters normally passed to
        ``ClientMethod``.

    :type ExpiresIn: int
    :param ExpiresIn: The number of seconds the presigned url is valid
        for. By default it expires in an hour (3600 seconds)

    :type HttpMethod: string
    :param HttpMethod: The http method to use on the generated url. By
        default, the http method is whatever is used in the method's model.

    :returns: The presigned url
    NT��is_presign_request�use_global_endpoint)�method_name��
api_params�operation_modelr:�BucketrO��ignore_signing_regionF�r�r�r�r:r��set_user_agent_headerr�)rjrEr*)�_should_use_global_endpointr��_PY_TO_OP_NAME�KeyErrorrr��
service_modelr��_emit_api_paramsr	�is_arnr@�_resolve_endpoint_ruleset�_convert_to_request_dictrk)r�ClientMethod�Params�	ExpiresIn�
HttpMethod�
client_methodr�rE�http_methodr:r0r*r��
bucket_is_arnr��additional_headers�
propertiesrjs                  r!rkrk�s���,!�M�
�F�
�~����J��K�"�:�4�@�@���G�
�)�N�B��,�]�;�����B�B�B�&�=�A�A�A�A�B�����i�-�=�=�n�M�M�O�
�
"�
"��'��#���F�
�$�V�Z�Z��"�%=�%=�>�>�M�
	
�&�&����#0�0�		'�	�	�	�����0�0��'�!��"�#�
1���L���!,��X���0�0�!��%�1���s	�
5�Ac��t|d<dS)Nr�)r�r�s  r!�add_generate_presigned_postr��s��2I��.�/�/�/r#c	���|}|}|}|}	|}
|�i}n|���}|	�g}	dt|��d�}t|j��}|jj�d��}
|�d|i|
|���}tj	|�
dd����}|�|
|||���\}}}|�||
|||d	�
��}|	�
d|i��|�d��r/|	�
d
d|dtd���g��n|	�
d|i��||d<|�|||	|
���S)a�	Builds the url and the form fields used for a presigned s3 post

    :type Bucket: string
    :param Bucket: The name of the bucket to presign the post to. Note that
        bucket related conditions should not be included in the
        ``conditions`` parameter.

    :type Key: string
    :param Key: Key name, optionally add ${filename} to the end to
        attach the submitted filename. Note that key related conditions and
        fields are filled out for you and should not be included in the
        ``Fields`` or ``Conditions`` parameter.

    :type Fields: dict
    :param Fields: A dictionary of prefilled form fields to build on top
        of. Elements that may be included are acl, Cache-Control,
        Content-Type, Content-Disposition, Content-Encoding, Expires,
        success_action_redirect, redirect, success_action_status,
        and x-amz-meta-.

        Note that if a particular element is included in the fields
        dictionary it will not be automatically added to the conditions
        list. You must specify a condition for the element as well.

    :type Conditions: list
    :param Conditions: A list of conditions to include in the policy. Each
        element can be either a list or a structure. For example:

        [
         {"acl": "public-read"},
         ["content-length-range", 2, 5],
         ["starts-with", "$success_action_redirect", ""]
        ]

        Conditions that are included may pertain to acl,
        content-length-range, Cache-Control, Content-Type,
        Content-Disposition, Content-Encoding, Expires,
        success_action_redirect, redirect, success_action_status,
        and/or x-amz-meta-.

        Note that if you include a condition, you must specify
        the a valid value in the fields dictionary as well. A value will
        not be added automatically to the fields dictionary based on the
        conditions.

    :type ExpiresIn: int
    :param ExpiresIn: The number of seconds the presigned post
        is valid for.

    :rtype: dict
    :returns: A dictionary with two elements: ``url`` and ``fields``.
        Url is the url to post to. Fields is a dictionary filled with
        the form fields and respective values to use when submitting the
        post. For example:

        {'url': 'https://mybucket.s3.amazonaws.com
         'fields': {'acl': 'public-read',
                    'key': 'mykey',
                    'signature': 'mysignature',
                    'policy': 'mybase64 encoded policy'}
        }
    NTr��CreateBucketr�r�rOr�Fr��bucketz${filename}zstarts-withz$keyrd)rjr�r�rE)�copyr�r�r�r�r�r�r�r	r�r@r�r�r�rQr�r�)rr��Key�Fields�
Conditionsr�rrdr�r�rEr:�post_presignerr�r�r�r�r�r�rjs                    r!r�r��s���B�F�

�C�
�F��J��J�
�~�������������
�#�:�4�@�@���G�
%�T�%9�:�:�N��i�-�=�=�n�M�M�O�
�
"�
"��f�%�'��#���F�
�$�V�Z�Z��"�%=�%=�>�>�M�
	
�&�&����#0�0�		'�	�	�	�����0�0��'�!��"�#�
1���L����x��(�)�)�)��|�|�M�"�"�(����=�&�#�6K��]�9K�9K�8K�6K�2L�M�N�N�N�N����5�#�,�'�'�'��F�5�M��1�1�!����	2���r#c��|jjdkrdS|jjj}|rc|�dd��rdS|�d��dkr|jjjdkrdS|�d��dkrdSd	S)
N�awsF�use_dualstack_endpoint�us_east_1_regional_endpoint�regionalz	us-east-1�addressing_style�virtualT)r��	partition�config�s3r@r)�client�	s3_configs  r!r�r�_s���
�{���%�%��u���"�%�I��	��=�=�1�5�9�9�	��5��M�M�7�8�8�J�F�F���"�.�+�=�=��5��=�=�+�,�,�	�9�9��5��4r#r)NrfN)NNrf)r�r�r�rr>�
botocore.auth�botocore.awsrequestrr�botocore.compatr�botocore.exceptionsrrr�botocore.utilsr	r
rr
rtr�r�r�r�rkr�r�r�r8r#r!�<module>rs���
�
�
���������������������K�K�K�K�K�K�K�K�'�'�'�'�'�'�����������
9�8�8�8�8�8�8�8�'�&�&�&�&�&�J�J�J�J�J�J�J�J�Z
C
�C
�C
�C
�C
�C
�C
�C
�LH�H�H�3(�3(�3(�3(�lO6�O6�O6�O6�O6�O6�O6�O6�dH�H�H�
AE�L�L�L�L�^J�J�J�
@D�E�E�E�E�P����r#