Ë
    Q5ýjÏK  ã                   ón  — d Z ddlZddlZddlmZ ddlZddlZddlZddl	Zddl
ZddlZddlZddlZddlZddlZddlZddlmZmZmZmZ ej*                  j,                  Zej*                  j0                  Z G d„ dej4                  j6                  «      Zdadefd„Zd(d	„Zej@                  jB                  ejD                  jF                  d
ddddddf	dejH                  jJ                  e&z  dej@                  jN                  e&z  dejD                  jP                  e&z  de)de&dz  de)de*de+dz  de)dz  dejX                  jZ                  dz  dej4                  j\                  fd„Z/de&dededej4                  j\                  fd„Z0ejb                  fdejH                  jJ                  e&z  de*dedej4                  jd                  fd„Z3dejH                  jJ                  e&z  dejH                  jJ                  fd„Z4d)de+ddfd „Z5ejD                  jF                  d
dddfdejH                  jJ                  e&z  dejD                  jP                  de)d!edz  dejX                  jZ                  dz  de+dz  dejH                  jJ                  fd"„Z6d#ejb                  dfd$ejH                  jJ                  e&z  d%e*de*d!edz  def
d&„Z7ej@                  jB                  ejD                  jF                  d
ddddddd#ejb                  dfd$ejH                  jJ                  e&z  dejH                  jJ                  e&z  dej@                  jN                  e&z  dejD                  jP                  e&z  de)de&dz  de)de*de+dz  de)dz  dejX                  jZ                  dz  d%e*de*d!edz  dej4                  j\                  fd'„Z8y)*úAsynchronous DNS stub resolver.é    N)ÚAny)ÚNXDOMAINÚNoAnswerÚ	NoRootSOAÚNotAbsolutec                   óØ  — e Zd ZdZej
                  j                  ej                  j                  dddddddf	dej                  j                  ez  dej
                  j                  ez  dej                  j                  ez  d	ed
edz  dedededz  dedz  dej"                  j$                  dz  dej&                  j(                  fd„Zdedededej&                  j(                  fd„Zej2                  fdej                  j                  ez  dededej&                  j4                  fd„Zdej                  j                  ez  dej                  j                  fd„Zddeddfd„Zy)ÚResolverr   FNTr   ÚqnameÚrdtypeÚrdclassÚtcpÚsourceÚraise_on_no_answerÚsource_portÚlifetimeÚsearchÚbackendÚreturnc           	   ƒ   óŒ  K  — t         j                  j                  | ||||||	«      }|
st         j                  j	                  «       }
t        j
                  «       }	 |j                  «       \  }}|�|S |€J ‚d}|s˜|j                  «       \  }}}|r|
j                  |«      ƒ d{  –—†  |j                  «        | j                  |||j                  «      }	 |j                  ||||||
¬«      ƒ d{  –—† }|j                  |d«      \  }}|�|S |sŒ˜Œ¸7 Œn7 Œ## t        $ r}|j                  d|«      \  }}Y d}~ŒÂd}~ww xY w­w)a³  Query nameservers asynchronously to find the answer to the question.

        :param backend: The async backend. If ``None`` (the default), dnspython
            will use the default backend.
        :type backend: :py:class:`dns.asyncbackend.Backend` or ``None``

        See :py:func:`dns.resolver.Resolver.resolve()` for the
        documentation of the other parameters, exceptions, and return
        type of this method.
        NF)Útimeoutr   r   Úmax_sizer   )ÚdnsÚresolverÚ_ResolutionÚasyncbackendÚget_default_backendÚtimeÚnext_requestÚnext_nameserverÚsleepÚset_random_idÚ_compute_timeoutÚerrorsÚasync_queryÚ	ExceptionÚquery_result)Úselfr   r   r   r   r   r   r   r   r   r   Ú
