Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]

a

XC?h+�@s`
dd
gZddl
Z
ddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZ
ddl
mZm
Z

ddlmZ
dZd	Zd
ZdZe��Zdd
�Zdd�ZGdd�de�ZGdd�d�Zdd�ZGdd�de�Zd*dd�
Zdd�ZGdd�de�Z Gd d�de!�Z"Gd!d"�d"e!�Z#e#Z$Gd#d$�d$e#�Z%Gd%d&�d&e!�Z&Gd'd(�d(e&�Z'Gd)d
�d
e"�Z(dS)+�Pool�
ThreadPool�N�
)
�util)�get_context�TimeoutError)
�wait�INIT�RUN�CLOSE�	TERMINATEc

Cstt
|��
S�
N)�list�map�
�args�r�9/opt/alt/python39/lib64/python3.9/multiprocessing/pool.py�mapstar/s
rc

Cstt
�|d
|d��
S)Nrr)r�	itertools�starmaprrrr�starmapstar2s
rc@seZ
dZd
d�Zdd�ZdS)�RemoteTracebackcCs
|
|_dSr
�
�tb)�selfrrrr�__init__:s
zRemoteTraceback.__init__c


Cs|jSr
r�
rrrr�__str__<s
zRemoteTraceback.__str__N)�__name__�
__module__�__qualname__rrrrrrr9s
rc@seZ
dZd
d�Zdd�ZdS)�ExceptionWithTracebackcCs0t�
t|
�
|
|�}d
�|�
}|
|_d||_dS)N�z

"""
%s""")�	traceback�format_exception�type�join�excr)rr(rrrrr@s




zExceptionWithTraceback.__init__c

Cst|j
|jffSr
)�rebuild_excr(rrrrr�
__reduce__Es
z!ExceptionWithTraceback.__reduce__N)rr r!rr*rrrrr"?s
r"cCst|
�
|_
|Sr
)r�	__cause__)r(rrrrr)Hs


r)cs0eZ
dZd
Z�f
dd�Zdd�Zdd�Z�ZS)�MaybeEncodingErrorzVWraps possible unpickleable errors, so they can be
    safely sent through the socket.cs.t|
�
|_
t|�
|_tt|��|j
|j�
dSr
)�reprr(�value�superr,r)rr(r.�
�	__class__rrrTs




zMaybeEncodingError.__init__c

Csd
|j|j
fS)Nz(Error sending result: '%s'. Reason: '%s')r.r(rrrrrYs

�zMaybeEncodingError.__str__c

Csd
|jj
|fS)Nz<%s: %s>)r1rrrrr�__repr__]s
zMaybeEncodingError.__repr__)rr r!�__doc__rrr2�
__classcell__rrr0rr,Ps
r,rFc
Cs�
|du
r(t|t
�r|d
ks(td�|�
�
�
|
j}|j}t|d�rR|j��
|
j	��
|du
rb||�
d}|dus~|�
r�||k�
r�z
|�}	Wn&t
tfy�


t�
d�

Y�
q�Yn0|	dur�t�
d�

�
q�|	\}
}}}
}zd||
i|�
�
f}WnJt�
y4
}
z0|�
r|tu
�
rt||j�}d|f}WYd}~n
d}~00z||
||f�

WnTt�
y�
}
z:t||d
�}t�
d	|�

||
|d|ff�

WYd}~n
d}~00d}	}
}}}
}|d
7}qft�
d
|�

dS)NrzMaxtasks {!r} is not valid�_writerrz)worker got EOFError or OSError -- exitingzworker got sentinel -- exitingTFz0Possible encoding error while sending result: %szworker exiting after %d tasks)�
isinstance�int�AssertionError�format�put�get�hasattrr5�close�_reader�EOFError�OSErrorr�debug�	Exception�_helper_reraises_exceptionr"�
__traceback__r,)�inqueue�outqueue�initializer�initargsZmaxtasks�wrap_exceptionr:r;Z	completed�task�job�
i�funcr�kwds�result�
e�wrappedrrr�workerasN
�































�(


rRc


Cs|�
d
S)z@Pickle-able helper function for use by _guarded_task_generation.Nr)
ZexrrrrC�srCcs2eZ
dZd
Zdd�
�f
dd�
Z�f
dd�Z�ZS)�
_PoolCachez�
    Class that implements a cache for the Pool class that will notify
    the pool management threads every time the cache is emptied. The
    notification is done by the use of a queue that is provided when
    instantiating the cache.
    N�
�notifierc


s|
|_t
�j|i|�
�

dSr
)rUr/r)rrUrrNr0rrr�s

z_PoolCache.__init__cs t��
|
�

|s|j�d�

dSr
)r/�__delitem__rUr:)r�itemr0rrrV�s

z_PoolCache.__delitem__)rr r!r3rrVr4rrr0rrS�s
rSc@s�
eZ
dZd
ZdZedd��
ZdLdd�
Zej	e
fd	d
�
Zdd�Zd
d�Z
edd��
Zedd��
Zdd�Zedd��
Zedd��
Zdd�Zdd�Zdifdd�
ZdMdd �
ZdNd!d"�
ZdOd#d$�
Zd%d&�ZdPd(d)�
ZdQd*d+�
Zdiddfd,d-�
ZdRd.d/�
ZdSd0d1�
ZedTd2d3�
�
Ze d4d5��
Z!ed6d7��
Z"ed8d9��
Z#ed:d;��
Z$d<d=�Z%d>d?�Z&d@dA�Z'dBdC�Z(edDdE��
Z)e dFdG��
Z*dHdI�Z+dJdK�Z,dS)Ur
zS
    Class which supports an async version of applying functions to arguments.
    Tc
Os|j|
i|�
�
Sr
�
�Process)�ctxrrNrrrrY�szPool.ProcessNrcCsg|_t
|_|pt�|_|��
t��|_|j��|_	t
|j	d
�
|_||_||_
||_|
durjt��phd}
|
dkrztd�
�
|du
r�t|�
s�td�
�
|
|_z|��
WnFty�


|jD]}|jdur�|��
q�|jD]}|��
qւYn0|��}tjtj|j|j|j|j|j|j|j |j!|j
|j|j|j"||j	fd�|_#d|j#_$t%|j#_|j#�&�
tjtj'|j|j(|j!|j|jfd�|_)d|j)_$t%|j)_|j)�&�
tjtj*|j!|j+|jfd�|_,d|j,_$t%|j,_|j,�&�
t-j.||j/|j|j |j!|j|j	|j#|j)|j,|jf	dd�|_0t%|_dS)	NrTrz&Number of processes must be at least 1zinitializer must be a callable��targetrT�)rZexitpriority)1�_poolr	�_stater�_ctx�
_setup_queues�queue�SimpleQueue�
_taskqueue�_change_notifierrS�_cache�_maxtasksperchild�_initializer�	_initargs�os�	cpu_count�
ValueError�callable�	TypeError�
_processes�_repopulate_poolrB�exitcode�	terminater'�_get_sentinels�	threadingZThreadr
�_handle_workersrY�_inqueue�	_outqueue�_wrap_exception�_worker_handler�daemonr
�start�
_handle_tasks�
_quick_put�
_task_handler�_handle_results�
_quick_get�_result_handlerrZFinalize�_terminate_pool�
_terminate)r�	processesrGrH�maxtasksperchild�context�
p�	sentinelsrrrr�s~































��





��




�






��z
Pool.__init__cCs>|j|kr:|
d
|��t
|d�
t|dd�du
r:|j�d�

dS)Nz&unclosed running multiprocessing pool )
�sourcere)r_�ResourceWarning�getattrrer:)rZ_warnr
rrr�__del__
s




�
zPool.__del__c
	Cs0|j}
d
|
j
�d|
j�d|j�dt|j�
�d�	S)N�
<�
.z state=z pool_size=�
>)r1r r!r_�lenr^)r�clsrrrr2
s


��z
Pool.__repr__c
Cs |jj
g
}
|jj
g
}g|
�
|�
Sr
)rwr>re)rZtask_queue_sentinelsZself_notifier_sentinelsrrrrs
s




zPool._get_sentinelsc

Csd
d�|D�
S)Nc
Ssg|]}
t|
d�r|
j
�qS)
�sentinel)r<r�)�.0rRrrr�
<listcomp>
s

�z.Pool._get_worker_sentinels.<locals>.<listcomp>r�
Zworkersrrr�_get_worker_sentinels
s
�zPool._get_worker_sentinelsc
CsPd
}
tt
t|�
�
�
D]6}||}|jdu
rt�d|�

|��
d}
||=q|
S)z�Cleanup after any worker processes which have exited due to reaching
        their specified lifetime.  Returns True if any workers were cleaned up.
        FN�cleaning up worker %dT)�reversed�ranger�rqrrAr')�poolZcleanedrLrRrrr�_join_exited_workers
s







zPool._join_exited_workersc

Cs0|�|j
|j|j|j|j|j|j|j|j	|j
�
Sr
)�_repopulate_pool_staticr`rYror^rvrwrhrirgrxrrrrrp.
s






