U ¯ªhâ–ã@sfddlZddlZddlZddlZddlZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZdd lmZmZdd lmZmZmZmZmZmZdd lmZdd lmZmZmZddl m!Z!ddl"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8ddl9m:Z;ddlZ>Gdd„dƒZ?dS)éNé)Ú authenticatoré)Ú MessagePacker)ÚMTProtoPlainSender)Ú RequestState)Ú MTProtoState)Ú TLRequest)ÚhelpersÚutils)ÚBadMessageErrorÚInvalidBufferErrorÚAuthKeyNotFoundÚ SecurityErrorÚTypeNotFoundErrorÚrpc_message_to_error)Ú BinaryReader)Ú RpcResultÚMessageContainerÚ GzipPacked)Ú LogOutRequest)Ú PingRequestÚDestroySessionRequestÚDestroyAuthKeyRequest)ÚMsgsAckÚPongÚ BadServerSaltÚBadMsgNotificationÚ FutureSaltsÚMsgNewDetailedInfoÚNewSessionCreatedÚMsgDetailedInfoÚ MsgsStateReqÚ MsgsStateInfoÚ MsgsAllInfoÚ MsgResendReqÚuploadÚDestroySessionOkÚDestroySessionNoneÚDestroyAuthKeyOkÚDestroyAuthKeyNoneÚDestroyAuthKeyFail)Útypes)ÚAuthKey)Ú retry_rangec@sŽeZdZdZddddddddœdd„Zd d „Zd d „Zd d„Zdd„ZdOdd„Z e dd„ƒZ dd„Z dd„Z dd„ZdPdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„Zeejjejjej jej!jej"jej#jfƒeej$j%jej$j&jej$j'jfƒd4œd5d6„Z(d7d8„Z)d9d:„Z*d;d<„Z+d=d>„Z,d?d@„Z-dAdB„Z.dCdD„Z/dEdF„Z0dGdH„Z1dIdJ„Z2dKdL„Z3dMdN„Z4dS)QÚ MTProtoSenderaô MTProto Mobile Protocol sender (https://core.telegram.org/mtproto/description). This class is responsible for wrapping requests into `TLMessage`'s, sending them over the network and receiving them in a safe manner. Automatic reconnection due to temporary network issues is a concern for this class as well, including retry of messages that could not be sent successfully. A new authorization key will be generated on connection if no other key exists yet. érTN)ÚretriesÚdelayÚauto_reconnectÚconnect_timeoutÚauth_key_callbackÚ updates_queueÚauto_reconnect_callbackc &Csrd|_||_|t|_||_||_||_||_||_||_ | |_ t   ¡|_ d|_d|_d|_t ¡ ¡|_|j d¡d|_d|_|pŒtdƒ|_t|j|jd|_t|j|jd|_i|_tƒ|_ t!j"dd|_#t$j%|j&t'j%|j(t)j%|j*t+j%|j,t-j%|j.t/j%|j0t1j%|j2t3j%|j4t5j%|j6t7j%|j8t9j%|j:t;j%|jj%|j?t@j%|jAtBj%|jAtCj%|jDtEj%|jDtFj%|jDi|_GdS)NF©Úloggersé )Úmaxlen)HÚ _connectionÚ_loggersÚ__name__Ú_logÚ_retriesÚ_delayÚ_auto_reconnectÚ_connect_timeoutÚ_auth_key_callbackÚ_updates_queueÚ_auto_reconnect_callbackÚasyncioÚLockÚ _connect_lockÚ_pingÚ_user_connectedÚ _reconnectingr Úget_running_loopÚ create_futureÚ _disconnectedÚ set_resultÚ_send_loop_handleÚ_recv_loop_handler-Úauth_keyrÚ_staterÚ _send_queueÚ_pending_stateÚsetÚ _pending_ackÚ collectionsÚdequeÚ _last_acksrÚCONSTRUCTOR_IDÚ_handle_rpc_resultrÚ_handle_containerrÚ_handle_gzip_packedrÚ _handle_pongrÚ_handle_bad_server_saltrÚ_handle_bad_notificationr!Ú_handle_detailed_inforÚ_handle_new_detailed_infor Ú_handle_new_session_createdrÚ _handle_ackrÚ_handle_future_saltsr"Ú_handle_state_forgottenr%r$Ú_handle_msg_allr'Ú_handle_destroy_sessionr(r)Ú_handle_destroy_auth_keyr*r+Ú _handlers) ÚselfrSr9r1r2r3r4r5r6r7©rnúB/tmp/pip-unpacked-wheel-c81u5j2r/telethon/network/mtprotosender.pyÚ__init__0s~   ízMTProtoSender.__init__c Ãst|j4IdHšV|jr6|j d¡W5QIdHR£dS||_| ¡IdHd|_W5QIdHR£dSQIdHRXdS)zV Connects to the specified given connection using the given auth key. NzUser is already connected!FT)rIrKr?Úinfor<Ú_connect)rmÚ connectionrnrnroÚconnect|s zMTProtoSender.connectcCs|jS©N)rK©rmrnrnroÚ is_connectedŠszMTProtoSender.is_connectedcCs|j o|jdk o|jjSru)rLr<Ú _connectedrvrnrnroÚ_transport_connecteds ÿýz"MTProtoSender._transport_connectedcÃs| ¡IdHdS)z‘ Cleanly disconnects the instance from the network, cancels all pending requests, and closes the send and receive loops. N)Ú _disconnectrvrnrnroÚ disconnect”szMTProtoSender.disconnectFc Csú|jstdƒ‚t |¡snz t|ƒ}Wn6tjk rZ}z|j d||¡‚W5d}~XYnX|j  |¡|j Sg}g}d}|D]f}zt||oŽ|d}Wn6tjk rÌ}z|j d||¡‚W5d}~XYnX|  |¡|  |j ¡q~|j  |¡|SdS)a­ This method enqueues the given request to be sent. Its send state will be saved until a response arrives, and a ``Future`` that will be resolved when the response arrives will be returned: .. code-block:: python async def method(): # Sending (enqueued for the send loop) future = sender.send(request) # Receiving (waits for the receive loop to read the result) result = await future Designed like this because Telegram may send the response at any point, and it can send other items while one waits for it. Once the response for this future arrives, it is set with the received result, quite similar to how a ``receive()`` call would otherwise work. Since the receiving part is "built in" the future, it's impossible to await receive a result that was never sent. z'Cannot send requests while disconnectedz#Request caused struct.error: %s: %sN)Úafter) rKÚConnectionErrorr Z is_list_likerÚstructÚerrorr?rUÚappendÚfutureÚextend)rmÚrequestZorderedÚstateÚeÚstatesZfuturesÚreqrnrnroÚsend›s.     zMTProtoSender.sendcCs t |j¡S)a Future that resolves when the connection to Telegram ends, either by user action or in the background. Note that it may resolve in either a ``ConnectionError`` or any other unexpected error that could not be handled. )rGZshieldrOrvrnrnroÚ disconnectedÑs zMTProtoSender.disconnectedc Ãsv|j d|j¡d}t|jƒD]²}|s<| |¡IdH}|sr{ÚsleeprAr}Úformatrzr rMÚdebugÚ create_taskÚ _send_looprQÚ _recv_looprRrOÚdonerN)rmÚ connectedÚattemptr…ZlooprnrnrorrÞsFÿ    zMTProtoSender._connectc Ãs”z6|j d|¡|jj|jdIdH|j d¡WdSttjfk rŽ}z4|j d|t |ƒj |¡t  |j ¡IdHWY¢dSd}~XYnXdS)NzConnection attempt %d...)ÚtimeoutzConnection success!Tz'Attempt %d at connecting failed: %s: %sF) r?r“r<rtrCrrGrŽrrr>r‘rA)rmr™r…rnrnror‹s ÿzMTProtoSender._try_connectc Ãs²t|j|jd}zN|j d|¡t |¡IdH\|j_|j _ |j rN|  |j¡|j d¡WdSt t fk r¬}z,|j d||¡t |j¡IdHWY¢dSd}~XYnXdS)Nr8zNew auth_key attempt %d...zauth_key generation success!Tz%Attempt %d at new auth_key failed: %sF)rr<r=r?r“rZdo_authenticationrSÚkeyrTZ time_offsetrDrÚAssertionErrorrrGr‘rA)rmr™Úplainr…rnrnrorŒ%sÿ  zMTProtoSender._try_gen_auth_keyc Ãs|jdkr|j d¡dS|j d|j¡d|_z |j d¡|j ¡IdHW5|j dt|jƒ¡|j ¡D]*}|r|j  ¡s|j  |¡qp|j  ¡qp|j  ¡t j|j|j|jdIdH|j d|j¡d|_X|jr|j  ¡s|r|j  |¡n |j d¡dS)Nz.Not disconnecting (already have no connection)zDisconnecting from %s...Fz#Cancelling %d pending message(s)...©Zsend_loop_handleZrecv_loop_handlezDisconnection from %s complete!zClosing current connection...)r<r?rqrKr“ÚlenrVÚvaluesrr—Ú set_exceptionÚcancelÚclearr Ú_cancelrQrRr{rOrP)rmrr„rnrnrorz:s2     ý zMTProtoSender._disconnectc Ãs |j d¡|j ¡IdHtj|j|j|jdIdHd|_|j   ¡|j rT|j nd}d}d}t |ddD]Z}z| ¡IdHWnttjfk rØ}z.|}|j d||jj¡t |j¡IdHW5d}~XYqltk rD}zNt|tƒr&|jd kr&|j d ¡tƒ}d}WY¢qÎn|j d |¡W5d}~XYqltk rŠ}z(|}|j d |¡t |j¡IdHW5d}~XYqlX|j |j  !¡¡|j  "¡|j#rÂt $¡ %| #¡¡qÎqld}|s|j &d |¡|rò| 'd¡nd}|j(|dIdHdS)z: Cleanly disconnects and then reconnects. z0Closing current connection to begin reconnect...NržFrT)Z force_retryz&Failed reconnection attempt %d with %sé”úUServer does not know about the current auth key; the session may need to be recreatedúInvalid buffer %sz/Unexpected exception reconnecting on attempt %dz(Automatic reconnection failed %d time(s)rŠ))r?rqr<r{r r¤rQrRrLrTÚresetrBr@r.rrrrGrŽÚ __class__r>r‘rAÚ BufferErrorÚ isinstancer ÚcoderrÚ ExceptionÚ exceptionrUr‚rVr r£rFrMr”rÚwith_tracebackrz)rmZ last_errorr1r™Úokr…rrnrnroÚ _reconnect\sZ ý  ÿ" ÿ$ zMTProtoSender._reconnectcCs*|jr&|js&d|_t ¡ | |¡¡dS)z(Starts a reconnection in the background.TN)rKrLr rMr”r±)rmrrnrnroÚ_start_reconnect¡s zMTProtoSender._start_reconnectcCs.|jdkr ||_| t|ƒ¡n | d¡dS)zŒ Send a keep-alive ping. If a pong for the last ping was not received yet, this means we're probably not connected. N)rJrˆrr²)rmZrnd_idrnrnroÚ_keepalive_ping°s zMTProtoSender._keepalive_pingc ÃsN|jrJ|jsJ|jrJttt|jƒƒƒ}|j |¡|j |¡|j  ¡|j   d¡|j  ¡IdH\}}|spq|j   dt |ƒt |ƒ¡|j |¡}|D]J}t|tƒsÀt|jtƒrâ||j|j<q˜|D]}t|jtƒrÄ||j|j<qÄq˜z|j |¡IdHWn@tk r:}z |j  d¡| |¡WY¢dSd}~XYnX|j   d¡qdS)zÊ This loop is responsible for popping items off the send queue, encrypting them, and sending them over the network. Besides `connect`, only this method ever sends data. zWaiting for messages to send...Nz0Encrypting %d message(s) in %d bytes for sendingz$Connection closed while sending dataz,Encrypted messages put in a queue to be sent)rKrLrXrrÚlistrUr€r[r£r?r“ÚgetrŸrTZencrypt_message_datar«rƒr rVÚmsg_idr<rˆrrqr²)rmÚackÚbatchÚdatar„Úsr…rnrnror•¾s:    ÿ      zMTProtoSender._send_loopc ÃsÆ|jrÂ|jsÂ|j d¡z|j ¡IdH}Wntjk rJ‚Ynìttj fk rŽ}z"|j  d|¡|  |¡WY¢dSd}~XYn¨t k rö}zL|j dkrÊ|j d|¡|j|dIdHn|j d¡|  |¡WY¢dSd}~XYn@tk r4}z |j d¡|  |¡WY¢dSd}~XYnXz |j |¡}|dkrRWqWn0tk r–}z |j  d |j|j¡WY¢qW5d}~XYnòtk rÎ}z|j d |¡WY¢qW5d}~XYnºtk rH}z\t|t ƒr|j d kr|j  d ¡|jtƒdIdHn|j d |¡|  |¡WY¢dSd}~XYn@tk r†}z |j d¡|  |¡WY¢dSd}~XYnXz| |¡IdHWqtk r¾|j d¡YqXqdS)zÕ This loop is responsible for reading all incoming responses from the network, decrypting and handling or dispatching them. Besides `connect`, only this method ever receives data. z#Receiving items from the network...Nz*Connection closed while receiving data: %si­z3Server indicated flood error at transport level: %srŠzServer sent invalid bufferz$Unhandled error while receiving dataz&Type %08x not found, remaining data %rz5Security error while unpacking a received message: %sr¥r¦r§z%Unhandled error while decrypting dataz%Unhandled error while processing msgs)rKrLr?r“r<ÚrecvrGZCancelledErrorrZIncompleteReadErrorrqr²r r¬rrzr®r­rTZdecrypt_message_datarZinvalid_constructor_idÚ remainingrrªr«rÚ_process_message)rmÚbodyr…Úmessagernrnror–ñsf          ÿÿ    zMTProtoSender._recv_loopcÃs4|j |j¡|j |jj|j¡}||ƒIdHdS)z¶ Adds the given message to the list of messages that must be acknowledged and dispatches control to different ``_handle_*`` method based on its type. N)rXÚaddr¶rlrµÚobjr\Ú_handle_update)rmr¿Úhandlerrnrnror½2s  ÿzMTProtoSender._process_messagecs|ˆj |d¡}|r|gSg}ˆj ¡D]}|j|kr&| |j¡q&|rX‡fdd„|DƒSˆjD]}|j|kr^|gSq^gS)zš Pops the states known to match the given ID from pending messages. This method should be used when the response isn't specific. Ncsg|]}ˆj |¡‘qSrn)rVÚpop)Ú.0ÚxrvrnroÚ Msz-MTProtoSender._pop_states..)rVrÄr Z container_idr€r¶r[)rmr¶r„Zto_popr·rnrvroÚ _pop_states=s    zMTProtoSender._pop_statesc Ãsp|j}|j |jd¡}|j d|j¡|s¢|jrB|j d|j¡n\z2t|j ƒ}t |  ¡t j ƒshtdƒ‚W5QRXWn(ttfk rœ|j d|j ¡YnXdS|jræt|j|jƒ}|j tt|jgƒƒ¡|j ¡sä|j |¡n†z&t|j ƒ}|j |¡}W5QRXWn<tk rH}z|j ¡s8|j |¡W5d}~XYn$X| |¡|j ¡sl|j |¡dS)zÐ Handles the result for Remote Procedure Calls: rpc_result#f35c6d01 req_msg_id:long result:bytes = RpcResult; This is where the future results for sent requests are set. Nz"Handling RPC result for message %dz)Received error without parent request: %szNot an upload.Filez,Received response without parent request: %s)rÁrVrÄÚ req_msg_idr?r“rrqrr¾r«Ú tgread_objectr&ZFileÚ ValueErrorrrrƒrUr€rrr¶rÚ cancelledr¡Z read_resultr­Ú_store_own_updatesrP)rmr¿Z rpc_resultr„ÚreaderrÚresultr…rnrnror]Us>ÿ  ÿ     z MTProtoSender._handle_rpc_resultcÃs.|j d¡|jjD]}| |¡IdHqdS)z¢ Processes the inner messages of a container with many of them: msg_container#73f1f8dc messages:vector<%Message> = MessageContainer; zHandling containerN)r?r“rÁÚmessagesr½)rmr¿Z inner_messagernrnror^‹s  zMTProtoSender._handle_containerc ÃsB|j d¡t|jjƒ }| ¡|_| |¡IdHW5QRXdS)zˆ Unpacks the data from a gzipped object and processes it: gzip_packed#3072cfa1 packed_data:bytes = Object; zHandling gzipped dataN)r?r“rrÁr¹rÊr½)rmr¿rÎrnrnror_•s  z!MTProtoSender._handle_gzip_packedcÃsjz|jjdkst‚Wn.tk rB|j d|jjj|j¡YdSX|j d|jjj¡|j  |j¡dS)Nl¬*êz0Note: %s is not an update, not dispatching it %szHandling update %s) rÁZSUBCLASS_OF_IDrœr?rr©r>r“rEÚ put_nowait©rmr¿rnrnror sýzMTProtoSender._handle_update)Ú _update_idsÚ_update_like_idscCsºz |j|kr d|_|j |¡n~|j|krxt t g|j|j¡t j t   d¡dd…Žj t j jd¡}d|_|j |¡n&|jtjjjkržd|j_|j |j¡Wntk r´YnXdS)NTré)Útzinfo)r\Z_self_outgoingrErÑÚ_tlÚ UpdateShortZUpdateDeleteMessagesZptsZ pts_countÚdatetimeÚtimeÚgmtimeÚreplaceÚtimezoneÚutcrÐZ InvitedUsersZupdatesÚAttributeError)rmrÁrÓrÔZupdrnrnrorÍ®s   "þz MTProtoSender._store_own_updatescÃsL|j}|j d|j¡|j|jkr(d|_|j |jd¡}|rH|j  |¡dS)zº Handles pong results, which don't come inside a ``rpc_result`` but are still sent through a request: pong#347773c5 msg_id:long ping_id:long = Pong; zHandling pong for message %dN) rÁr?r“r¶rJZping_idrVrÄrrP)rmr¿Zpongr„rnrnror`Õs zMTProtoSender._handle_pongcÃsN|j}|j d|j¡|j|j_| |j¡}|j  |¡|j dt |ƒ¡dS)a Corrects the currently used server salt to use the right value before enqueuing the rejected message to be re-sent: bad_server_salt#edab447b bad_msg_id:long bad_msg_seqno:int error_code:int new_server_salt:long = BadMsgNotification; z Handling bad salt for message %dz%d message(s) will be resentN) rÁr?r“Ú bad_msg_idZnew_server_saltrTÚsaltrÈrUr‚rŸ)rmr¿Zbad_saltr†rnrnroraås    z%MTProtoSender._handle_bad_server_saltcÃsÈ|j}| |j¡}|j d|¡|jdkrJ|jj|jd}|j  d|¡n\|jdkrf|jj d7_ n@|jdkr‚|jj d8_ n$|D]}|j   t |j|jƒ¡q†d S|j |¡|j d t|ƒ¡d S) a Adjusts the current state to be correct based on the received bad message notification whenever possible: bad_msg_notification#a7eff811 bad_msg_id:long bad_msg_seqno:int error_code:int = BadMsgNotification; zHandling bad msg %s)éé)Zcorrect_msg_idz-System clock is wrong, set time offset to %dsé é@é!râNz)%d messages will be resent due to bad msg)rÁrÈràr?r“Z error_coderTZupdate_time_offsetr¶rqZ _sequencerr¡r rƒrUr‚rŸ)rmr¿Zbad_msgr†Útor„rnrnrorbõs*  ÿ   ÿ ÿz&MTProtoSender._handle_bad_notificationcÃs&|jj}|j d|¡|j |¡dS)zÏ Updates the current status with the received detailed information: msg_detailed_info#276d3ec6 msg_id:long answer_msg_id:long bytes:int status:int = MsgDetailedInfo; z%Handling detailed info for message %dN©rÁZ answer_msg_idr?r“rXrÀ©rmr¿r¶rnrnrorcsz#MTProtoSender._handle_detailed_infocÃs&|jj}|j d|¡|j |¡dS)zÇ Updates the current status with the received detailed information: msg_new_detailed_info#809db6df answer_msg_id:long bytes:int status:int = MsgDetailedInfo; z)Handling new detailed info for message %dNrèrérnrnrord%sz'MTProtoSender._handle_new_detailed_infocÃs|j d¡|jj|j_dS)zÉ Updates the current status with the received session information: new_session_created#9ec20908 first_msg_id:long unique_id:long server_salt:long = NewSession; zHandling new session createdN)r?r“rÁZ server_saltrTrárÒrnrnrore1s z)MTProtoSender._handle_new_session_createdcÃsd|j}|j dt|jƒ¡|jD]>}|j |¡}|r t|jt ƒr |j|=|j   ¡s |j   d¡q dS)a3 Handles a server acknowledge about our messages. Normally these can be ignored except in the case of ``auth.logOut``: auth.logOut#5717da40 = Bool; Telegram doesn't seem to send its result so we need to confirm it manually. No other request is known to have this behaviour. Since the ID of sent messages consisting of a container is never returned (unless on a bad notification), this method also removes containers messages when any of their inner messages are acknowledged. zHandling acknowledge for %sTN) rÁr?r“ÚstrÚmsg_idsrVrµr«rƒrrrÌrP)rmr¿r·r¶r„rnrnrorf<s   zMTProtoSender._handle_ackcÃs6|j d|j¡|j |jd¡}|r2|j |j¡dS)zõ Handles future salt results, which don't come inside a ``rpc_result`` but are still sent through a request: future_salts#ae500895 req_msg_id:long now:int salts:vector = FutureSalts; z$Handling future salts for message %dN)r?r“r¶rVrÄrrPrÁ)rmr¿r„rnrnrorgTs z"MTProtoSender._handle_future_saltscÃs.|j tt|jtdƒt|jjƒdƒ¡dS)z Handles both :tl:`MsgsStateReq` and :tl:`MsgResendReq` by enqueuing a :tl:`MsgsStateInfo` to be sent at a later point. r)rÉrqN) rUr€rr#r¶ÚchrrŸrÁrërÒrnrnrorhcs ÿz%MTProtoSender._handle_state_forgottencÃsdS)zC Handles :tl:`MsgsAllInfo` by doing nothing (yet). NrnrÒrnrnrorilszMTProtoSender._handle_msg_allcÃs\|j ¡D](\}}t|jtƒr |jj|jjkr q8q dS|j|=|j ¡sX|j  |j¡dS)z Handles both :tl:`DestroySessionOk` and :tl:`DestroySessionNone`. It behaves pretty much like handling an RPC result. N) rVÚitemsr«rƒrZ session_idrÁrrÌrP©rmr¿r¶r„rnrnrorjqs ÿ z%MTProtoSender._handle_destroy_sessioncÃsx|j d|j¡t|j ¡ƒD]4\}}t|jtƒr|j|=|j   ¡s|j   |j¡qt|jt ƒrt|j tƒdIdHdS)a Handles :tl:`DestroyAuthKeyFail`, :tl:`DestroyAuthKeyNone`, and :tl:`DestroyAuthKeyOk`. :tl:`DestroyAuthKey` is not intended for users to use, but they still might, and the response won't come in `rpc_result`, so thhat's worked around here. zHandling destroy auth key %srŠN)r?r“rÁr´rVrír«rƒrrrÌrPr)rzrrîrnrnrorks   z&MTProtoSender._handle_destroy_auth_key)F)N)5r>Ú __module__Ú __qualname__Ú__doc__rprtrwryr{rˆÚpropertyr‰rrr‹rŒrzr±r²r³r•r–r½rÈr]r^r_rÂÚ frozensetr×ZUpdateShortMessager\ZUpdateShortChatMessagerØZUpdatesCombinedZUpdatesZUpdateShortSentMessagerÐZAffectedHistoryZAffectedMessagesZAffectedFoundMessagesrÍr`rarbrcrdrerfrgrhrirjrkrnrnrnror/!srý L 6 ;  "E3A 6  úýù '$    r/)@rGrYr~rÙrÚÚrZextensions.messagepackerrZmtprotoplainsenderrZ requeststaterZ mtprotostaterZ tl.tlobjectr r r Úerrorsr r rrrrÚ extensionsrZtl.corerrrZtl.functions.authrZ tl.functionsrrrZtl.typesrrrrrrr r!r"r#r$r%r&r'r(r)r*r+Útlr,r×Zcryptor-r.r/rnrnrnroÚs*         P