resolutionÚstartÚrequestÚanswerÚdoneÚ
nameserverÚbackoffr   ÚresponseÚexÚ_s                         úK/root/telegram-saas/.venv/lib/python3.12/site-packages/dns/asyncresolver.pyÚresolvezResolver.resolve/   sk  è ø€ ô0 —\‘\×-Ñ-Ø�%˜ ¨#Ð/AÀ6ó
ˆ
ñ Ü×&Ñ&×:Ñ:Ó<ˆGÜ—	‘	“ˆØØ(×5Ñ5Ó7‰OˆG�Vð
 Ð!à�ØÐ&Ð&Ð&ØˆDÙØ+5×+EÑ+EÓ+GÑ(�
˜C ÙØ!Ÿ-™-¨Ó0×0Ð0Ø×%Ñ%Ô'Ø×/Ñ/°°xÀ×ARÑARÓS�ðØ%/×%;Ñ%;ØØ 'Ø%Ø$/Ø!$Ø 'ð &<ó &÷  �Hð  *×6Ñ6°xÀÓF‘�˜ð
 Ð%Ø!�Mò1 ð ð 1øð ùô !ò Ø(×5Ñ5°d¸BÓ?‘G�A�tÜûðüsT   ‚B$EÂ&DÂ'1EÃD Ã3DÃ4D Ã8EÄEÄD Ä	EÄ"D<Ä7EÄ<EÅEÚipaddrÚargsÚkwargsc              �   ó  K  — i }|j                  |«       t        j                  j                  |d<   t        j                  j
                  |d<    | j                  t        j                  j                  |«      g|¢­i |¤Žƒ d{  –—† S 7 Œ­w)a³  Use an asynchronous resolver to run a reverse query for PTR
        records.

        This utilizes the resolve() method to perform a PTR lookup on the
        specified IP address.

        :param ipaddr: The IPv4 or IPv6 address to look up.
        :type ipaddr: str

        All other arguments that can be passed to the resolve() function
        except for rdtype and rdclass are also supported by this
        function.

        r   r   N)	Úupdater   Ú	rdatatypeÚPTRÚ
rdataclassÚINr4   ÚreversenameÚfrom_address)r(   r5   r6   r7   Úmodified_kwargss        r3   Úresolve_addresszResolver.resolve_addressr   s‚   è ø€ ð( +-ˆØ×Ñ˜vÔ&Ü$'§M¡M×$5Ñ$5ˆ˜Ñ!Ü%(§^¡^×%6Ñ%6ˆ˜	Ñ"Ø!�T—\‘\Ü�O‰O×(Ñ(¨Ó0ð
Ø37ò
Ø;Jñ
÷ 
ð 	
ð 
ús   ‚BBÂBÂBÚnameÚfamilyc              ‹   óÚ  K  — i }|j                  |«       |j                  dd«       t        j                  j                  |d<   |t
        j                  k(  r^ | j                  |t        j                  j                  fi |¤Žƒ d{  –—† }t        j                  j                  j                  |¬«      S |t
        j                  k(  r^ | j                  |t        j                  j                  fi |¤Žƒ d{  –—† }t        j                  j                  j                  |¬«      S |t
        j                  k7  rt!        d|› �«      ‚|j                  dd«      }|j                  d	d«      }t#        j"                  «       }	 | j                  |t        j                  j                  fd
| j%                  |	|«      dœ|¤Žƒ d{  –—† }|j&                  } | j                  |t        j                  j                  fd
| j%                  |	|«      dœ|¤Žƒ d{  –—† }t        j                  j                  j                  ||| ¬«      }
|
st)        |j*                  ¬«      ‚|
S 7 �ŒÚ7 �Œl7 Œ¤7 ŒS­w)aO  Use an asynchronous resolver to query for address records.

        This utilizes the resolve() method to perform A and/or AAAA lookups on
        the specified name.

        :param name: The name to resolve.
        :type name: :py:class:`dns.name.Name` or str
        :param family: The address family. If ``socket.AF_UNSPEC`` (the
            default), both A and AAAA records will be retrieved.
        :type family: int

        All other arguments that can be passed to the resolve() function
        except for rdtype and rdclass are also supported by this
        function.
        r   Nr   )Úv4)Úv6zunknown address family r   Tr   F)r   r   )rF   rE   Ú	add_empty)r0   )r9   Úpopr   r<   r=   ÚsocketÚAF_INETr4   r:   ÚAr   ÚHostAnswersÚmakeÚAF_INET6ÚAAAAÚ	AF_UNSPECÚNotImplementedErrorr   r#   r   r   r0   )r(   rB   rC   r7   r@   rE   rF   r   r   r*   Úanswerss              r3   Úresolve_namezResolver.resolve_nameŽ   s%  è ø€ ð0 +-ˆØ×Ñ˜vÔ&Ø×Ñ˜H dÔ+Ü%(§^¡^×%6Ñ%6ˆ˜	Ñ"à”V—^‘^Ò#Ø#�t—|‘| D¬#¯-©-¯/©/ÑM¸_ÑM×MˆBÜ—<‘<×+Ñ+×0Ñ0°BÐ0Ó7Ð7Ø”v—‘Ò&Ø#�t—|‘| D¬#¯-©-×*<Ñ*<ÑPÀÑP×PˆBÜ—<‘<×+Ñ+×0Ñ0°BÐ0Ó7Ð7Ø”v×'Ñ'Ò'Ü%Ð(?À¸xÐ&HÓIÐIà,×0Ñ0Ð1EÀtÓLÐØ"×&Ñ& z°4Ó8ˆÜ—	‘	“ˆØ�4—<‘<ØÜ�M‰M×Ñð