�zPool._repopulate_poolc

Csft|t
|�
�
D]P}
|
|t||||||	fd
�}|j�dd�|_d|_|��
|�|�

t�	d�

qdS)z�Bring the number of pool processes up to the specified number,
        for use after reaping workers which have exited.
        r[rYZ
PoolWorkerTzadded workerN)
r�r�rR�name�replacerzr{�appendrrA)rZrYr�r�rErFrGrHr�rIrL�
wrrrr�7
s




��




zPool._repopulate_pool_staticc

Cs*t�
|�
r&t�||
||||||||	�

d
S)zEClean up any exited workers and start replacements for them.
        N)r
r�r�)
rZrYr�r�rErFrGrHr�rIrrr�_maintain_poolJ
s




�zPool._maintain_poolc

Cs4|j�
�|_|j�
�|_|jjj|_|jjj|_	dSr
)
r`rcrvrwr5�sendr}r>�recvr�rrrrraV
s



zPool._setup_queuesc

Cs|jt
krtd
�
�
dS)NzPool not running)r_r
rlrrrr�_check_running\
s


zPool._check_runningcCs|�|
||��
�S)
zT
        Equivalent of `func(*args, **kwds)`.
        Pool must be running.
        )�apply_asyncr;)rrMrrNrrr�apply`
