%gkSrSSKJr SSKJrJr SSKJrJr SSK J r SSK J r J r JrJrJrJrJrJr SSKJrJr SS KJrJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r& SS K'J(r(J)r)J*r*J+r+ SS K,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6 SS K7J8r8 \(aSS K9J:r:J;r; SSKJ?r?J@r@ SSKAJBrB "SS\5rC"SS\5rD"SS\5rE\F"\G"\C55Vs/sHnSPM snrHS\H\CR'S\H\CR'S\H\CR'"SS5rL0\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4S\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4S\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4S\CR4_\CR\DR4\LR\CR4_0\CR\DR4\LR\CR4_\CR\DR4S\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4S\CR4_\CR\DR4\LR\CR4_\CR\DR4S\CR4_\CR\DR4\LR\CR4_\CR\DR4S\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_E0\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4S\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4S\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_E0\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4S\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_\CR\DR4S\CR4_\CR\DR4S\CR4_\CR\DR4\LR\CR4_\CR\DR4\LR\CR4_E\CR\DR4S\CR4\CR\DR4S\CR4\CR\DR4\LR\CR4\CR\DR4\LR\CR4\CR\DR4\LR\CR4\CR\DR4\LR\CR4\CR\DR4\LR\CR4\CR\DR4\LR\CR4\CR\DR4\LR\CR40 Er{"SS5r|SSjr}gs snf) z< h2/stream ~~~~~~~~~ An implementation of a HTTP/2 stream. ) annotations)EnumIntEnum) TYPE_CHECKINGAny) HeaderTuple) AltSvcFrameContinuationFrame DataFrameFrame HeadersFramePushPromiseFrameRstStreamFrameWindowUpdateFrame) ErrorCodes_error_code_from_int)AlternativeServiceAvailable DataReceivedEventInformationalResponseReceivedPushedStreamReceivedRequestReceivedResponseReceived StreamEnded StreamResetTrailersReceived WindowUpdated_PushedRequestSent _RequestSent _ResponseSent _TrailersSent)FlowControlErrorInvalidBodyLengthError ProtocolErrorStreamClosedError) HeaderValidationFlagsauthority_from_headersextract_method_headerguard_increment_windowis_informational_responsenormalize_inbound_headersnormalize_outbound_headersutf8_encode_headersvalidate_headersvalidate_outbound_headers) WindowManager) GeneratorIterable)Encoder)HeaderHeaderWeaklyTyped)H2Configurationc0\rSrSrSrSrSrSrSrSr Sr S r g ) StreamState9rrN) __name__ __module__ __qualname____firstlineno__IDLERESERVED_REMOTERESERVED_LOCALOPENHALF_CLOSED_REMOTEHALF_CLOSED_LOCALCLOSED__static_attributes__r@+/usr/lib/python3/dist-packages/h2/stream.pyr9r99s' DON D FrMr9c`\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrg) StreamInputsCrrr;r<r=r>r? r@N)rArBrCrD SEND_HEADERSSEND_PUSH_PROMISESEND_RST_STREAM SEND_DATASEND_WINDOW_UPDATESEND_END_STREAM RECV_HEADERSRECV_PUSH_PROMISERECV_RST_STREAM RECV_DATARECV_WINDOW_UPDATERECV_END_STREAMRECV_CONTINUATIONSEND_INFORMATIONAL_HEADERSRECV_INFORMATIONAL_HEADERSSEND_ALTERNATIVE_SERVICERECV_ALTERNATIVE_SERVICEUPGRADE_CLIENTUPGRADE_SERVERrLr@rMrNrPrPCsjLOIOLOIO!#!#!!NNrMrPc$\rSrSrSrSrSrSrSrg)StreamClosedByYrrr;r<r@N) rArBrCrDrcrir`rfrLr@rMrNrrrrYsOOOOrMrrFTc\rSrSrSrSSjrS SjrS!SjrS!SjrS!Sjr S!Sjr S!S jr S!S jr S!S jr S!S jrS!S jrS!SjrS!SjrS!SjrS!SjrS"SjrS"SjrS"SjrS"SjrS"SjrS"SjrS"SjrS!SjrS!SjrS!SjrS"SjrSrg)#H2StreamStateMachinekz A single HTTP/2 stream state machine. This stream object implements basically the state machine described in RFC 7540 section 5.1. :param stream_id: The stream ID of this stream. This is stored primarily for logging purposes. c[RUlXlSUlSUlSUlSUlSUlSUl g)N) r9rEstate stream_idclient headers_sent trailers_sentheaders_receivedtrailers_receivedstream_closed_by)selfrys rN__init__H2StreamStateMachine.__init__vsI %% "$( *.*.-1.28<rMc[U[5(d Sn[U5e[URU4up4URnX@lUb U"X5$/$![ a [ RUle[a&n[ RUl[ U5UeSnAff=f![a:nURn[ RUlSUSU3n[ U5UeSnAff=f)z0 Process a specific input in the state machine. z)Input must be an instance of StreamInputsNzInvalid input z in state ) isinstancerP ValueError _transitionsrxr%r9rKAssertionErrorKeyError)rinput_msgfunc target_stateprevious_stateerr old_states rN process_input"H2StreamStateMachine.process_inputs&,//=CS/ ! !-tzz6.B!C D"ZZN%J655I%!,!3!3DJ%6!,!3!3DJ',#56 . I$++DJ"6(*YK@C$# -  .s/B-A)B*!B%%B*- C175C,,C1c8SUlSUl[5nU/$)z Fires when a request is sent. T)rzr{r rrevents rN request_sent!H2StreamStateMachine.request_sents!  wrMcUR(d;URSLd URc Sn[U5eSUl[5/$UR(aeSUl[ 5/$)zc Fires when something that should be a response is sent. This 'response' may actually be trailers. TzClient cannot send responses.)r{rzr%r!r|r"rrrs rN response_sent"H2StreamStateMachine.response_sentsg   {{d"dkk&95#C(( $D !O$ $%%%%!  rMcUR(aeUR(aeSUlSUl[5nURUlU/$)z# Fires when a request is received. FT)r}r~rzrryrs rNrequest_received%H2StreamStateMachine.request_receivedsK(((()))) $!..wrMcUR(d#URSLdeSUl[5nO$UR(aeSUl[ 5nUR UlU/$)zW Fires when a response is received. Also disambiguates between responses and trailers. T)r}rzrr~rryrs rNresponse_received&H2StreamStateMachine.response_receiveds` $$;;$& &&$(D !$&E-- --%)D "$&E..wrMczUR(d Sn[U5e[5nURUlU/$)z Fires when data is received. z"cannot receive data before headers)r}r%rryrrrrs rN data_received"H2StreamStateMachine.data_receiveds6$$6C$ $..wrMc>[5nURUlU/$)z/ Fires when a window update frame is received. )rryrs rNwindow_updated#H2StreamStateMachine.window_updateds..wrMc>[5nURUlU/$)zw Fires when an END_STREAM flag is received in the OPEN state, transitioning this stream to a HALF_CLOSED_REMOTE state. )rryrs rNstream_half_closed'H2StreamStateMachine.stream_half_closeds  ..wrMch[RUl[5nURUlU/$)z' Fires when a stream is cleanly ended. )rrrirrryrs rN stream_ended!H2StreamStateMachine.stream_ended+!/ > > ..wrMch[RUl[5nURUlU/$)z* Fired when a stream is forcefully reset. )rrrfrrryrs rN stream_reset!H2StreamStateMachine.stream_resetrrMc@URbeSUlSUl/$)z Fires on the newly pushed stream, when pushed by the local peer. No event here, but definitionally this peer must be a server. FT)rzr}rrs rNsend_new_pushed_stream+H2StreamStateMachine.send_new_pushed_stream s( {{""" $ rMc@URbeSUlSUl/$)z Fires on the newly pushed stream, when pushed by the remote peer. No event here, but definitionally this peer must be a client. T)rzr{rs rNrecv_new_pushed_stream+H2StreamStateMachine.recv_new_pushed_streams( {{"""   rMcTURSLa Sn[U5e[5nU/$)z Fires on the already-existing stream when a PUSH_PROMISE frame is sent. We may only send PUSH_PROMISE frames if we're a server. Tz&Cannot push streams from client peers.)rzr%rrs rNsend_push_promise&H2StreamStateMachine.send_push_promise s/ ;;$ :C$ $"$wrMcUR(dURcSnOSn[U5e[5nURUlU/$)z Fires on the already-existing stream when a PUSH_PROMISE frame is received. We may only receive PUSH_PROMISE frames if we're a client. Fires a PushedStreamReceived event. z"Idle streams cannot receive pushesz)Cannot receive pushed streams as a server)rzr%rryparent_stream_idrs rNrecv_push_promise&H2StreamStateMachine.recv_push_promise,sE{{{{":A$ $$&!%wrMc.[RUlg)zT Called when an attempt is made to send END_STREAM in the HALF_CLOSED_REMOTE state. N)rrrcrrs rNsend_end_stream$H2StreamStateMachine.send_end_stream> !/ > >rMc.[RUlg)zQ Called when an attempt is made to send RST_STREAM in a non-closed stream state. N)rrr`rrs rNsend_reset_stream&H2StreamStateMachine.send_reset_streamErrMc[RUl[UR5n[ 5nURUl[ RUlSUl U/Ul Ue)aK Called when we need to forcefully emit another RST_STREAM frame on behalf of the state machine. If this is the first time we've done this, we should also hang an event off the StreamClosedError so that the user can be informed. We know it's the first time we've done this if the stream is currently in a state other than CLOSED. F) rrr`rr&ryrr STREAM_CLOSED error_code remote_reset_events)rrerrorrs rNreset_stream_on_error*H2StreamStateMachine.reset_stream_on_errorLsV!/ > >!$..1 ..%33"  rMc,[UR5e)a? Called when an unexpected frame is received on an already-closed stream. An endpoint that receives an unexpected frame should treat it as a stream error or connection error with type STREAM_CLOSED, depending on the specific frame. The error handling is done at a higher level: this just raises the appropriate error. r&ryrs rNrecv_on_closed_stream*H2StreamStateMachine.recv_on_closed_streama //rMc,[UR5e)a# Called when an attempt is made to send data on an already-closed stream. This essentially overrides the standard logic by throwing a more-specific error: StreamClosedError. This is a ProtocolError, so it matches the standard API of the state machine, but provides more detail to the user. rrs rNsend_on_closed_stream*H2StreamStateMachine.send_on_closed_streammrrMcURceUR[R:Xa[UR5eSn[ U5e)a Called when a PUSH_PROMISE frame is received on a full stop stream. If the stream was closed by us sending a RST_STREAM frame, then we presume that the PUSH_PROMISE was in flight when we reset the parent stream. Rathen than accept the new stream, we just reset it. Otherwise, we should call this a PROTOCOL_ERROR: pushing a stream on a naturally closed stream is a real problem because it creates a brand new stream that the remote peer now believes exists. #Attempted to push on closed stream.)rrrr`r&ryr%rs rNrecv_push_on_closed_stream/H2StreamStateMachine.recv_push_on_closed_streamysI$$000  N$B$B B#DNN3 33C  rMcSn[U5e)ac Called when an attempt is made to push on an already-closed stream. This essentially overrides the standard logic by providing a more useful error message. It's necessary because simply indicating that the stream is closed is not enough: there is now a new stream that is not allowed to be there. The only recourse is to tear the whole connection down. r)r%rs rNsend_push_on_closed_stream/H2StreamStateMachine.send_push_on_closed_streams4C  rMcXUR(a Sn[U5e[5nU/$)z Called when an informational header block is sent (that is, a block where the :status header has a 1XX value). Only enforces that these are sent *before* final headers are sent. z)Information response after final response)r{r%r!rs rNsend_informational_response0H2StreamStateMachine.send_informational_responses+   =C$ $wrMczUR(a Sn[U5e[5nURUlU/$)zt Called when an informational header block is received (that is, a block where the :status header has a 1XX value). z+Informational response after final response)r}r%rryrs rNrecv_informational_response0H2StreamStateMachine.recv_informational_responses7  ?C$ $-/..wrMc`URSLa/$UR(a/$[5/$)a Called when receiving an ALTSVC frame. RFC 7838 allows us to receive ALTSVC frames at any stream state, which is really absurdly overzealous. For that reason, we want to limit the states in which we can actually receive it. It's really only sensible to receive it after we've sent our own headers and before the server has sent its header block: the server can't guarantee that we have any state around after it completes its header block, and the server doesn't know what origin we're talking about before we've sent ours. For that reason, this function applies a few extra checks on both state and some of the little state variables we keep around. If those suggest an unreasonable situation for the ALTSVC frame to have been sent in, we quietly ignore it (as RFC 7838 suggests). This function is also *not* always called by the state machine. In some states (IDLE, RESERVED_LOCAL, CLOSED) we don't bother to call it, because we know the frame cannot be valid in that state (IDLE because the server cannot know what origin the stream applies to, CLOSED because the server cannot assume we still have state around, RESERVED_LOCAL because by definition if we're in the RESERVED_LOCAL state then *we* are the server). F)rzr}rrs rN recv_alt_svc!H2StreamStateMachine.recv_alt_svcs36 ;;% I  I,-..rMc@UR(a Sn[U5eg)a Called when sending an ALTSVC frame on this stream. For consistency with the restrictions we apply on receiving ALTSVC frames in ``recv_alt_svc``, we want to restrict when users can send ALTSVC frames to the situations when we ourselves would accept them. That means: when we are a server, when we have received the request headers, and when we have not yet sent our own response headers. z2Cannot send ALTSVC after sending response headers.N)r{r%rs rN send_alt_svc!H2StreamStateMachine.send_alt_svcs"   FC$ $ rM)rzr}r{rxrryr~r|N)ryintreturnNone)rrPrr)rr9rz list[Event])rr9rr) rArBrCrD__doc__rrrrrrrrrrrrrrrrrrrrrrrrrrrLr@rMrNruruks< < ! $    $??* 0 0!& !  &/P%rMruNc\rSrSrSrS#SjrS$Sjr\S%Sj5r\S&Sj5r \S&Sj5r \S'Sj5r S(S jr S)S*S jjr S+S jrS,S jrS-S.SjjrS,SjrS/SjrS0SjrS1SjrS2SjrS3SjrS4SjrS5SjrS6SjrS7SjrS8S9SjjrS:SjrS;SjrSSjr S?Sjr!S@S jr"SAS!jr#S"r$g )BH2StreamiaJ A low-level HTTP/2 stream object. This handles building and receiving frames and maintains per-stream state. This wraps a HTTP/2 Stream state machine implementation, ensuring that frames can only be sent/received when the stream is in a valid state. Attempts to create frames that cannot be sent will raise a ``ProtocolError``. c[U5UlXlSUlSUlX@l[ U5UlSUlSUl SUl X l g)Nr) ru state_machinerymax_outbound_frame_sizerequest_methodoutbound_flow_control_windowr1_inbound_window_manager_expected_content_length_actual_content_length _authorityconfig)rryrinbound_window_sizeoutbound_window_sizes rNrH2Stream.__init__sc 2)<"37$,0-A)(55H'I$59%'(#)- rMc~S[U5RSURSURR<S3$)N)typerAryrrxrs rN__repr__H2Stream.__repr__$s;4:&&'tDNN+;74CUCUC[C[B^^_``rMc.URR$)a The size of the inbound flow control window for the stream. This is rarely publicly useful: instead, use :meth:`remote_flow_control_window `. This shortcut is largely present to provide a shortcut to this data. )rcurrent_window_sizers rNinbound_flow_control_window$H2Stream.inbound_flow_control_window's++???rMc<[URR$)zq Whether the stream is 'open' in any sense: that is, whether it counts against the number of concurrent streams. ) STREAM_OPENrrxrs rNopen H2Stream.open1s4--3344rMcPURR[R:H$)z Whether the stream is closed. )rrxr9rKrs rNclosedH2Stream.closed>s! !!'';+=+===rMc.URR$)z> Returns how the stream was closed, as one of StreamClosedBy. )rrrs rN closed_byH2Stream.closed_byEs !!222rMcURRRSU5 URS:XdeU(a[R O[R nURRU5 g)z Called by the connection to indicate that this stream is the initial request/response of an upgraded connection. Places the stream into an appropriate state. z Upgrading %rrN) rloggerdebugryrProrprr)r client_siders rNupgradeH2Stream.upgradeLs_   6~~"""+6L ' ',,  ((0rMcVURRRSX5 [Rn[ U5nUR R(d4[U5(a$U(a Sn[U5e[RnUR RU5n[UR5nURU5n URXRX5n U(aGUR R[R 5 U SR"R%S5 UR R&(aU(d Sn[U5eUR R(aUR(c[+U5Ul[-U5UlU $)zV Returns a list of HEADERS/CONTINUATION frames to emit as either headers or trailers. zSend headers %s on %rz1Cannot set END_STREAM on informational responses.r END_STREAMz"Trailers must have END_STREAM set.)rrrrPr^r.rrzr+r%rkrr ry_build_hdr_validation_flags_build_headers_framesrcflagsaddr|rr(r)r) rheadersencoder end_streamr bytes_headersreventshfhdr_validation_flagsframess rN send_headersH2Stream.send_headers]sH   !8'H**+G4 ##**)-88I#C((!<>   !$..1A!* 3J rMc[US[[45n[US[[[ 45n[US[ [45n[URR=(d SUUUS9$)zd Constructs a set of header validation flags for use when normalizing and validating header blocks. rF) is_client is_traileris_response_headeris_push_promise) rr"rr!rrrrr'rrz)rr"r{r|r}s rNr$H2Stream._build_hdr_validation_flagss  1I '78 ( 1I -  % 1I,.@A %((//85!1+   rMc~URR(a"URRn[XU5nURR(a [X5nUR U5n[ S[ U5UR=(d S5Vs/sHnXgXpR=(d S-PM nn/n USUlU RU5 USSH/n [UR5n XlU RU 5 M1 U SRRS5 U $s snf)z8 Helper method to build headers or push promise frames. rrN END_HEADERS)rr-split_outbound_cookiesr0encoderangerZrr3appendr ryrr) rrr first_framer$should_split_outbound_cookiesencoded_headersi header_blocksr%blockcfs rNrH2Stream._build_headers_framess* ;; 1 1-1KK,N,N )0/LG ;; 0 0/G"..13'$*F*F*K!  a!=!=!BC D  MO(+  k""12&E"4>>2BG MM" ' r ]+ # s #D:cURR(a [X5nURR(a [X5n[ U[ 5(a [ X5n[U5$)z When headers have been received from the remote peer, run a processing pipeline on them to transform them into the appropriate form for attaching to an event. )rr,validate_inbound_headersr/rstr_decode_headerslist)rrheader_validation_flagsrKs rNrJ"H2Stream._process_received_headers*sZ ;; 0 0/G ;; / /&wHG os + +%g?GG}rMcURS:XaSUlgUHup#US:XdM [US5Ul g g![anSU<3n[ U5UeSnAff=f)z Checks the headers for a content-length header and initializes the _expected_content_length field from it. It's not an error for no Content-Length header to be present. sHEADrNscontent-lengthrUzInvalid content-length header: )rrrrr%)rrnvrrs rNrS#H2Stream._initialize_content_lengthBsu   ' ),-D ) DA%%6472JD1 "6;A5AC',#56s? A  AA cU=RU- slURnURnUb)XC:a [XC5eU(aXC:wa [XC5eggg)ae Update the expected content length in response to data being received. Validates that the appropriate amount of data is sent. Always updates the received data, but only validates the length against the content-length header if one was sent. :param length: The length of the body chunk received. :param end_stream: If this is the last body chunk received. N)rrr$)rlengthr actualexpecteds rNrYH2Stream._track_content_lengthVsa ##v-#,,00   ,X>>h0,X>>1z rMcURRU-nURRU5 X Rlg)a) We changed SETTINGS_INITIAL_WINDOW_SIZE, which means we need to update the target window size for flow control. For our flow control strategy, this means we need to do two things: we need to adjust the current window size, but we also need to set the target maximum window size to the new value. N)rmax_window_sizerB)rr` new_max_sizes rN*_inbound_flow_control_change_from_settings3H2Stream._inbound_flow_control_change_from_settingsks:33CCeK  $$22597C$$4rM) rrrrrrrrrry) ryrrr7rrrrrr)rr)rr)rbool)rzStreamClosedBy | None)rrrr)F)rIterable[HeaderWeaklyTyped]rr4r rr9list[HeadersFrame | ContinuationFrame | PushPromiseFrame])r*rrrrr4rr)r list[Frame])FN)r3zbytes | memoryviewr rr4z int | Nonerr)r=bytesrr)rDrrr)r)rrIterable[Header]rKbool | str | Nonertuple[list[Frame], list[Event]])rOrrr)rrr rrKrrr)r3rr rr\rrr)rDrrr)rr)rkr rr)r)rzErrorCodes | intrr)rkrrr)rurrr)r"rrr') rrrr4rzHeadersFrame | PushPromiseFramer$r'rr)rrrr'rKrrr)rrrr)rrr rrr)r`rrr)%rArBrCrDrrrpropertyrr r rrr&r,r/r7r r?rFrLrPrUr]rcrfrlrbrrwrrrJrSrYrrLr@rMrNrrs0('*(+ 04 8a@@ 5 5>> 33 1().595%5"&53l5n /2 %@ &- 2k : &++/*")5@<   9<.>7HMl0 "!1"$("*;"@_"H."H "6  ( 6.'7.'..,K.5J . I .`+;;P4EJZ0(?* DrMrc## UHn[U[5(deUup4[U[5(de[U[5(deURU5nURU5nUR XV5v M g7f)z Given an iterable of header two-tuples and an encoding, decodes those headers using that encoding while preserving the type of the header tuple. This ensures that the use of ``HeaderTuple`` is preserved. N)rrrdecode __class__)rencodingheadernamevaluerrs rNrrxs &+.... $&&&&%'''' KK ! LL "q$$sB B )rrrrrz"Generator[HeaderTuple, None, None])~r __future__renumrrtypingrrhpackrhyperframe.framer r r r r rrrerrorsrrr"rrrrrrrrrrrrr r!r" exceptionsr#r$r%r& utilitiesr'r(r)r*r+r,r-r.r/r0windowsr1collections.abcr2r3 hpack.hpackr4 hpack.structr5r6rr7r9rPrrrrZr rHrJrIrurEr^rrdrrgrrKr_rrGrerrFrnrorprrbrhrr`rrfrrmrrrrarrcrirrrrkrrlrrrrrrrrrr)_s0rNrs #%QQQ4"cb   #3#6''4,T$C $4565u56 $ K  -1 K ) )*.2 K * *+@%@%RF|001  * *K,<,<=F|001  . . 0@0@A F |--.  3 3[5G5GHF|556  4 4  & & (F|556  4 4  ' ' )F|<<= { F |223  * *K,I,IJ#F$|223  . .  * * ,'F.!:!:;  + +[-K-KL1F2!7!78  3 3[5G5GH5F6!@!@A {))*9F:!@!@A  , ,k.H.HI=F>!=!=>  / /1C1CDAFB!=!=>  * *K,>,>?EFF!F!FG  * *K,F,FGIFJ!F!FG {))*MFR  ,";";<  / /  ) ) +UFX  ,"8"89  3 3[5G5GH[F\  ,"A"AB {**+_F`  ,"A"AB  , ,k.I.IJcFd  ,">">?  / /1C1CDgFh  ,">">?  * *K,>,>?kFl  ,"G"GH  * *K,G,GHoFt|001  + +[-=-=>wFx|001  / /1A1AB{F||--. { F@|--.  + +[-=-=>CFD|334 {,,-GFH|334  0 0  ' ' )KFN|667 { QFR|667  , ,k.>.>?UFV|334  / /1C1CDYFZ|334  * *K,>,>?]F^|556  / /1A1ABaFb|556  / /1A1ABeFf|>>?  9 9;;K;KLiFj|>>?  9 9;;K;KLmFn|<<=  * *K,<,<=qFr|<<=  * *K,<,<=uFz##\%>%>?  + +[-K-KL}F~##\%>%>?  3 3[5G5GHAFB##\%;%;< {--.EFF##\%;%;<  3 3[5G5GHIFJ##\%A%AB  - -{/A/ABMFN##\%D%DE {--.QFR##\%D%DE  , ,k.L.LMUFV##\%A%AB  / /1C1CDYFZ##\%A%AB  * *K,>,>?]F^##\%C%CD  / /  * * ,aFd##\%C%CD  3 3[5G5GHgFh##\%L%LM  9 9  * * ,kFn##\%J%JK  * *K,J,JKqFr##\%J%JK  * *K,J,JKuFz""L$=$=>  / /  ) ) +}F@""L$:$:;  + +[-J-JKCFD""L$@$@A  * *K,>,>?GFH""L$C$CD {,,-KFL""L$C$CD  , ,k.K.KLOFP""L$@$@A  / /1C1CDSFT""L$@$@A  * *K,>,>?WFX""L$B$BC  / /  ) ) +[F^""L$K$KL  9 9  ) ) +aFd""L$I$IJ  * *K,I,IJgFh""L$I$IJ  * *K,I,IJkFp556 {!!"sFt>>? {!!"wFJ223  3 3[5G5GHMFN//0  3 3[5G5GHQF\889 {!!"556 {!!" 778  8 8+:L:LM223  3 3[5G5GH778  8 8+:L:LM556  3 3[5G5GH//0  3 3[5G5GH889  3 3[5G5GH556  3 3[5G5GHKF Rx Dx Dv%g(7s {