ð  %Ø×*Ñ*¨5°(Ó;ñ	
ð
 ñ
÷ 
ˆð �x‰xˆØ�4—<‘<ØÜ�M‰M�O‰Oð
ð  %Ø×*Ñ*¨5°(Ó;ñ	
ð
 ñ
÷ 
ˆô —,‘,×*Ñ*×/Ñ/Ø�bÐ(:Ð$:ð 0ó 
ˆñ Ü B§K¡KÔ0Ð0ØˆðI Nùð Qùð
øð
úsL   ‚BI+ÂI!ÂA0I+Ã8I$Ã9C	I+ÇI'ÇAI+ÈI)ÈAI+É$I+É'I+É)I+c              ƒ   óÐ   K  — 	 | j                  |d¬«      ƒ d{  –—† }|j                  }|S 7 Œ# t        j                  j                  $ r}|j                  }Y d}~|S d}~ww xY w­w)a  Determine the canonical name of *name*.

        The canonical name is the name the resolver uses for queries
        after all CNAME and DNAME renamings have been applied.

        :param name: The query name.
        :type name: :py:class:`dns.name.Name` or str
        :rtype: :py:class:`dns.name.Name`

        This method can raise any exception that
        :py:meth:`~dns.asyncresolver.Resolver.resolve` can raise, other than
        :py:exc:`dns.resolver.NoAnswer` and :py:exc:`dns.resolver.NXDOMAIN`.
        F)r   N)r4   Úcanonical_namer   r   r   )r(   rB   r,   rU   Úes        r3   rU   zResolver.canonical_nameÔ   sc   è ø€ ð	.ØŸ<™<¨À˜<ÓG×GˆFØ#×2Ñ2ˆNð Ðð	 Hùä�|‰|×$Ñ$ò 	.Ø×-Ñ-ŒNØÐûð	.üs7   ‚A&„/ š-›/ «A&­/ ¯A#ÁAÁA&ÁA#Á#A&c              ƒ   ó„  K  — 	 t        j                   «       |z   }| j                  t        j                  j                  d|¬«      ƒ d{  –—† }t        j
                  j                  |«      }t        j                  j                  ||«      ƒ d{  –—† }t        |«      dkD  r|| _	        yy7 Œb7 Œ# t        $ r Y yw xY w­w)aÃ  Try to update the resolver's nameservers using Discovery of Designated
        Resolvers (DDR).  If successful, the resolver will subsequently use
        DNS-over-HTTPS or DNS-over-TLS for future queries.

        *lifetime*, a float, is the maximum time to spend attempting DDR.  The default
        is 5 seconds.

        If the SVCB query is successful and results in a non-empty list of nameservers,
        then the resolver's nameservers are set to the returned servers in priority
        order.

        The current implementation does not use any address hints from the SVCB record,
        nor does it resolve addresses for the SCVB target name, rather it assumes that
        the bootstrap nameserver will always be one of the addresses and uses it.
        A future revision to the code may offer fuller support.  The code verifies that
        the bootstrap nameserver is in the Subject Alternative Name field of the
        TLS certficate.
        Úsvcb)r   Nr   )r   r4   r   Ú_ddrÚ_local_resolver_nameÚqueryÚ