sz
Pool.applycCs|�|
|t
|���S)
zx
        Apply `func` to each element in `iterable`, collecting the results
        in a list that is returned.
        )�
_map_asyncrr;�rrM�iterable�	chunksizerrrrg
szPool.mapcCs|�|
|t
|���S)
z�
        Like `map()` method but the elements of the `iterable` are expected to
        be iterables as well and will be unpacked as arguments. Hence
        `func` and (a, b) becomes func(a, b).
        )r�rr;r�rrrrn
szPool.starmapcCs|�|
|t
|||�S)
z=
        Asynchronous version of `starmap()` method.
        )r�r�rrMr�r��callback�error_callbackrrr�
starmap_asyncv
s
�zPool.starmap_asyncc
cslz,d
}t|�
D]\}}|
|||f
ifV
qWn:t
yf
}
z"|
|dt|f
ifV
WYd}~n
d}~00dS)z�Provides a generator of tasks for imap and imap_unordered with
        appropriate handling for iterables which throw exceptions during
        iteration.���rN)�	enumeraterBrC)rZ
result_jobrMr�rL�
xrPrrr�_guarded_task_generation~
s




zPool._guarded_task_generationrcCs�|��
|d
kr:t
|�
}|j�|�|j|
|�|jf�

|S|d
krPtd�|�
�
�
t	�
|
||�}t
|�
}|j�|�|jt|�|jf�

dd�|D�
SdS)zP
        Equivalent of `map()` -- can be MUCH slower than `Pool.map()`.
        rzChunksize must be 1+, not {0:n}c
ss|]}
|
D]
}|V
q
qdSr
r�r��chunkrWrrr�	<genexpr>�
�zPool.imap.<locals>.<genexpr>N)r��IMapIteratorrdr:r��_job�_set_lengthrlr9r
�
_get_tasksr�rrMr�r�rO�task_batchesrrr�imap�
s4



��


��



���z	Pool.imapcCs�|��
|d
kr:t
|�
}|j�|�|j|
|�|jf�

|S|d
krPtd�|�
�
�
t	�
|
||�}t
|�
}|j�|�|jt|�|jf�

