%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /lib/python3/dist-packages/dns/__pycache__/
Upload File :
Create Path :
Current File : //lib/python3/dist-packages/dns/__pycache__/asyncquery.cpython-312.pyc

�

5��e�h�!���dZddlZddlZddlZddlZddlZddlmZmZm	Z	m
Z
mZddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlZ
ddlmZddlmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#e"rddl$Z$e
jJjLZ'd�Z(d>d�Z)	d>de
jTjVd	ee
jXjZe.fd
ede	e/de
e0e/ff
d
�Z1										d?de
jTjVd
e	ede	e/de2de2de	ee
jfjhe
jjjlfde	e.de2de2de2de	e
jXjZdefd�Z7											d@de
jXjZde8de	e/de0de	e8de0de2de2de2de2de	e
jTjVde	e
jTjrde2de
jXjZfd �Z:											dAde
jXjZde8de	e/de0de	e8de0de2de2de2d!e	e
jTjVd"e	e
jTjvde	e
jTjrde2de
e
jXjZe2ffd#�Z<	d>de
jTjvd	ee
jXjZe.fde	e/de
e0e/ffd$�Z=d%�Z>					dBde
jTjvde	e/de2de	ee
jfjhe
jjjlfde	e.de2de
e
jXjZe/ffd&�Z?								dCde
jXjZde8de	e/de0de	e8de0de2de2de	e
jTjvde	e
jTjrde
jXjZfd'�Z@											dDde
jXjZde8de	e/de0de	e8de0de2de2de	e
jTjvde	e
jTjrd)e	e#j�d*e	e8d+ee2e8fde
jXjZfd,�ZBdd-dddddd.d(d(ddej�f
de
jXjZde8de	e/de0de	e8de0de2de2d/e	d0d1e8d2e2d+ee2e8fd3e	e8d4e	d5d6e	e0de
jXjZf d7�ZDddddddej�dfde8d8e
j�j�de	e
jXjZde0de	e/d9e	e/de	e8de0d:ede	e
jTjrddfd;�ZH										dEde
jXjZde8de	e/de0de	e8de0de2de2d<e	e
j�j�d+ee2e8fde	e
jTjrd*e	e8de
jXjZfd=�ZIy)FzTalk to a DNS server.�N)�Any�Dict�Optional�Tuple�Union)�NullContext)
�BadResponse�NoDOH�NoDOQ�UDPMode�_compute_times�_make_dot_ssl_context�_matches_destination�
_remaining�have_doh�sslc��|s|rF|�@|tjk(rd}||fS|tjk(rd}||fStd|����||fSy)Nz0.0.0.0z::zunknown address family )�socket�AF_INET�AF_INET6�NotImplementedError)�af�address�ports   �0/usr/lib/python3/dist-packages/dns/asyncquery.py�
_source_tupler:sl���$��?��V�^�^�#�#��
����	�v���&�������*�,C�B�4�*H�I�I������c�R�|�%|stj�}t||z
d�Sy)Nr)�time�max)�
expiration�nows  r�_timeoutr#Js+������)�)�+�C��:��#�Q�'�'�r�sock�what�destinationr!�returnc���K�t|tjj�r|j	�}tj
�}|j
||t||���d{���}||fS7��w)a�Send a DNS message to the specified UDP socket.

    *sock*, a ``dns.asyncbackend.DatagramSocket``.

    *what*, a ``bytes`` or ``dns.message.Message``, the message to send.

    *destination*, a destination tuple appropriate for the address family
    of the socket, specifying where to send the query.

    *expiration*, a ``float`` or ``None``, the absolute time at which
    a timeout exception should be raised.  If ``None``, no timeout will
    occur.  The expiration value is meaningless for the asyncio backend, as
    asyncio's transport sendto() never blocks.

    Returns an ``(int, float)`` tuple of bytes sent and the sent time.
    N)�
isinstance�dns�message�Message�to_wirer�sendtor#)r$r%r&r!�	sent_time�ns      r�send_udpr1Ss^����.�$����+�+�,��|�|�~���	�	��I��k�k�$��X�j�)�-L�M�M�A�
�y�>��	N�s�A)A6�+A4�,	A6F�ignore_unexpected�one_rr_per_rrset�keyring�request_mac�ignore_trailing�raise_on_truncation�
ignore_errors�queryc���K�d}	|jdt|���d{���\}}t|j|||�s�@t	j�}
	t
jj||||||��}|	r|
�|
j|�s��||
|fS7�u#t
jj$r.}|	r&|
�$|
j|j
��sYd}~�܂d}~wt$r|	rY��wxYw�w)ajRead a DNS message from a UDP socket.

    *sock*, a ``dns.asyncbackend.DatagramSocket``.

    See :py:func:`dns.query.receive_udp()` for the documentation of the other
    parameters, and exceptions.

    Returns a ``(dns.message.Message, float, tuple)`` tuple of the received message, the
    received time, and the address where the message arrived from.
    r�N)r4r5r3r6r7)�recvfromr#r�familyrr*r+�	from_wire�	Truncated�is_response�	Exception)r$r&r!r2r3r4r5r6r7r8r9�wire�from_address�
received_time�r�es                r�receive_udprGqs����0�D�
�%)�]�]�5�(�:�:N�%O�O���|�#��K�K��{�4E�
�
��	�	��
�	����%�%���'�!1� /�$7�
&��A�.�U�.�u�7H�7H��7K���=�,�/�/�A P���{�{�$�$�		���%��)�)�!�)�)�+�6�����	����		�sK�"C7�B�4C7�%B�?C7�C4�9#C"�C7�!C"�"C4�0C7�2C4�4C7�5�q�where�timeoutr�source�source_port�backendc
���K�|j�}
t|�\}}tjj	|�}t||f|�}|
rt
|
�}no|stjj�}t|||�}|j�r||f}nd}|j|tjd||��d{���}|4�d{���}t||
||��d{���t||||||j |j"||	||��d{���\}}}||z
|_|s|j'|�st(�|cddd��d{���S7��7��7�s7�D7�
#1�d{���7swYyxYw�w)aFReturn the response obtained after sending a query via UDP.

    *sock*, a ``dns.asyncbackend.DatagramSocket``, or ``None``,
    the socket to use for the query.  If ``None``, the default, a
    socket is created.  Note that if a socket is provided, the
    *source*, *source_port*, and *backend* are ignored.

    *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
    the default, then dnspython will use the default backend.

    See :py:func:`dns.query.udp()` for the documentation of the other
    parameters, exceptions, and return type of this method.
    Nr)r-r