_remainingÚ_get_nameservers_asyncÚlenÚnameserversr&   )r(   r   Ú
expirationr,   r   r_   s         r3   Útry_ddrzResolver.try_ddré   s¬   è ø€ ð&
	ÜŸ™› xÑ/ˆJØŸ<™<Ü—‘×-Ñ-¨vÀð (ó ÷ ˆFô —i‘i×*Ñ*¨:Ó6ˆGÜ #§¡× ?Ñ ?ÀÈÓ P×PˆKÜ�;Ó !Ò#Ø#.�Õ ð $ðøð Qùô ò 	Ùð	üsN   ‚C „AB1 Á
B-ÁAB1 ÂB/ÂB1 Â+C Â-B1 Â/B1 Â1	B=Â:C Â<B=Â=C ©g      @)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r:   rK   r<   r=   rB   ÚNameÚstrÚ	RdataTypeÚ
RdataClassÚboolÚintÚfloatr   ÚBackendr   ÚAnswerr4   r   rA   rI   rP   rL   rS   rU   ra   © ó    r3   r
   r
   ,   sÁ  „ Ù)ð
 14·±·±Ø36·>±>×3DÑ3DØØ!Ø#'ØØ!%Ø"Ø37ñA"à�x‰x�}‰}˜sÑ"ðA"ð —‘×'Ñ'¨#Ñ-ðA"ð —‘×*Ñ*¨SÑ0ð	A"ð
 ðA"ð �d‘
ðA"ð !ðA"ð ðA"ð ˜$‘,ðA"ð �t‘ðA"ð ×!Ñ!×)Ñ)¨DÑ0ðA"ð 
�‰×	Ñ	óA"ðF
Øð
Ø"%ð
Ø14ð
à	�‰×	Ñ	ó
ð> ×&Ñ&ñBà�h‰h�m‰m˜cÑ!ðBð ðBð ð	Bð
 
�‰×	!Ñ	!óBðL¨¯©¯©¸Ñ)<ð ÀÇÁÇÁó ñ* eð °dô rq   r
   r   c                  ó>   — t         €
t        «        t         €J ‚t         S )zDGet the default asynchronous resolver, initializing it if necessary.)Údefault_resolverÚreset_default_resolverrp   rq   r3   Úget_default_resolverru     s    € äÐÜÔ ÜÐ'Ð'Ð'ÜÐrq   c                  ó   — t        «       ay)z¤Re-initialize default asynchronous resolver.

    Note that the resolver configuration (i.e. /etc/resolv.conf on UNIX
    systems) will be re-read immediately.
    N)r
   rs   rp   rq   r3   rt   rt     s   € ô  “zÑrq   FTr   r   r   r   r   r   r   r   r   r   c
              ƒ   ób   K  — t        «       j                  | |||||||||	«
      ƒ d{  –—† S 7 Œ­w)a  Query nameservers asynchronously to find the answer to the question.

    This is a convenience function that uses the default resolver
    object to make the query.

    See :py:func:`dns.asyncresolver.Resolver.resolve` for more
    information on the parameters.
    N)ru   r4   )