dd�|D�
SdS)zL
        Like `imap()` method but ordering of results is arbitrary.
        rzChunksize must be 1+, not {0!r}c
ss|]}
|
D]
}|V
q
qdSr
rr�rrrr��
r�z&Pool.imap_unordered.<locals>.<genexpr>N)r��IMapUnorderedIteratorrdr:r�r�r�rlr9r
r�rr�rrr�imap_unordered�
s0



��

�



���zPool.imap_unorderedcCs6|��
t
|||�}|j�|jd
|
||fg
df�

|S)z;
        Asynchronous version of `apply()` method.
        rN)r��ApplyResultrdr:r�)rrMrrNr�r�rOrrrr��
s


zPool.apply_asynccCs|�|
|t
|||�S)
z9
        Asynchronous version of `map()` method.
        )r�rr�rrr�	map_async�
s
�zPool.map_asyncc
Cs�|��
t
|d
�st|�
}|durJtt|�
t|j�
d�\}}|rJ|d7}t|�
dkrZd}t�|
||�}t||t|�
||d�}	|j	�
|�|	j||�df�

|	S)zY
        Helper function to implement map, starmap and their async counterparts.
        �__len__N�rr�
r�)
r�r<r�divmodr�r^r
r��	MapResultrdr:r�r�)
rrMr�Zmapperr�r�r�Zextrar�rOrrrr��
s,









�

���zPool._map_asynccCs"t||d
�
|
�
�s|
��
qdS)N)
�timeout)r�emptyr;)r��change_notifierr�rrr�_wait_for_updates�
s

zPool._wait_for_updatescCstt�
�}|jtks |
r\|jtkr\|�|||||||	|
||�

g|�|�
�
|
�
}|�||�
q|�d�

t	�
d
�

dS)Nzworker handler exiting)rt�current_threadr_r
rr�r�r�r:rrA)r��cache�	taskqueuerZrYr�r�rErFrGrHr�rIr�r��threadZcurrent_sentinelsrrrru�
s


�

zPool._handle_workersc

Cs�
t�
�}t|jd�D�
]
\}}d}z�|D]�}|jtkrDt�d
�


q�z|
|�

Wq(ty�
}	
zH|dd�\}
}z||
�	|d|	f�
Wnt
y�


Yn0WYd}	~	q(d}	~	00q(|r�t�d�

|r�|dnd}||d�

Wd}}}
qWd}}}

�
q,Wd}}}
qd}}}
0qt�d�

z6t�d�

|�d�

t�d	�

|D]}|
d�

�
qPWnt�
y�


t�d
�

Yn0t�d�

dS)Nz'task handler found thread._state != RUN�Fzdoing set_length()rr�ztask handler got sentinelz/task handler sending sentinel to result handlerz(task handler sending sentinel to workersz/task handler got OSError when sending sentinelsztask handler exiting)
rtr��iterr;r_r
rrArB�_set�KeyErrorr:r@)
r�r:rFr�r�r�ZtaskseqZ
set_lengthrJrPrK�idxr�rrrr|sJ



















�
�








zPool._handle_tasksc	Cs�
t�
�}z
|
�}Wn"ttfy4


t�d
�

YdS0|jtkr^|jtksRJd�
�
t�d�

q�|durrt�d�

q�|\}}}z||�	||�
Wnt
y�


Yn0d}}}q|�
rJ|jtk�
rJz
|
�}Wn"ttfy�


t�d
�

YdS0|du�
rt�d�

q�|\}}}z||�	||�
Wnt
�
y:


Yn0d}}}q�t|d��
r�t�d�

z,td�
D]}|j
���
s�
�
q�|
�
�
qjWnttf�
y�


Yn0t�d	t|�
|j�
dS)
Nz.result handler got EOFError/OSError -- exitingzThread not in TERMINATEz,result handler found thread._state=TERMINATEzresult handler got sentinelz&result handler ignoring extra sentinelr>z"ensuring that outqueue is not full�
z7result handler exiting: len(cache)=%s, thread._state=%s)rtr�r@r?rrAr_r
rr�r�r<r�r>�pollr�)rFr;r�r�rJrKrL�objrrrr:s\















































�zPool._handle_resultsccs0t|
�
}
t
t�|
|��
}|s dS||fV
qdSr
)r��tupler�islice)rM�it�sizer�rrrr�vs