r*�inet�af_for_address�_lltupler�asyncbackend�get_default_backendr�datagram_connection_required�make_socketr�
SOCK_DGRAMr1rGr4�macrr@r	)rIrJrKrrLrMr2r3r6r7r$rNr8rB�
begin_timer!rr&�cm�stuple�dtuple�srErD�_s                         r�udpr_�sw����8
�9�9�;�D�-�g�6��Z��	���	 �	 ��	'�B��E�4�=�"�-�K��5@��5F����&�&�:�:�<�G��r�6�;�7���/�/�1��T�]�F��F��&�&�r�6�+<�+<�a���P�
P�����Q��q�$��Z�8�8�8�&1�
�����
�I�I�
�E�E����
�'
�!
���M�1���+�������q�!1����)���Q����8��!
�������s~�CE6�E�
E6�E�E6�E!�'E�(0E!�E�,E!�E6�E�E6�E6�E!�E!�E6�!E3�'E*�(E3�/E6�udp_sock�tcp_sockc
���K�	t|||||||||d|	||�
�d{���}
|
dfS7�#tjj$r$t	|||||||||
|�
�d{���7}
|
dfcYSwxYw�w)a�Return the response to the query, trying UDP first and falling back
    to TCP if UDP results in a truncated response.

    *udp_sock*, a ``dns.asyncbackend.DatagramSocket``, or ``None``,
    the socket to use for the UDP query.  If ``None``, the default, a
    socket is created.  Note that if a socket is provided the *source*,
    *source_port*, and *backend* are ignored for the UDP query.

    *tcp_sock*, a ``dns.asyncbackend.StreamSocket``, or ``None``, the
    socket to use for the TCP query.  If ``None``, the default, a
    socket is created.  Note that if a socket is provided *where*,
    *source*, *source_port*, and *backend*  are ignored for the TCP query.

    *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
    the default, then dnspython will use the default backend.

    See :py:func:`dns.query.udp_with_fallback()` for the documentation
    of the other parameters, exceptions, and return type of this
    method.
    TNF)r_r*r+r?�tcp)rIrJrKrrLrMr2r3r6r`rarNr8�responses              r�udp_with_fallbackre�s�����F ��
�������������
�
���%� � �
�� �;�;� � �
 ��
����������
�
�
���$���
 �s=�A-�)�'�)�A-�)�4A*�A �	A*�'A-�)A*�*A-c��BK�t|tjj�r|j	d��}nt|�j
dd�|z}tj�}|j|t||���d{���t|�|fS7��w)z�Send a DNS message to the specified TCP socket.

    *sock*, a ``dns.asyncbackend.StreamSocket``.

    See :py:func:`dns.query.send_tcp()` for the documentation of the other
    parameters, exceptions, and return type of this method.
    T)�prepend_length��bigN)
r)r*r+r,r-�len�to_bytesr�sendallr#)r$r%r!�tcpmsgr/s     r�send_tcprn4s������$����+�+�,����T��2��
�T��#�#�A�u�-��4���	�	��I�
�,�,�v�x�
�I�>�
?�?�?���K��#�#�@�s�B	B�B�Bc��K�d}|dkDrG|j|t|���d{���}|dk(rt�|t|�z
}||z}|dkDr�G|S7�*�w)z|Read the specified number of bytes from stream.  Keep trying until we
    either get the desired amount, or we hit EOF.
    rrN)�recvr#�EOFErrorrj)r$�countr!r]r0s     r�
_read_exactlyrsMsc����	�A�
�!�)��)�)�E�8�J�#7�8�8����8��N���A����
��E���!�)�
�H�
9�s�&A�A�'A�Ac��K�t|d|��d{���}tjd|�\}t|||��d{���}tj�}	tj
j
|||||��}
|
|	fS7�m7�B�w)z�Read a DNS message from a TCP socket.

    *sock*, a ``dns.asyncbackend.StreamSocket``.

    See :py:func:`dns.query.receive_tcp()` for the documentation of the other
    parameters, exceptions, and return type of this method.
    rhN�!H�r4r5r3r6)rs�struct�unpackrr*r+r>)r$r!r3r4r5r6�ldata�lrBrDrEs           r�receive_tcpr{[s�����  ��a��4�4�E��=�=��u�%�D�Q��t�Q�
�3�3�D��I�I�K�M���������)�'�	�	�A�
�}���
5��3�s"�B�B�,B�B�AB�Bc
	���K�|j�}
t|�\}}|r$|j��d{���t|�}
n|tj
j
|�}t|||�}||f}|	stjj�}	|	j|tjd|||��d{���}
|
4�d{���}t||
|��d{���t||||j|j |��d{���\}}||z
|_|j%|�st&�|cddd��d{���S7��7��7��7�n7�D7�#1�d{���7swYyxYw�w)aOReturn the response obtained after sending a query via TCP.

    *sock*, a ``dns.asyncbacket.StreamSocket``, or ``None``, the
    socket to use for the query.  If ``None``, the default, a socket
    is created.  Note that if a socket is provided
    *where*, *port*, *source*, *source_port*, and *backend* are ignored.

    *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
    the default, then dnspython will use the default backend.

    See :py:func:`dns.query.tcp()` for the documentation of the other
    parameters, exceptions, and return type of this method.
    Nr)r-r
�getpeernamerr*rPrQrrSrTrVr�SOCK_STREAMrnr{r4rXrr@r	)rIrJrKrrLrMr3r6r$rNrBrYr!rZrr[r\r]rErDs                    rrcrcys_����4
�9�9�;�D�-�g�6��Z������ � � �5@��5F���X�X�
$�
$�U�
+���r�6�;�7��������&�&�:�:�<�G��&�&���"�"�A�v�v�w�
�
�����Q��q�$�
�+�+�+�#.�
�z�+�Q�Y�Y�����$
�
���M���+����}�}�Q��������	!��
����+��
�������s��4E(�E�BE(�>E	�?
E(�	E�
E(�
E�E
�+E�
E�)E�4E(�E�E(�	E(�E(�
E�E�E(�E%�E�E%�!E(T�ssl_context�server_hostname�verifyc

��ZK�t|�\}
}|rt|�}n�|
�t||�}
tjj|�}t
|||�}||f}|	stjj�}	|	j|tjd||||
|��d{���}|4�d{���}t|�}t||||||||||	�
�d{���}tj�}||
z
|_|cddd��d{���S7�g7�^7�97�#1�d{���7swYyxYw�w)a�Return the response obtained after sending a query via TLS.

    *sock*, an ``asyncbackend.StreamSocket``, or ``None``, the socket
    to use for the query.  If ``None``, the default, a socket is
    created.  Note that if a socket is provided, it must be a
    connected SSL stream socket, and *where*, *port*,
    *source*, *source_port*, *backend*, *ssl_context*, and *server_hostname*
    are ignored.

    *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
    the default, then dnspython will use the default backend.

    See :py:func:`dns.query.tls()` for the documentation of the other
    parameters, exceptions, and return type of this method.
    Nr)r
rrr*rPrQrrSrTrVrr~r#rcr)rIrJrKrrLrMr3r6r$rNrr�r�rYr!rZrr[r\r]rd�end_times                      r�tlsr��sE����< .�g�6��Z���5@��5F����/���H�K�
�X�X�
$�
$�U�
+���r�6�;�7��������&�&�:�:�<�G��&�&�����
������	
�	
�����Q��:�&���
��������
��
�
���9�9�;�� �:�-��
��!���	
����
�������sl�B$D+�&D�'
D+�1D�2D+�5#D�D�#D�<D+�D�	D+�D+�D�D+�D(�D�D(�$D+i�z
/dns-query�clientzhttpx.AsyncClient�path�post�bootstrap_address�resolverzdns.asyncresolver.Resolverr=c
��0K�tst�|r%t|tj�std��|j
�}	tjj|�}d}ddi}|�mtjj|�rN|tjk(rdj|||	�}n)|tjk(rdj|||	�}n|}tjj!�}|�d}d}n|}|}|j#�|dd||||
|�	�}|rt%|�}ntjdd||�
�}|4�d{���}|
rS|j'dt)t+|��d��|j-|j/||��|��d{���}nbt1j2|�j5d
�}|j7�}|j-|j9|d|i��|��d{���}ddd��d{���j:dks|j:dkDr0tdj||j:|j<���tj>jA|j<|jB|jD||��}|jFjI�|_%|jM|�stN�|S#t
$rd}Y���wxYw7���7��U7��7��#1�d{���7swY��xYw�w)a�Return the response obtained after sending a query via DNS-over-HTTPS.

    *client*, a ``httpx.AsyncClient``.  If provided, the client to use for
    the query.

    Unlike the other dnspython async functions, a backend cannot be provided
    in this function because httpx always auto-detects the async backend.

    See :py:func:`dns.query.https()` for the documentation of the other
    parameters, exceptions, and return type of this method.
    z.session parameter must be an httpx.AsyncClientN�acceptzapplication/dns-messagezhttps://{}:{}{}zhttps://[{}]:{}{}rT)�
local_address�http1�http2r��
local_portr�r�r=)r�r�r��	transport)zcontent-typezcontent-length)�headers�content�=r*)r��params��i+z4{} responded with status code {}
Response body: {!r}rv)(rr
r)�httpx�AsyncClient�
ValueErrorr-r*rPrQ�
is_addressrr�formatrrSrT�get_transport_classr�update�strrj�wait_forr��base64�urlsafe_b64encode�rstrip�decode�get�status_coder�r+r>r4r5�elapsed�
total_secondsrr@r	)rIrJrKrrLrMr3r6r�r�r�r�r�r�r=rBrr�r��urlrNr�r�rZ�
the_clientrd�twirerEs                            r�httpsr��s�����:���
�j���):�):�;��I�J�J��9�9�;�D��
�X�X�
$�
$�U�
+���I��2�3�G�	�~�#�(�(�-�-�e�4�
�����#�*�*�5�$��=�C�
�6�?�?�
"�%�,�,�U�D�$�?�C������2�2�4�G�
�~��
��
��
� �
�-��+�+�-�#�����+���	�I��5@��5H��
�
�
��d�6�Y�
�����Z���N�N�$=�&)�#�d�)�n��
�%�-�-�����W�d��C�W���H��+�+�D�1�8�8��>�D��K�K�M�E�$�-�-����s�G�U�E�N��K�W���H�!��,���c�!�X�%9�%9�C�%?��
$�$*�F��x�+�+�X�-=�-=�%�
�	
�	���������	�	��M�M�)�'�	�	�A��
�
�
+�
+�
-�A�F��=�=������H��[��
����L������!�����s��AL�K%�&C+L�K7�L�AL�%K:�&A"L�K=�	L�
L�K?�CL�%K4�0L�3K4�4L�:L�=L�?L�L�L
�L�L�txn_manager�lifetime�udp_modec
���K�|�#tjj|�\}}
ntjj|�}
|jdj
}|tjjk(}|j�}
|j�}tjj|�}t|||�}||f}t|�\}}d}|�r�d}|r&|tjk7rt j"}d}nt j$}d}|	stj&j)�}	|	j+||d||t-|���d{���}|4�d{���|r%|j/||t-|���d{���n<t1j2dt5|��|z}|j7||��d{���tjj9|||
|�5}d}d}|�st|�\}}|�|�||kDr|}|rGt;||f|�}	t-|�}|j=d|��d{���\}}t?|||d�rnC�8tA|d|��d{���} t1jBd| �\}!tA||!|��d{���}|tjjk(}tjDjG||jH|jJd|
|||��}"	|jM|"�}|"jR}|s��|s7|jHr+"jTstjVjYd	��ddd�ddd��d{���|r���yy7��7��7���7���7��87��7��#tjjN$r0|sJ�|tjPk(r�d}d}tj}Y���wxYw#1swY��xYw7�z#1�d{���7swY��xYw�w)
amConduct an inbound transfer and apply it via a transaction from the
    txn_manager.

    *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
    the default, then dnspython will use the default backend.

    See :py:func:`dns.query.inbound_xfr()` for the documentation of
    the other parameters, exceptions, and return type of this method.
    NrTFrur;rh)r4r5�xfr�origin�tsig_ctx�multir3zmissing TSIG)-r*r��
make_query�extract_serial_from_query�question�rdtype�	rdatatype�IXFR�from_wire_originr-rPrQrr
r�NEVERrrWr~rSrTrVr#r.rw�packrjrl�InboundrRr<rrsrxr+r>r4rX�process_message�UseTCP�ONLYr��had_tsig�	exception�	FormError)#rJr�r9rrKr�rLrMr�rN�serialr��is_ixfrr�rBrr[r\r^r!�retry�	sock_type�is_udpr]rm�inbound�doner��mexpirationr&�rwirerCryrzrEs#                                   r�inbound_xfrr�ls�����*
�}��'�'�,�,�[�9�������2�2�5�9��
�^�^�A�
�
%�
%�F���
�
�*�*�*�G�
�
)�
)�
+�F��=�=�?�D�	���	 �	 ��	'�B�
�2�v�{�
3�F��T�]�F�$�X�.�O�Q�
��E�
����x�7�=�=�0��)�)�I��F��*�*�I��F���&�&�:�:�<�G��%�%��	�1�f�f�h�z�.B�
�
���3	B�3	B���h�h�t�V�X�j�-A�B�B�B����T�3�t�9�5��<���i�i��
�3�3�3�������f�f�f�E�-
B�������'5�g�'>�$�Q��"�*�"�.�;��3K�&0���&.��t�}�b�&A��"�&.�{�&;�G�:;�*�*�U�G�:T�4T�1�U�L�3� "�L�+�t� �!&�
#�'4�A�q�+�&F� F��%�}�}�T�5�9���&3�A�q�+�&F� F��$��
�
�(:�(:�:�G����-�-�� %�
�
�$)�I�I� �%�!)�#)�z�)0�.�	�A�	!�&�6�6�q�9�� !�z�z�H�Q�R����q�z�z��-�-�1�1�.�A�A�[-
B�
3	B�3	B��
��3	B��B��4��5U��!G�� F���7�7�>�>�!�%�
�v�#�w�|�|�3�!�#�� $��#*�=�=�� �!��G-
B�-
B��
3	B��3	B�3	B�3	B�s��EO8�M1�
O8�)M4�*O8�-"O#�M7�<O#�M:�
&O#�3AO�M=�'O�-N�.,O�N�AO�9N�
O�9O�O#�O8�&O!�'O8�/O8�4O8�7O#�:O#�=O�O�O�A	O�O�O�O�O	�O#�!O8�#O5�)O,�*O5�1O8�
connectionc	��K�tjjstd��d|_|j�}|r7tjj}
tjj}|}n"tjj|
�\}
}|
�4�d{���}|||	|��4�d{���}|s|j||||�}t|�\}}j|��d{���}|4�d{���|j|d��d{���|jt|���d{���}ddd��d{���tj�}ddd��d{���tjj!||j"|j$||��}ddd��d{���t'z
d�_|j)|�st*�|S7��F7��57��7��7��7��7��#1�d{���7swY��xYw7��#1�d{���7swY��xYw7�m#1�d{���7swY�}xYw�w)aiReturn the response obtained after sending an asynchronous query via
    DNS-over-QUIC.

    *backend*, a ``dns.asyncbackend.Backend``, or ``None``.  If ``None``,
    the default, then dnspython will use the default backend.

    See :py:func:`dns.query.quic()` for the documentation of the other
    parameters, exceptions, and return type of this method.
    zDNS-over-QUIC is not available.rN)�verify_mode�server_nameTrvg)r*�quic�	have_quicr�idr-�null_factory�factories_for_backend�connectr
�make_stream�send�receiverrr+r>r4r5r r@r	)rIrJrKrrLrMr3r6r�r�rNr�rB�cfactory�mfactory�the_connection�context�the_manager�startr!�stream�finishrEs                       rr�r��s����0�8�8����5�6�6��A�D��9�9�;�D���8�8�(�(���8�8�(�(��#��"�x�x�=�=�g�F���8��z�
�
�W����_�
�
	!�
	!�
��!,�!4�!4�U�D�&�+�!V��"0��"9��U�J�)�5�5�g�>�>�F��
D�
D��k�k�$��-�-�-�#�^�^�J�z�,B�C�C��
D�
D��Y�Y�[�F�
	!�
	!�
�K�K�!�!���I�I��
�
�-�+�
"�
��
�
�&��%���
%�A�F��=�=������H�-
��
	!��?��
D��-��C��
D��
D�
D�
D��
	!��
	!�
	!�
	!��
��
�
�
�s�B#H>�%G+�&H>�)H)�9G.�:H)�=9H�6G1�7
H�G3
�H�G;�G5
�!G;�=G7
�>G;�H�
G9�H�&H)�1H�2<H)�.H>�9H'�:2H>�.H)�1H�3H�5G;�7G;�9H�;H
�H�H
�	H�H)�H$	�H�H$	� H)�'H>�)H;�/H2�0H;�7H>)N)
NNFFNrFFFN)NrHNrFFFFNNF)NrHNrFFFNNNF)NFNrF)NrHNrFFNN)N�UNrFFNNNNT)
Nr�NrFFNTNN)K�__doc__r��
contextlibrrwr�typingrrrrr�dns.asyncbackendr*�
dns.exception�dns.inet�dns.message�dns.name�dns.quic�	dns.rcode�dns.rdataclass�
dns.rdatatype�dns.transaction�dns._asyncbackendr�	dns.queryr	r
rrr
rrrrrr�rP�low_level_address_tuplerRrr#rS�DatagramSocketr+r,�bytes�float�intr1�bool�name�Name�tsig�KeyrGr��Backendr_�StreamSocketrernrsr{rc�
SSLContextr��	AF_UNSPECr�r��transaction�TransactionManagerr�r��AsyncQuicConnection�rr�<module>rs	��$�
��
�
��4�4�����������)�������8�8�+�+��
� �#'�	�

�
�
�
)�
)��
����#�#�U�*�
+�������	�
�3��:���@"&�"&�#�"�;?�#&�!� %��+/�:0�

�
�
�
)�
)�:0��#��:0����:0��	:0�
�:0��d�3�8�8�=�=�#�(�(�,�,�6�7�
8�
:0��%��:0��:0��:0��:0��C�K�K�'�'�(�:0�	�:0�@ $�� ��#�"�!� %�6:�26��?�
�{�{���?��?��e�_�?��	?�

�S�M�?��
?��?��?��?��?��3�#�#�2�2�
3�?��c�&�&�.�.�
/�?��?�	�[�[���?�J $�� ��#�"�!�:>�8<�26��A �
�{�{���A ��A ��e�_�A ��	A �

�S�M�A ��
A ��A ��A ��A ��s�'�'�6�6�7�A ��s�'�'�4�4�5�A ��c�&�&�.�.�
/�A ��A ��3�;�;����$�%�A �N#'�$�

�
�
�
'�
'�$�
����#�#�U�*�
+�$����$��3��:��	$�2
� #'�"�;?�#&�!�
�

�
�
�
'�
'���������d�3�8�8�=�=�#�(�(�,�,�6�7�
8�	�
�%����
��3�;�;����%�&��B $�� ��"�!�48�26�5�
�{�{���5��5��e�_�5��	5�

�S�M�5��
5��5��5��3�#�#�0�0�
1�5��c�&�&�.�.�
/�5�	�[�[���5�v $�� ��"�!�48�26�,0�%)�#�C�
�{�{���C��C��e�_�C��	C�

�S�M�C��
C��C��C��3�#�#�0�0�
1�C��c�&�&�.�.�
/�C��#�.�.�)�C��c�]�C�
�$��)��C�	�[�[���C�R $�� ��"�!�,0���#�'+�7;�"�,�,�r
�
�{�{���r
��r
��e�_�r
��	r
�

�S�M�r
��
r
��r
��r
�
�(�)�r
��r
��r
�
�$��)��r
� ��}�r
��3�4�r
�
�S�M�r
� 	�[�[���!r
�p,0��#� $� ���
�
�26�bB��bB����3�3�bB��C�K�K�'�'�(�bB��	bB�
�e�_�bB��u�o�
bB�
�S�M�bB��bB��bB��c�&�&�.�.�
/�bB�
�bB�P $�� ��"�!�9=�#�26�%)�;
�
�{�{���;
��;
��e�_�;
��	;
�

�S�M�;
��
;
��;
��;
�����5�5�6�;
�
�$��)��;
��c�&�&�.�.�
/�;
��c�]�;
�	�[�[���;
r

Zerion Mini Shell 1.0