r   r   r   r   r   r   r   r   r   r   s
             r3   r4   r4     sF   è ø€ ô* &Ó'×/Ñ/ØØØØØØØØØØó÷ ð ð ús   ‚&/¨-©/r5   r6   r7   c              �   óZ   K  —  t        «       j                  | g|¢­i |¤Žƒ d{  –—† S 7 Œ­w)z¦Use a resolver to run a reverse query for PTR records.

    See :py:func:`dns.asyncresolver.Resolver.resolve_address` for more
    information on the parameters.
    N)ru   rA   )r5   r6   r7   s      r3   rA   rA   B  s/   è ø€ ð 8Ô%Ó'×7Ñ7¸ÐPÀÒPÈÑP×PÐPÐPús   ‚"+¤)¥+rB   rC   c              ‹   óV   K  —  t        «       j                  | |fi |¤Žƒ d{  –—† S 7 Œ­w)z¨Use a resolver to asynchronously query for address records.

    See :py:func:`dns.asyncresolver.Resolver.resolve_name` for more
    information on the parameters.
    N)ru   rS   )rB   rC   r7   s      r3   rS   rS   N  s,   è ø€ ð 5Ô%Ó'×4Ñ4°T¸6ÑLÀVÑL×LÐLÐLús   ‚ )¢'£)c              ƒ   óP   K  — t        «       j                  | «      ƒ d{  –—† S 7 Œ­w)z©Determine the canonical name of *name*.

    See :py:func:`dns.resolver.Resolver.canonical_name` for more
    information on the parameters and possible exceptions.
    N)ru   rU   )rB   s    r3   rU   rU   Z  s"   è ø€ ô &Ó'×6Ñ6°tÓ<×<Ð<Ð<úó   ‚&Ÿ$ &r   c              ƒ   óP   K  — t        «       j                  | «      ƒ d{  –—† S 7 Œ­w)a  Try to update the default resolver's nameservers using Discovery of Designated
    Resolvers (DDR).  If successful, the resolver will subsequently use
    DNS-over-HTTPS or DNS-over-TLS for future queries.

    See :py:func:`dns.resolver.Resolver.try_ddr` for more information.
    N)ru   ra   )r   s    r3   ra   ra   d  s"   è ø€ ô &Ó'×/Ñ/°Ó8×8Ð8Ð8úr{   r   c              ƒ   ó”  K  — t        | t        «      r8t        j                  j	                  | t        j                  j
                  «      } |€
t        «       }| j                  «       st        | «      ‚t        j                  «       }|�||z   }nd}	 	 |�|t        j                  «       z
  }|dk  rd}nd}|j                  | t        j                  j                  ||||¬«      ƒ d{  –—† }	|	j                  €J ‚|	j                  j                  | k(  r| S 	 	 | j1                  «       } Œ—7 Œ@# t        t        f$ rå}
t        |
t        «      r |
j!                  «       j#                  | «      }n|
j%                  «       }|r˜|j&                  D ]‰  }|j(                  t        j                  j                  k(  sŒ+|j*                  |k(  sŒ;|j                  j-                  | «      \  }}}|t        j                  j.                  k(  sŒx|j                  c cY d}
~
S  Y d}
~
�Œd}
~
ww xY w# t        j                  j2                  $ r t4        ‚w xY w­w)z´Find the name of the zone which contains the specified name.

    See :py:func:`dns.resolver.zone_for_name` for more
    information on the parameters and possible exceptions.
    Nr   )r   r   )Ú