zPool._get_tasksc

Cstd
�
�
dS)Nz:pool objects cannot be passed between processes or pickled)
�NotImplementedErrorrrrrr*s

�zPool.__reduce__c

Cs2t�
d
�

|jtkr.t|_t|j_|j�d�

dS)Nzclosing pool)rrAr_r
rryrer:rrrrr=�s







z
Pool.closec

Cst�
d
�

t|_|��
dS)Nzterminating pool)rrArr_r�rrrrrr�s



zPool.terminatec
Csjt�
d
�

|jtkrtd�
�
n|jttfv
r4td�
�
|j��
|j	��
|j
��
|jD]}
|
��
qXdS)Nzjoining poolzPool is still runningzIn unknown state)rrAr_r
rlrrryr'r~r�r^)rr�rrrr'�s
















z	Pool.joincCs@t�
d
�

|j��
|
��r<|j��r<|j��
t�	d�

qdS)Nz7removing tasks from inqueue until task handler finishedr)
rrAZ_rlock�acquire�is_aliver>r�r��time�sleep)rE�task_handlerr�rrr�_help_stuff_finish�s







zPool._help_stuff_finishc
CsX
t�
d
�

t|_|�d�

t|_t�
d�

|�||t|�
�
|��sXt|	�
dkrXtd�
�
t|_|�d�

|�d�

t�
d�

t	�
�|u
r�|��
|r�t|dd�r�t�
d�

|D]}
|
j
dur�|
��
q�t�
d�

t	�
�|u
r�|��
t�
d	�

t	�
�|u
�
r|��
|�
rTt|dd��
rTt�
d
�

|D](}
|
���
r*t�
d|
j�

|
��
�
q*dS)Nzfinalizing poolz&helping task handler/workers to finishrz.Cannot have cache with result_hander not alivezjoining worker handlerrrzterminating workerszjoining task handlerzjoining result handlerzjoining pool workersr�)rrArr_r:r�r�r�r8rtr�r'r<rqrr�pid)r�r�rErFr�r�Zworker_handlerr�Zresult_handlerr�r�rrrr��sB






�

























zPool._terminate_poolc

Cs|��
|Sr
)
r�rrrr�	__enter__�s

zPool.__enter__cCs|��
dSr
)
rr)r�exc_typeZexc_valZexc_tbrrr�__exit__�s
z
Pool.__exit__)NNrNN)
N)
N)NNN)
r)
r)NNN)NNN)
N)-rr r!r3rx�staticmethodrYr�warnings�warnr
r�r2rsr�r�rpr�r�rar�r�rrr�r�r�r�r�r�r�r��classmethodrur|rr�r*r=rrr'r�r�r�r�rrrrr
�sv



�
P



	






�



�


�

�





-

;





5c@sJeZ
dZd
d�Zdd�Zdd�Zddd	�
Zdd
d�
Zdd
�Ze	e
j�
ZdS)r�cCs>|
|_t
��|_tt�
|_|
j|_||_||_	||j|j<dSr
)
r^rtZEvent�_event�next�job_counterr�rf�	_callback�_error_callback)rr�r�r�rrrr�s








zApplyResult.__init__c

Cs
|j�
�Sr
)r�Zis_setrrrr�ready�s
zApplyResult.readyc

Cs|��st
d
�|�
�
�
|jS)Nz{0!r} not ready)r�rlr9�_successrrrr�
successful�s


zApplyResult.successfulNcCs|j�
|
�

dSr
)r�r�rr�rrrr�s
zApplyResult.waitcCs,|�|
�

|�
�st�
|jr"|jS|j�
dSr
)rr�rr��_valuer�rrrr;�s





zApplyResult.getcCsZ|\|_|_
|jr$|jr$|�|j
�

|jr<|js<|�|j
�

|j��
|j|j=d|_dSr
)	r�r�r�r�r��setrfr�r^�rrLr�rrrr�s









zApplyResult._set)
N)
N)
rr r!rr�r�rr;r�r��types�GenericAlias�__class_getitem__rrrrr��s	

	
r�c@seZ
dZd
d�Zdd�ZdS)r�cCshtj
||
||d
�
d|_dg
||_||_|dk
rNd|_|j��
|j|j	=n||t
||�
|_dS)Nr�Tr)r�rr�r��
_chunksize�_number_leftr�r�rfr��bool)rr�r��lengthr�r�rrrrs


