U
|
I=®d ã @ s® d dl mZ d dlZd dlZd dlZd dlZd dlmZm Z
|
d dlZddl m Z m Z mZmZmZmZmZmZmZmZmZmZmZ ddlmZ ddlm Z ddl m Z dd l m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& dd
|
l'm(Z( dd l)m*Z* dd l+m,Z, dd l-m.Z. ddl/m0Z0 ddl1m2Z2 ddl3m4Z4 ddl5m6Z6m7Z7m8Z8m9Z:m;Z; ddl<m=Z= e j>j?Z?e @eA¡ZBeC ZDG dd deCZEejFejGhZHG dd deEe(ZIG dd deIZJdd ZKdd Z9dS ) é )Úabsolute_importN)ÚerrorÚtimeouté ) ÚClosedPoolErrorÚ ProtocolErrorÚEmptyPoolErrorÚHeaderParsingErrorÚHostChangedErrorÚLocationValueErrorÚ MaxRetryErrorÚ
|
ProxyErrorÚReadTimeoutErrorÚSSLErrorÚ TimeoutErrorÚInsecureRequestWarningÚNewConnectionError)ÚCertificateError)Úsix)Úqueue)Úport_by_schemeÚDummyConnectionÚHTTPConnectionÚHTTPSConnectionÚVerifiedHTTPSConnectionÚ HTTPExceptionÚ BaseSSLError)ÚRequestMethods)Ú HTTPResponse)Úis_connection_dropped)Úset_file_position)Úassert_header_parsing)ÚRetry)ÚTimeout)Úget_hostÚ parse_urlÚUrlÚ_normalize_hostÚ_encode_target)Ú LifoQueuec @ sB e Zd ZdZdZeZd ddZdd Zdd Z d d
|
Z
|
d d Z dS )ÚConnectionPoola;
|
Base class for all connection pools, such as
|
:class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`.
|
|
.. note::
|
ConnectionPool.urlopen() does not normalize or percent-encode target URIs
|
which is useful if your target server doesn't support percent-encoded
|
target URIs.
|
Nc C s0 |s t dt|| jd| _| ¡ | _|| _d S )NzNo host specified.©Úscheme)r r' r, ÚhostÚlowerÚ _proxy_hostÚport)Úselfr- r0 © r2 úYD:\z\workplace\VsCode\pyvenv\venv\Lib\site-packages\pip/_vendor/urllib3/connectionpool.pyÚ__init__N s
|
|
zConnectionPool.__init__c C s dt | j| j| jf S )Nz%s(host=%r, port=%r))ÚtypeÚ__name__r- r0 ©r1 r2 r2 r3 Ú__str__V s zConnectionPool.__str__c C s | S ©Nr2 r7 r2 r2 r3 Ú __enter__Y s zConnectionPool.__enter__c C s | ¡ dS )NF)Úclose)r1 Úexc_typeÚexc_valÚexc_tbr2 r2 r3 Ú__exit__\ s zConnectionPool.__exit__c C s dS )úD
|
Close all pooled connections and disable the pool.
|
Nr2 r7 r2 r2 r3 r; a s zConnectionPool.close)N) r6 Ú
|
__module__Ú __qualname__Ú__doc__r, r) ÚQueueClsr4 r8 r: r? r; r2 r2 r2 r3 r* @ s
|
|
r* c
|
@ s¸ e Zd ZdZdZeZeZdde j
|
ddddddf ddZ dd Z d!d
|
d Z d d Zdd Zdd Zdd Zdd ZedfddZdd Zdd Zd d Zdddd d eddddf
|
d d ZdS )"ÚHTTPConnectionPoolaN
|
Thread-safe connection pool for one host.
|
|
:param host:
|
Host used for this HTTP Connection (e.g. "localhost"), passed into
|
:class:`httplib.HTTPConnection`.
|
|
:param port:
|
Port used for this HTTP Connection (None is equivalent to 80), passed
|
into :class:`httplib.HTTPConnection`.
|
|
:param strict:
|
Causes BadStatusLine to be raised if the status line can't be parsed
|
as a valid HTTP/1.0 or 1.1 status line, passed into
|
:class:`httplib.HTTPConnection`.
|
|
.. note::
|
Only works in Python 2. This parameter is ignored in Python 3.
|
|
:param timeout:
|
Socket timeout in seconds for each individual connection. This can
|
be a float or integer, which sets the timeout for the HTTP request,
|
or an instance of :class:`urllib3.util.Timeout` which gives you more
|
fine-grained control over request timeouts. After the constructor has
|
been parsed, this is always a `urllib3.util.Timeout` object.
|
|
:param maxsize:
|
Number of connections to save that can be reused. More than 1 is useful
|
in multithreaded situations. If ``block`` is set to False, more
|
connections will be created but they will not be saved once they've
|
been used.
|
|
:param block:
|
If set to True, no more than ``maxsize`` connections will be used at
|
a time. When no free connections are available, the call will block
|
until a connection has been released. This is a useful side effect for
|
particular multithreaded situations where one does not want to use more
|
than maxsize connections per host to prevent flooding.
|
|
:param headers:
|
Headers to include with all requests, unless other headers are given
|
explicitly.
|
|
:param retries:
|
Retry configuration to use by default with requests in this pool.
|
|
:param _proxy:
|
Parsed proxy URL, should not be used directly, instead, see
|
:class:`urllib3.connectionpool.ProxyManager`"
|
|
:param _proxy_headers:
|
A dictionary with proxy headers, should not be used directly,
|
instead, see :class:`urllib3.connectionpool.ProxyManager`"
|
|
:param \**conn_kw:
|
Additional parameters are used to create fresh :class:`urllib3.connection.HTTPConnection`,
|
:class:`urllib3.connection.HTTPSConnection` instances.
|
ÚhttpNFr c K s´ t | ||¡ t | |¡ || _t|ts4t |¡}|d krBtj}|| _ || _
|
| |¡| _ || _ | | _|
|
pli | _t|D ]} | j d ¡ qxd| _d| _| | _| jr°| j dg ¡ d S )Nr Úsocket_options)r* r4 r ÚstrictÚ
|
isinstancer# Ú
|
from_floatr" ÚDEFAULTr ÚretriesrD ÚpoolÚblockÚproxyÚ proxy_headersÚxrangeÚputÚnum_connectionsÚ num_requestsÚconn_kwÚ
|
setdefault) r1 r- r0 rH r ÚmaxsizerN ÚheadersrL Ú_proxyÚ_proxy_headersrU Ú_r2 r2 r3 r4 ¬ s(
|
|
|
zHTTPConnectionPool.__init__c C sR | j d7 _ t d| j | j| jp$d¡ | jf | j| j| jj| jd| j }|S )z9
|
Return a fresh :class:`HTTPConnection`.
|
r z(Starting new HTTP connection (%d): %s:%sÚ80)r- r0 r rH )
|
rS ÚlogÚdebugr- r0 Ú ConnectionClsr Úconnect_timeoutrH rU ©r1 Úconnr2 r2 r3 Ú _new_connÝ s üüûz HTTPConnectionPool._new_connc C s d}z| j j| j|d}W nB tk
|
r8 t| dY n& tjk
|
r\ | jrXt| dY nX |rt|rt
|
d| j ¡ | ¡ t |dddkrd}|p| ¡ S ) a
|
Get a connection. Will return a pooled connection if one is available.
|
|
If no connections are available and :prop:`.block` is ``False``, then a
|
fresh connection is returned.
|
|
:param timeout:
|
Seconds to wait before giving up and raising
|
:class:`urllib3.exceptions.EmptyPoolError` if the pool is empty and
|
:prop:`.block` is ``True``.
|
N)rN r zPool is closed.z>Pool reached maximum size and no more connections are allowed.z Resetting dropped connection: %sÚ auto_openr r )rM ÚgetrN ÚAttributeErrorr r ÚEmptyr r r] r^ r- r; Úgetattrrc )r1 r rb r2 r2 r3 Ú _get_connò s$ þ z HTTPConnectionPool._get_connc C s^ z| j j|dd W dS tk
|
r* Y n$ tjk
|
rL t d| j¡ Y nX |rZ| ¡ dS )aä
|
Put a connection back into the pool.
|
|
:param conn:
|
Connection object for the current host and port as returned by
|
:meth:`._new_conn` or :meth:`._get_conn`.
|
|
If the pool is already full, the connection is closed and discarded
|
because we exceeded maxsize. If connections are discarded frequently,
|
then maxsize should be increased.
|
|
If the pool is closed, then the connection will be closed and discarded.
|
F©rN Nz2Connection pool is full, discarding connection: %s) rM rR rf r ÚFullr] Úwarningr- r; ra r2 r2 r3 Ú _put_conn s z HTTPConnectionPool._put_connc C s dS )úU
|
Called right before a request is made, after the socket is created.
|
Nr2 ra r2 r2 r3 Ú_validate_conn5 s z!HTTPConnectionPool._validate_connc C s d S r9 r2 ra r2 r2 r3 Ú_prepare_proxy; s z!HTTPConnectionPool._prepare_proxyc C s2 |t kr| j ¡ S t|tr$| ¡ S t |¡S dS )z< Helper that always returns a :class:`urllib3.util.Timeout` N)Ú_Defaultr ÚclonerI r# rJ )r1 r r2 r2 r3 Ú _get_timeout? s
|
|
|
z HTTPConnectionPool._get_timeoutc C sj t |trt| |d| t|dr>|jtkr>t| |d| dt|ksVdt|krft| |d| dS )zAIs the error actually a timeout? Will raise a ReadTimeout or passú!Read timed out. (read timeout=%s)Úerrnoz timed outzdid not complete (read)N)rI Ú SocketTimeoutr Úhasattrru Ú_blocking_errnosÚstr)r1 ÚerrÚurlÚ timeout_valuer2 r2 r3 Ú_raise_timeoutK s(
|
ÿ ÿÿ ÿz!HTTPConnectionPool._raise_timeoutc K s | j d7 _ | |¡}| ¡ |j|_z| |¡ W n: ttfk
|
rp } z| j|||jd W 5 d}~X Y nX |r|j ||f| n|j
|
||f| |j } t |ddrê| dkrÂt | |d| | tjkrÞ|j t ¡ ¡ n |j | ¡ zjz|jdd}
|
W nT tk
|
rP z | ¡ }
|
W n0 tk
|
rJ } zt |d¡ W 5 d}~X Y nX Y nX W n< tttfk
|
r } z| j||| d W 5 d}~X Y nX t |d d
|
} t d | j | j | j ||| |
|
j |
|
j ¡ zt!|
|
j" W n@ t#tfk
|
r } z tj$d | %|¡| dd W 5 d} ~ X Y nX |
|
S )a
|
Perform a request on a given urllib connection object taken from our
|
pool.
|
|
:param conn:
|
a connection from one of our connection pools
|
|
:param timeout:
|
Socket timeout in seconds for the request. This can be a
|
float or integer, which will set the same timeout value for
|
the socket connect and the socket read, or an instance of
|
:class:`urllib3.util.Timeout`, which gives you more fine-grained
|
control over your timeouts.
|
r )rz r{ r| NÚsockr rt T)Ú bufferingÚ _http_vsn_strzHTTP/?z%s://%s:%s "%s %s %s" %s %sz$Failed to parse headers (url=%s): %s)Úexc_info)&rT rs Ú start_connectr` r ro rv r r} Úrequest_chunkedÚrequestÚ read_timeoutrh r r# ÚDEFAULT_TIMEOUTr~ Ú
|
settimeoutÚsocketÚgetdefaulttimeoutÚ getresponseÚ TypeErrorÚ BaseExceptionr Ú
|
raise_fromÚ SocketErrorr] r^ r, r- r0 ÚstatusÚlengthr! Úmsgr rl Ú _absolute_url) r1 rb Úmethodr{ r ÚchunkedÚhttplib_request_kwÚ timeout_objÚer
Úhttplib_responseÚ http_versionÚhper2 r2 r3 Ú _make_requestd sp
|
ÿ
|
( ÷ üz HTTPConnectionPool._make_requestc C s t | j| j| j|djS )N)r, r- r0 Úpath)r& r, r- r0 r{ )r1 r r2 r2 r3 r É s z HTTPConnectionPool._absolute_urlc C sV | j dkrdS | j d }| _ z |jdd}|r | ¡ q W n tjk
|
rP Y nX dS )r@ NFrj )rM re r; r rg )r1 Úold_poolrb r2 r2 r3 r; Ì s
|
zHTTPConnectionPool.closec C sx | d¡rdS t|\}}}|dk r0t||d}| jrF|sFt |¡}n| js^|t |¡kr^d}|||f| j| j| jfkS )zj
|
Check if the given ``url`` is a member of the same host as this
|
connection pool.
|
ú/TNr+ )Ú
|
startswithr$ r' r0 r re r, r- )r1 r{ r, r- r0 r2 r2 r3 Ú is_same_hostÞ s
|
|
z HTTPConnectionPool.is_same_hostTc K sþ |dkr| j }t|ts*tj||| jd}|
|
dkr>| dd¡}
|
|rX| |¡sXt| ||| d¡rrt
|
t |¡}nt
|
t |j ¡}d}|
|
}| jdkr¨| ¡ }| | j¡ d}d}t|| } ztz| |¡}| j| d}|j|_| jdk oôt|d d }|r| |¡ | j ||||||| d
|
}|
|
s(|nd}|| d < | j j |f| ||d | }d}W nÖ t j k
|
rx t!| d Y n¶ t"t#t$t%t&t't(fk
|
r, } zd}t|t&t(fr¶t'|}n>t|t$t)frÚ| jrÚt*d|}nt|t$t#frôt%d|}|j+|||| t, -¡ d d}| .¡ |}W 5 d}~X Y nX W 5 |sJ|oD| ¡ }d}|rZ| |¡ X |st/ 0d|||¡ | j1|||||||f|| |
|
| | d| S |o¨| 2¡ }|rN|j3dkrÀd}z|j+|||| d}W n, t4k
|
r |j5rú| 6¡ | Y S X | 6¡ | 7|¡ t/ 8d||¡ | j1||||f||||| |
|
| | d| S t9| :d¡}| ;||j3|¡rúz|j+|||| d}W n, t4k
|
r° |j<r¨| 6¡ | Y S X | 6¡ | .|¡ t/ 8d|¡ | j1||||f||||| |
|
| | d| S |S )aá
|
Get a connection from the pool and perform an HTTP request. This is the
|
lowest level call for making a request, so you'll need to specify all
|
the raw details.
|
|
.. note::
|
|
More commonly, it's appropriate to use a convenience method provided
|
by :class:`.RequestMethods`, such as :meth:`request`.
|
|
.. note::
|
|
`release_conn` will only behave as expected if
|
`preload_content=False` because we want to make
|
`preload_content=False` the default behaviour someday soon without
|
breaking backwards compatibility.
|
|
:param method:
|
HTTP request method (such as GET, POST, PUT, etc.)
|
|
:param body:
|
Data to send in the request body (useful for creating
|
POST requests, see HTTPConnectionPool.post_url for
|
more convenience).
|
|
:param headers:
|
Dictionary of custom headers to send, such as User-Agent,
|
If-None-Match, etc. If None, pool headers are used. If provided,
|
these headers completely replace any pool-specific headers.
|
|
:param retries:
|
Configure the number of retries to allow before raising a
|
:class:`~urllib3.exceptions.MaxRetryError` exception.
|
|
Pass ``None`` to retry until you receive a response. Pass a
|
:class:`~urllib3.util.retry.Retry` object for fine-grained control
|
over different types of retries.
|
Pass an integer number to retry connection errors that many times,
|
but no other types of errors. Pass zero to never retry.
|
|
If ``False``, then retries are disabled and any exception is raised
|
immediately. Also, instead of raising a MaxRetryError on redirects,
|
the redirect response will be returned.
|
|
:type retries: :class:`~urllib3.util.retry.Retry`, False, or an int.
|
|
:param redirect:
|
If True, automatically handle redirects (status codes 301, 302,
|
303, 307, 308). Each redirect counts as a retry. Disabling retries
|
will disable redirect, too.
|
|
:param assert_same_host:
|
If ``True``, will make sure that the host of the pool requests is
|
consistent else will raise HostChangedError. When False, you can
|
use the pool on an HTTP proxy and request foreign hosts.
|
|
:param timeout:
|
If specified, overrides the default timeout for this one
|
request. It may be a float (in seconds) or an instance of
|
:class:`urllib3.util.Timeout`.
|
|
:param pool_timeout:
|
If set and the pool is set to block=True, then this method will
|
block for ``pool_timeout`` seconds and raise EmptyPoolError if no
|
connection is available within the time period.
|
|
:param release_conn:
|
If False, then the urlopen call will not release the connection
|
back into the pool once a response is received (but will release if
|
you read the entire contents of the response such as when
|
`preload_content=True`). This is useful if you're not preloading
|
the response's content immediately. You will need to call
|
``r.release_conn()`` on the response ``r`` to return the connection
|
back into the pool. If None, it takes the value of
|
``response_kw.get('preload_content', True)``.
|
|
:param chunked:
|
If True, urllib3 will send the body using chunked transfer
|
encoding. Otherwise, urllib3 will send the body using the standard
|
content-length form. Defaults to False.
|
|
:param int body_pos:
|
Position to seek to in file-like body in the event of a retry or
|
redirect. Typically this won't need to be set because urllib3 will
|
auto-populate the value when needed.
|
|
:param \**response_kw:
|
Additional parameters are passed to
|
:meth:`urllib3.response.HTTPResponse.from_httplib`
|
N)ÚredirectÚdefaultÚpreload_contentTr rF F)r r~ )r ÚbodyrX r Úrequest_method)rM Ú
|
connectionrL z"No pool connections are available.zCannot connect to proxy.zConnection aborted.é )r Ú_poolÚ _stacktracez1Retrying (%r) after connection broken by '%r': %s)r Ú pool_timeoutÚ release_connr Úbody_posi/ ÚGET)Úresponser¨ zRedirecting %s -> %s)rL r¡ Úassert_same_hostr rª r« r r¬ z Retry-Afterz Retry: %s)=rX rI r" Úfrom_intrL re r r
|
r r Ú
|
ensure_strr( r% r{ r, ÚcopyÚupdaterP r r; rm rs ri r` r rO rh rp r Ú ResponseClsÚ from_httplibr rg r r r r r r r r r r Ú incrementÚsysr Úsleepr] rl ÚurlopenÚget_redirect_locationr r Úraise_on_redirectÚ
|
drain_connÚsleep_for_retryr^ ÚboolÚ getheaderÚis_retryÚraise_on_status)r1 r r{ r¤ rX rL r¡ r¯ r rª r« r r¬ Ú response_kwrb Úrelease_this_connrz Ú
|
clean_exitr Úis_new_proxy_connr Ú response_connr® r Úredirect_locationÚhas_retry_afterr2 r2 r3 r¹ ó sP j
|
|
|
|
|
ÿ
|
ùÿüû ù
|
|
|
ÿ ÿùô ó
|
|
üô ó
|
|
üô ózHTTPConnectionPool.urlopen)N)r6 rA rB rC r, r r_ r r´ r# r r4 rc ri rm ro rp rs r} rq r r r; r r¹ r2 r2 r2 r3 rE l sL ;õ
|
1
|
' ÿ
|
eórE c sp e Zd ZdZdZeZddejdddddddddddddddfddZ dd Z
|
d
|
d Z d d Z fddZ ZS )ÚHTTPSConnectionPoolaÛ
|
Same as :class:`.HTTPConnectionPool`, but HTTPS.
|
|
When Python is compiled with the :mod:`ssl` module, then
|
:class:`.VerifiedHTTPSConnection` is used, which *can* verify certificates,
|
instead of :class:`.HTTPSConnection`.
|
|
:class:`.VerifiedHTTPSConnection` uses one of ``assert_fingerprint``,
|
``assert_hostname`` and ``host`` in this order to verify connections.
|
If ``assert_hostname`` is False, no verification is done.
|
|
The ``key_file``, ``cert_file``, ``cert_reqs``, ``ca_certs``,
|
``ca_cert_dir``, ``ssl_version``, ``key_password`` are only used if :mod:`ssl`
|
is available and are fed into :meth:`urllib3.util.ssl_wrap_socket` to upgrade
|
the connection socket into an SSL socket.
|
ÚhttpsNFr c K s\ t j| ||||||||| |
|
f | | | _| | _| | _|| _|| _|| _|| _|| _ || _
|
d S r9 ) rE r4 Úkey_fileÚ cert_fileÚ cert_reqsÚ key_passwordÚca_certsÚ ca_cert_dirÚ ssl_versionÚassert_hostnameÚassert_fingerprint)r1 r- r0 rH r rW rN rX rL rY rZ rË rÌ rÍ rÎ rÏ rÑ rÒ rÓ rÐ rU r2 r2 r3 r4 W s0 õ ôz HTTPSConnectionPool.__init__c
|
C s@ t |tr<|j| j| j| j| j| j| j| j | j
|
d | j |_ |S )z
|
Prepare the ``connection`` for :meth:`urllib3.util.ssl_wrap_socket`
|
and establish the tunnel if proxy is used.
|
)rË rÎ rÌ rÍ rÏ rÐ rÒ rÓ ) rI r Úset_certrË rÎ rÌ rÍ rÏ rÐ rÒ rÓ rÑ ra r2 r2 r3 Ú _prepare_conn s
|
ø
|
z!HTTPSConnectionPool._prepare_connc C s | | j| j| j¡ | ¡ dS )z
|
Establish tunnel connection early, because otherwise httplib
|
would improperly set Host: header to proxy's IP:port.
|
N)Ú
|
set_tunnelr/ r0 rP Úconnectra r2 r2 r3 rp s z"HTTPSConnectionPool._prepare_proxyc
|
C s | j d7 _ t d| j | j| jp$d¡ | jr8| jtkr@td| j}| j}| jdk rf| jj}| jj}| jf ||| j j
|
| j | j | j | jd| j}| |¡S )zB
|
Return a fresh :class:`httplib.HTTPSConnection`.
|
r z)Starting new HTTPS connection (%d): %s:%sÚ443zCCan't connect to HTTPS URL because the SSL module is not available.N)r- r0 r rH rÌ rË rÎ )rS r] r^ r- r0 r_ r r rO r r` rH rÌ rË rÎ rU rÕ )r1 Ú actual_hostÚ actual_portrb r2 r2 r3 rc ¤ s8 üÿ
|
ùø z HTTPSConnectionPool._new_connc s@ t t| |¡ t|dds$| ¡ |js<t d|j t ¡ dS )rn r~ Nz¸Unverified HTTPS request is being made to host '%s'. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings)
|
ÚsuperrÉ ro rh r× Ú is_verifiedÚwarningsÚwarnr- r ra ©Ú __class__r2 r3 ro È s ýùz"HTTPSConnectionPool._validate_conn)r6 rA rB rC r, r r_ r# r r4 rÕ rp rc ro Ú __classcell__r2 r2 rß r3 rÉ B s4 ì
|
1$rÉ c K sR t | \}}}|p t |d¡}|dkr:t|fd|i|S t|fd|i|S dS )a
|
Given a url, return an :class:`.ConnectionPool` instance of its host.
|
|
This is a shortcut for not having to parse out the scheme, host, and port
|
of the url before creating an :class:`.ConnectionPool` instance.
|
|
:param url:
|
Absolute URL string that must include the scheme. Port is optional.
|
|
:param \**kw:
|
Passes additional parameters to the constructor of the appropriate
|
:class:`.ConnectionPool`. Useful for specifying things like
|
timeout, maxsize, headers, etc.
|
|
Example::
|
|
>>> conn = connection_from_url('http://google.com/')
|
>>> r = conn.request('GET', '/')
|
éP rÊ r0 N)r$ r re rÉ rE )r{ Úkwr, r- r0 r2 r2 r3 Úconnection_from_urlÞ s
|
rä c C s. t | |} | d¡r*| d¡r*| dd
} | S )z?
|
Normalize hosts for comparisons and use with sockets.
|
ú[ú]r éÿÿÿÿ)Únormalize_hostr Úendswith)r- r, r2 r2 r3 r' ú s
|
r' )LÚ
|
__future__r ru Úloggingr· rÝ r r r r rv Ú
|
exceptionsr r r r r
|
r r r r r r r r Zpackages.ssl_match_hostnamer Úpackagesr Zpackages.six.movesr r¦ r r r r r r r r r r® r Zutil.connectionr Z util.requestr Z util.responser! Z
|
util.retryr" Z util.timeoutr# Zutil.urlr$ r% r& r' rè r( Z
|
util.queuer) ÚmovesrQ Ú getLoggerr6 r] Úobjectrq r* ÚEAGAINÚ EWOULDBLOCKrx rE rÉ rä r2 r2 r2 r3 Ú<module> sF < $
|
) [
|