isinstancerh   r   rB   Ú	from_textÚrootru   Úis_absoluter   r   r4   r:   ÚSOAÚrrsetr   r   Ú	responsesÚgetr0   Ú	authorityr   r   ÚfullcompareÚNAMERELN_SUPERDOMAINÚparentÚNoParentr   )rB   r   r   r   r   r   r*   r`   Ú	rlifetimer,   rV   r0   ÚrrsÚnrr2   s                  r3   Úzone_for_namerŽ   n  sô  è ø€ ô �$œÔÜ�x‰x×!Ñ! $¬¯©¯©Ó6ˆØÐÜ'Ó)ˆØ×ÑÔÜ˜$ÓÐÜ�I‰I‹K€EàÐØ˜XÑ%‰
àˆ
Ø
ð$	,àÐ%Ø&¬¯©«Ñ4�	Ø ’>Ø !‘Ià �	Ø#×+Ñ+ØÜ—‘×!Ñ!ØØØ"Øð ,ó ÷ ˆFð —<‘<Ð+Ð+Ð+Ø�|‰|× Ñ  DÒ(Ø�ð )ð,	Ø—;‘;“=ˆDðS ðùô œ(Ð#ò 	,Ü˜!œXÔ&ØŸ;™;›=×,Ñ,¨TÓ2‘àŸ:™:›<�ÙØ#×-Ñ-ò 
,�CØ—z‘z¤S§]¡]×%6Ñ%6Ó6¸3¿;¹;È'Ó;QØ#&§8¡8×#7Ñ#7¸Ó#=™˜˜A˜qØ¤§¡×!>Ñ!>Ó>ð $'§8¡8ŸOð
,ÿùð	,ûô* �x‰x× Ñ ò 	ÜˆOð	üs€   ‚BIÂAD* Ã'D(Ã(,D* ÄIÄH! Ä'IÄ(D* Ä*HÄ9A8HÆ2HÇ<HÇ?HÈHÈIÈHÈIÈHÈIÈ!$IÉIé5   ÚwhereÚportc              ƒ   óÎ  K  — |€
t        «       }g }t        | t        «      rOt        j                  j                  | «      r0|j                  t        j                  j                  | |«      «       n^|j                  | |«      ƒ d{  –—† }|j                  «       D ]1  }|j                  t        j                  j                  ||«      «       Œ3 t        d¬«      }||_        |S 7 Œ]­w)aë  Make a stub resolver using the specified destination as the full resolver.

    :param where: The domain name or IP address of the full resolver.
    :type where: :py:class:`dns.name.Name` or str
    :param port: The port to use.  Default is 53.
    :type port: int
    :param family: The address family.  Used only when *where* is not an
        address literal.  ``socket.AF_UNSPEC`` (default) uses the first
        address returned; otherwise the first address of the given family.
    :type family: int
    :param resolver: The resolver to use for hostname resolution.  If
        ``None``, the default resolver is used.
    :type resolver: :py:class:`dns.asyncresolver.Resolver` or ``None``
    :rtype: :py:class:`dns.resolver.Resolver`
    NF)Ú	configure)ru   r~   rh   r   ÚinetÚ
is_addressÚappendr.   ÚDo53NameserverrS   Ú	addressesr
   r_   )r�   r‘   rC   r   r_   rR   ÚaddressÚress           r3   Úmake_resolver_atr›   ¶  s¾   è ø€ ð* ÐÜ'Ó)ˆØ9;€KÜ�%œÔ¤#§(¡(×"5Ñ"5°eÔ"<Ø×Ñœ3Ÿ>™>×8Ñ8¸ÀÓEÕFà ×-Ñ-¨e°VÓ<×<ˆØ×(Ñ(Ó*ò 	MˆGØ×ÑœsŸ~™~×<Ñ<¸WÀdÓKÕLð	Mä
˜UÔ
#€CØ!€C„OØ€Jð =ús   ‚BC%ÂC#ÂAC%c              ƒ   ó‚   K  — t        | |||«      ƒ d{  –—† }|j                  |||||||||	|
«
      ƒ d{  –—† S 7 Œ&7 Œ­w)a‘  Query nameservers to find the answer to the question.

    This is a convenience function that calls ``dns.asyncresolver.make_resolver_at()``
    to make a resolver, and then uses it to resolve the query.

    See ``dns.asyncresolver.Resolver.resolve`` for more information on the resolution
    parameters, and ``dns.asyncresolver.make_resolver_at`` for information about the
    resolver parameters *where*, *port*, *family*, and *resolver*.

    If making more than one query, it is more efficient to call
    ``dns.asyncresolver.make_resolver_at()`` and then use that resolver for the queries
    instead of calling ``resolve_at()`` multiple times.
    N)r›   r4   )r�   r   r   r   r   r   r   r   r   r   r   r‘   rC   r   rš   s                  r3   Ú
resolve_atr�   Ù  s[   è ø€ ô: ! ¨¨f°hÓ?×
?€CØ—‘ØØØØØØØØØØó÷ ð ð @øðús   ‚?”;•!?¶=·?½?)r   Nrb   )9rf   rI   r   Útypingr   Údns._ddrr   Údns.asyncbackendÚdns.asyncqueryÚdns.inetÚdns.nameÚdns.nameserverÚ	dns.queryÚdns.rdataclassÚdns.rdatatypeÚdns.resolverÚdns.reversenamer   r   r   r   Ú
asyncqueryÚudpÚ_udpr   Ú_tcpr   ÚBaseResolverr
   rs   ru   rt   r:   rK   r<   r=   rB   rg   rh   ri   rj   rk   rl   rm   r   rn   ro   r4   rA   rP   rL   rS   rU   ra   rŽ   r›   r�   rp   rq   r3   ú<module>r¯      sl  ðñ$ &ã Û Ý ã Û Û Û Û Û Û Û Û Û Û ÷ DÓ Cð ‡~�~×Ñ€Ø
‡~�~×Ñ€ôZˆs�|‰|×(Ñ(ô Zðz Ð ð˜hó ó"ð -0¯M©M¯O©OØ/2¯~©~×/@Ñ/@ØØØ#ØØ!ØØ/3ñ Ø�8‰8�=‰=˜3Ñð à�M‰M×#Ñ# cÑ)ð ð �^‰^×&Ñ&¨Ñ,ð ð 
ð	 ð
 �$‰Jð ð ð ð ð ð �d‰lð ð �4‰Kð ð ×Ñ×%Ñ%¨Ñ,ð ð 	‡\�\×Ñó ðF	QØð	QØð	QØ'*ð	Qà‡\�\×Ñó	Qð .4×-=Ñ-=ñ	MØ
�(‰(�-‰-˜#Ñ
ð	MØ'*ð	MØILð	Mà‡\�\×Ñó	Mð=˜sŸx™xŸ}™}¨sÑ2ð =°s·x±x·}±}ó =ñ9˜5ð 9¨4ó 9ð *-¯©×):Ñ):ØØ $Ø/3Ø!ñEØ
�(‰(�-‰-˜#Ñ
ðEà�^‰^×&Ñ&ðEð 
ðEð ˜‰oð	Eð
 ×Ñ×%Ñ%¨Ñ,ðEð �d‰lðEð 	‡X�X‡]�]óEðT Ø×"Ñ"Ø $ñ	 Ø�8‰8�=‰=˜3Ñð à
ð ð ð ð ˜‰oð	 ð
 ó ðL -0¯M©M¯O©OØ/2¯~©~×/@Ñ/@ØØØ#ØØ!ØØ/3ØØ×"Ñ"Ø $ñ)Ø�8‰8�=‰=˜3Ñð)à�8‰8�=‰=˜3Ñð)ð �M‰M×#Ñ# cÑ)ð)ð �^‰^×&Ñ&¨Ñ,ð	)ð
 
ð)ð �$‰Jð)ð ð)ð ð)ð �d‰lð)ð �4‰Kð)ð ×Ñ×%Ñ%¨Ñ,ð)ð ð)ð ð)ð ˜‰oð)ð 	‡\�\×Ñô)rq   