�






zMapResult.__init__cCs�|jd
8_|\}}|rv|j
rv||j|
|j|
d
|j�<|jdkr�|jrZ|�|j�

|j|j=|j��
d|_	nL|s�|j
r�d|_
||_|jdkr�|j
r�|�
|j�

|j|j=|j��
d|_	dS)NrrF)r�r�r�r�r�rfr�r�r�r^r�)rrLZsuccess_result�successrOrrrr�&s&























zMapResult._setN)rr r!rr�rrrrr�s
r�c@s:eZ
dZd
d�Zdd�Zddd�
ZeZdd	�Zd
d�ZdS)
r�cCsT|
|_t
�t
���
|_tt�
|_|
j|_t	�
�|_d
|_d|_
i|_||j|j<dS)Nr)r^rtZ	ConditionZLock�_condr�r�r�rf�collections�deque�_items�_index�_length�	_unsorted)rr�rrrrDs










zIMapIterator.__init__c


Cs|Sr
rrrrr�__iter__Os
zIMapIterator.__iter__NcCs�|j��
z|j
��}Wnvty�


|j|jkr<d|_td�|j�|
�

z|j
��}Wn0ty�


|j|jkr|d|_td�t	d�Yn0Yn0Wd�
n1s�0


Y
|\}}|r�|S|�
dSr
)
r�r

�popleft�
IndexErrorr
r
r^�
StopIterationrr)rr�rWr�r.rrrr�Rs&














0


zIMapIterator.nextcCs�|j��
|j
|
krn|j�|�

|j
d
7_
|j
|jvrb|j�|j
�
}|j�|�

|j
d
7_
q,|j��
n
||j|
<|j
|jkr�|j|j	=d|_
Wd�
n1s�0


Y
dS�Nr)r�r
r

r�r
�pop�notifyr
rfr�r^r�rrrr�js













zIMapIterator._setcCsV|j�<
|
|_
|j|j
kr4|j��
|j|j=d|_Wd�
n1sH0


Y
dSr
)r�r
r
r
rfr�r^)rr�rrrr�{s







zIMapIterator._set_length)
N)	rr r!rr
r��__next__r�r�rrrrr�Bs
r�c@seZ
dZd
d�ZdS)r�cCsj|j�P
|j
�|�

|jd
7_|j��
|j|jkrH|j|j=d|_Wd�
n1s\0


Y
dSr	
)	r�r

r�r
r
r
rfr�r^r�rrrr��s








zIMapUnorderedIterator._setN)rr r!r�rrrrr��sr�c@sVeZ
dZd
Zedd��
Zddd�
Zdd	�Zd
d�Zedd
��
Z	edd��
Z
dd�ZdS)rFc
Osd
dlm
}
||
i|�
�
S)NrrX)ZdummyrY)rZrrNrYrrrrY�s
zThreadPool.ProcessNrcCst�
||
||�
dSr
)r
r)rr�rGrHrrrr�s
zThreadPool.__init__c

Cs,t�
�|_t�
�|_|jj|_|jj|_dSr
)rbrcrvrwr:r}r;r�rrrrra�s






zThreadPool._setup_queuesc


Cs
|jj
g
Sr
)rer>rrrrrs�s
zThreadPool._get_sentinelsc


CsgSr
rr�rrrr��sz ThreadPool._get_worker_sentinelscCsDz|jd
d�

qWnt
jy&


Yn0t|�
D]}|�d�

q0dS)NF)
�block)r;rbZEmptyr�r:)rEr�r�rLrrrr��s



zThreadPool._help_stuff_finishcCst�
|�

dSr
)r�r�)rr�r�r�rrrr��s
zThreadPool._wait_for_updates)NNr)rr r!rxr�rYrrarsr�r�r�rrrrr�s








)NrNF))�__all__r�rrjrbrtr�r$r�r�r#rrrZ
connectionrr	r
rr�countr�rrrBrr"r)r,rRrC�dictrS�objectr
r�ZAsyncResultr�r�r�rrrrr�<module>
sN












	
�
-=++E