diff --git a/rbt/v1alpha1/react.proto b/rbt/v1alpha1/react.proto index 0b770b655..cbc1113e7 100644 --- a/rbt/v1alpha1/react.proto +++ b/rbt/v1alpha1/react.proto @@ -18,6 +18,18 @@ message QueryRequest { // Authorization bearer token. optional string bearer_token = 3; + + // ID of the `QueryResponse` that this request acknowledges; see + // `AcknowledgeQueryResponse`. Only meaningful on transports where a + // client can send more than one message per query, i.e. websockets. + // When this is set the other fields are ignored. + string acknowledge_query_response_id = 4; + + // Whether this client acknowledges the responses it receives. A + // client from before acknowledgements existed does not set this, + // and gets a new response as soon as one is produced rather than + // once it is ready for one. + bool client_can_acknowledge_responses = 5; } message QueryResponse { @@ -40,8 +52,22 @@ message QueryResponse { // // TODO(benh): send these as bytes? repeated string idempotency_keys = 2; + + // Unique ID of this response, used to acknowledge it. Only set when + // the client set `client_can_acknowledge_responses` on its + // `QueryRequest`; an empty ID means no acknowledgement is expected. + string query_response_id = 4; +} + +//////////////////////////////////////////////////////////////////////// + +message AcknowledgeQueryResponseRequest { + // ID of the `QueryResponse` being acknowledged. + string query_response_id = 1; } +message AcknowledgeQueryResponseResponse {} + //////////////////////////////////////////////////////////////////////// // TODO(benh): support batch, e.g., create a `MutateRequests` which @@ -90,8 +116,17 @@ message WebSocketsConnectionResponse {} service React { // Allows users to "watch" the response of a unary reader method for // changes. The current response of the method is sent when the - // stream is opened, then a new response is sent whenever the - // state changes in a way that causes the method's response to change. + // stream is opened. A client that sets + // `client_can_acknowledge_responses` must acknowledge every + // response before a next one is produced, and that next response + // reflects the _latest_ state, skipping any states that came and + // went while the client was busy. A client that does not set it + // gets every response as soon as it is produced. + // + // A client acknowledges either by calling + // `AcknowledgeQueryResponse`, or, when its responses arrive over a + // websocket, by sending a `QueryRequest` with + // `acknowledge_query_response_id` set on that same websocket. // // NOTE: the service name and state ID is expected to be part of the // gRPC metadata, exactly like any other reboot requests. @@ -101,6 +136,16 @@ service React { }; } + // Acknowledges that a client has processed a response from `Query` + // and is ready for a next one. Must be called on the same server + // that produced the response. + rpc AcknowledgeQueryResponse(AcknowledgeQueryResponseRequest) + returns (AcknowledgeQueryResponseResponse) { + option (google.api.http) = { + post: "/rbt.v1alpha1.React/AcknowledgeQueryResponse" + }; + } + // All connections must be HTTP/2 (h2), but the WebSocket protocol // is inherently HTTP/1.1. RFC 8441 // (https://datatracker.ietf.org/doc/html/rfc8441) introduced diff --git a/reboot/aio/contexts.py b/reboot/aio/contexts.py index b814275c2..6d9022c80 100644 --- a/reboot/aio/contexts.py +++ b/reboot/aio/contexts.py @@ -474,10 +474,13 @@ async def query(): self._state_type_name, self._state_ref ) - call = react_pb2_grpc.ReactStub(channel).Query( + stub = react_pb2_grpc.ReactStub(channel) + + call = stub.Query( react_pb2.QueryRequest( method=self._method, request=serialized_request, + client_can_acknowledge_responses=True, ), metadata=metadata, ) @@ -498,25 +501,59 @@ async def loop(): assert task is not None async for query_response in call: - if not query_response.HasField('response'): - continue - - response = self._response_type() - response.ParseFromString(query_response.response) - - self._used_response[task].clear() - - self._calls[task] = call - - self._responses[task] = asyncio.Future() - self._responses[task].set_result(response) - - if not have_first_response.is_set(): - have_first_response.set() - else: - self._event.set() - - await self._used_response[task].wait() + if query_response.HasField('response'): + response = self._response_type() + response.ParseFromString( + query_response.response + ) + + self._used_response[task].clear() + + self._calls[task] = call + + self._responses[task] = asyncio.Future() + self._responses[task].set_result(response) + + if not have_first_response.is_set(): + have_first_response.set() + else: + self._event.set() + + await self._used_response[task].wait() + + # Only now that the response has been used + # do we ask for a next one, so that it + # reflects the latest state rather than a + # state that has already been superseded. + # An older backend doesn't send an ID and + # doesn't expect an acknowledgement. + if query_response.query_response_id != '': + try: + await stub.AcknowledgeQueryResponse( + react_pb2. + AcknowledgeQueryResponseRequest( + query_response_id=query_response. + query_response_id, + ), + # The same metadata ensures + # we're routed to the same + # server. + metadata=metadata, + ) + except grpc.aio.AioRpcError as error: + if ( + error.code() + != grpc.StatusCode.UNIMPLEMENTED + ): + raise + # We have reached a server that has + # no `AcknowledgeQueryResponse`, + # which we can do mid-stream when a + # deployment is rolled back. + # Returning starts a fresh read; + # that server's responses carry no + # ID and expect no acknowledgement. + return raise RuntimeError('React.Query should be infinite') diff --git a/reboot/aio/react.py b/reboot/aio/react.py index d1039e986..b0e671867 100644 --- a/reboot/aio/react.py +++ b/reboot/aio/react.py @@ -73,6 +73,10 @@ def __init__( self._state_name_by_state_tag[state_tag] = state_type_name self._middleware_by_state_type[state_type_name] = middleware + # Events, keyed by the ID of a response sent by `Query`, that + # are set once the client acknowledges that response. + self._query_response_acknowledgements: dict[str, asyncio.Event] = {} + self._stop_websockets_serve = asyncio.Event() def _state_type_name_for_state_ref( @@ -338,16 +342,34 @@ async def _websocket_query( query_task = asyncio.current_task() assert query_task is not None - async def consume_heartbeats(): + # Events, keyed by query response ID, that are set once the + # client acknowledges the response with that ID. + acknowledgements: dict[str, asyncio.Event] = {} + + async def consume_requests(): try: while True: - _ = await websocket.recv() + request_bytes = await websocket.recv() + + # Everything the client sends after its initial + # request is either an acknowledgement or a + # heartbeat; a heartbeat is an empty + # `QueryRequest`, which acknowledges nothing. + acknowledgement = react_pb2.QueryRequest() + acknowledgement.ParseFromString(request_bytes) + + acknowledged = acknowledgements.pop( + acknowledgement.acknowledge_query_response_id, + None, + ) + if acknowledged is not None: + acknowledged.set() except Exception: # WebSocket closed (or errored); cancel the main query # task to unblock `_query()` and trigger cleanup. query_task.cancel() - heartbeats_task = asyncio.create_task(consume_heartbeats()) + requests_task = asyncio.create_task(consume_requests()) try: async for response in self._query( @@ -355,14 +377,132 @@ async def consume_heartbeats(): headers=headers, middleware=middleware, ): - await websocket.send(response.SerializeToString()) + if not request.client_can_acknowledge_responses: + # This client acknowledges nothing, so produce a + # next response as soon as we have one; the empty + # ID tells it that we expect no acknowledgement. + await websocket.send(response.SerializeToString()) + continue + + response.query_response_id = str(uuid.uuid4()) + + acknowledged = asyncio.Event() + acknowledgements[response.query_response_id] = acknowledged + + try: + await websocket.send(response.SerializeToString()) + + # Wait for the client to tell us that it is ready + # for a next response. This is what stops us from + # producing responses faster than the client can + # consume them; while we wait here the state may + # change any number of times, and the next + # response we produce will reflect the latest of + # those states. + await acknowledged.wait() + finally: + acknowledgements.pop(response.query_response_id, None) finally: - heartbeats_task.cancel() - await asyncio.gather(heartbeats_task, return_exceptions=True) + requests_task.cancel() + await asyncio.gather(requests_task, return_exceptions=True) def add_to_server(self, server: grpc.aio.Server) -> None: react_pb2_grpc.add_ReactServicer_to_server(self, server) + async def _middleware_for( + self, + grpc_context: grpc.aio.ServicerContext, + headers: Headers, + ) -> Middleware: + """Returns the middleware for the state that the given headers + address, after confirming that this server is authoritative for + that state.""" + state_ref = headers.state_ref + + state_type_name = self._state_type_name_for_state_ref(state_ref) + + if state_type_name is None: + log_at_most_once_per( + seconds=60, + log_method=logger.error, + message=_unknown_query_or_mutation_error_message( + is_query=True, + state_type=state_ref.state_type, + ), + ) + raise SystemAborted(UnknownService()) + + middleware = self._middleware_by_state_type[state_type_name] + + try: + assert headers.application_id is not None # Guaranteed by `Headers`. + authoritative_server = middleware.placement_client.server_for_actor( + headers.application_id, + state_ref, + ) + except reboot.aio.placement.UnknownApplicationError: + # It's possible that the user did indeed type an application ID + # that doesn't exist, but it's also quite possible that this + # request reached us before the placement planner had gossipped + # out the information about which applications exist (we see + # this e.g. after `rbt dev`'s chaos monkey restarts). For that + # reason, abort with a retryable error. + raise SystemAborted( + Unavailable(), + message= + f"Application '{headers.application_id}' not found. If you " + "are confident the application exists, this may be because " + "the system is still starting.", + ) from None + + if authoritative_server != middleware.server_id: + # This is NOT the correct server. Fail. + await grpc_context.abort( + grpc.StatusCode.UNAVAILABLE, + f"Server '{middleware.server_id}' is not " + "authoritative for this request; server " + f"'{authoritative_server}' is.", + ) + raise # Unreachable but necessary for mypy. + + return middleware + + async def AcknowledgeQueryResponse( + self, + request: react_pb2.AcknowledgeQueryResponseRequest, + grpc_context: grpc.aio.ServicerContext, + ) -> react_pb2.AcknowledgeQueryResponseResponse: + """Implements the React.AcknowledgeQueryResponse RPC that lets a + client tell us it has processed a response from `Query` and is + ready for a next one.""" + # Confirm that we are the server that produced the response. + await self._middleware_for( + grpc_context, + Headers.from_grpc_context(grpc_context), + ) + + acknowledged = self._query_response_acknowledgements.pop( + request.query_response_id, + None, + ) + + if acknowledged is None: + # There are several valid reasons why we may not know this + # response: + # 1. The server may have restarted and lost its memory of + # the response. The client's `Query` call will have been + # broken by that same restart, and it will get a fresh + # response once it reconnects. + # 2. The client may have sent its acknowledgement twice + # (e.g. retried the request), in which case we have + # already produced a next response. + # Either way there is nothing left to do. + return react_pb2.AcknowledgeQueryResponseResponse() + + acknowledged.set() + + return react_pb2.AcknowledgeQueryResponseResponse() + async def _query( self, *, @@ -425,61 +565,51 @@ def done_callback(_) -> None: try: headers = Headers.from_grpc_context(grpc_context) - state_ref = headers.state_ref - - state_type_name = self._state_type_name_for_state_ref(state_ref) - - if state_type_name is None: - log_at_most_once_per( - seconds=60, - log_method=logger.error, - message=_unknown_query_or_mutation_error_message( - is_query=True, - state_type=state_ref.state_type, - ), - ) - raise SystemAborted(UnknownService()) - - middleware = self._middleware_by_state_type[state_type_name] - - # Confirm whether this is the right server to be serving this - # request. - try: - assert headers.application_id is not None # Guaranteed by `Headers`. - authoritative_server = middleware.placement_client.server_for_actor( - headers.application_id, - state_ref, - ) - except reboot.aio.placement.UnknownApplicationError: - # It's possible that the user did indeed type an application ID - # that doesn't exist, but it's also quite possible that this - # request reached us before the placement planner had gossipped - # out the information about which applications exist (we see - # this e.g. after `rbt dev`'s chaos monkey restarts). For that - # reason, abort with a retryable error. - raise SystemAborted( - Unavailable(), - message= - f"Application '{headers.application_id}' not found. If you " - "are confident the application exists, this may be because " - "the system is still starting.", - ) from None - if authoritative_server != middleware.server_id: - # This is NOT the correct server. Fail. - await grpc_context.abort( - grpc.StatusCode.UNAVAILABLE, - f"Server '{middleware.server_id}' is not " - "authoritative for this request; server " - f"'{authoritative_server}' is.", - ) - raise # Unreachable but necessary for mypy. + middleware = await self._middleware_for(grpc_context, headers) async for response in self._query( request=request, headers=headers, middleware=middleware, ): - yield response + if not request.client_can_acknowledge_responses: + # This client acknowledges nothing, so produce a + # next response as soon as we have one; the empty + # ID tells it that we expect no acknowledgement. + yield response + continue + + response.query_response_id = str(uuid.uuid4()) + + acknowledged = asyncio.Event() + self._query_response_acknowledgements[ + response.query_response_id] = acknowledged + + try: + yield response + + # Wait for the client to tell us, via + # `AcknowledgeQueryResponse`, that it is ready for + # a next response. This is what stops us from + # producing responses faster than the client can + # consume them; while we wait here the state may + # change any number of times, and the next + # response we produce will reflect the latest of + # those states. + # + # TODO: consider more advanced flow control + # mechanisms than "one-ack-per-response"; + # e.g. if we could measure the throughput to + # the client we could proactively send + # multiple responses without waiting for an + # ack for each one, which would reduce the + # user-visible latency of updates. + await acknowledged.wait() + finally: + self._query_response_acknowledgements.pop( + response.query_response_id, + None, + ) except asyncio.CancelledError: # It's pretty normal for a query to be cancelled; it's not useful to # print a stack trace. diff --git a/reboot/templates/reboot.py.j2 b/reboot/templates/reboot.py.j2 index f11446176..56b6a028d 100644 --- a/reboot/templates/reboot.py.j2 +++ b/reboot/templates/reboot.py.j2 @@ -5283,9 +5283,11 @@ class {{ client.proto.state_name }}: __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='{{ method.proto.name }}', request={{ client.proto.state_name }}{{ method.proto.name }}RequestToProto( @@ -5293,6 +5295,7 @@ class {{ client.proto.state_name }}: __request__ {% endif %} ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -5308,13 +5311,38 @@ class {{ client.proto.state_name }}: # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = {{ method.output_type }}() - __response__.ParseFromString(__query_response__.response) - yield {{ client.proto.state_name }}{{ method.proto.name }}ResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = {{ method.output_type }}() + __response__.ParseFromString(__query_response__.response) + yield {{ client.proto.state_name }}{{ method.proto.name }}ResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server diff --git a/reboot/templates/reboot_react.ts.j2 b/reboot/templates/reboot_react.ts.j2 index 4802aaba7..7ce944f81 100644 --- a/reboot/templates/reboot_react.ts.j2 +++ b/reboot/templates/reboot_react.ts.j2 @@ -775,6 +775,7 @@ class {{ client.proto.state_name | to_camel }}Instance { const queryRequest = new reboot_api.react_pb.QueryRequest({ method, request: serializedRequest, + clientCanAcknowledgeResponses: true, ...(bearerToken !== undefined && { bearerToken } || {}), }); @@ -909,21 +910,40 @@ class {{ client.proto.state_name | to_camel }}Instance { // orphans list with a length greater than 0. In this case, we don't // want to skip checking the expecteds list just because we have // already checked the orphans list. - if ( - expecteds.length > 0 && - queryResponse.idempotencyKeys.includes( - expecteds[0].idempotencyKey + // + // A single query response can report the idempotency keys of + // several mutations at once, because the backend aggregates the + // keys of every state it skipped over on its way to the state this + // response reflects. Two mutations may also share an idempotency + // key. So observe _every_ mutation whose key this response + // reports, not just the oldest one. + const observeds = expecteds.filter( + expected => queryResponse.idempotencyKeys.includes( + expected.idempotencyKey ) - ) { - await expecteds[0].observed(() => { + ); + if (observeds.length > 0) { + expecteds = expecteds.filter( + expected => !observeds.includes(expected) + ); + // The one response we have in hand is the response for + // every one of these mutations, so publish it once, on + // the last of them, rather than handing every listener + // and the offline cache the same response N times. This + // is the same shape as the `orphans` loop above, and it + // matters more now that a response can report the keys + // of every state the backend skipped. + for (let i = 0; i < observeds.length - 1; i++) { + observeds[i].observed(() => {}); + } + await observeds[observeds.length - 1].observed(() => { if (response !== undefined) { reader.setResponse(response); } - expecteds.shift(); }); } // If we don't have any orphans to observe and we don't have any expecteds to observe, - // or at least, the first expecteds _is not observed_ by this response, then go ahead and + // or at least, none of the expecteds _is observed_ by this response, then go ahead and // pass on the response because it might contain new data that should get shown to the // user (e.g., in a chat app this could be a new chat message from a different user). else if (response !== undefined && !haveOrphans) { diff --git a/reboot/web/index.ts b/reboot/web/index.ts index cac6e9a99..475449849 100644 --- a/reboot/web/index.ts +++ b/reboot/web/index.ts @@ -381,6 +381,7 @@ export function reactively< const queryRequest = new react_pb.QueryRequest({ method, request: request.toBinary(), + clientCanAcknowledgeResponses: true, ...((bearerToken !== undefined && { bearerToken: await bearerToken(), }) || @@ -418,6 +419,73 @@ export function reactively< return [responses(), setRequest]; } +// Thrown when the backend has no `AcknowledgeQueryResponse` at all, as +// a backend from before flow control does not. +class AcknowledgementsUnimplemented extends Error {} + +// Tells the backend that we have processed the response with the given +// ID and are ready for a next one. Retries until the backend confirms, +// since a lost acknowledgement would leave the `Query` stream waiting +// forever. +async function acknowledgeQueryResponse({ + endpoint, + headers, + queryResponseId, + signal, +}: { + endpoint: string; + headers: Headers; + queryResponseId: string; + signal?: AbortSignal; +}): Promise { + const url = new URL( + `${endpoint}/rbt.v1alpha1.React/AcknowledgeQueryResponse` + ); + + const backoff = new Backoff(); + + while (true) { + try { + const response = await guardedFetch( + new Request(url.toString(), { + method: "POST", + headers, + body: JSON.stringify({ queryResponseId }), + signal, + }) + ); + // A `fetch()` only throws on network errors; an HTTP error + // response resolves successfully, so we have to check for it + // ourselves. + if (!response.ok) { + if (response.status === 404 || response.status === 501) { + // We are talking to a backend that has no + // `AcknowledgeQueryResponse`, which we can reach mid-stream + // when a deployment is rolled back or we are rerouted to an + // older server. Retrying can only fail again, so give up and + // let the caller reconnect; the fresh `Query` gets responses + // without an ID, which expect no acknowledgement. + throw new AcknowledgementsUnimplemented(); + } + throw new Error( + `Acknowledging query response '${queryResponseId}' failed ` + + `with HTTP status ${response.status}` + ); + } + return; + } catch (e) { + if (signal?.aborted || e instanceof AcknowledgementsUnimplemented) { + throw e; + } + console.warn( + `[Reboot] Failed to acknowledge query response ` + + `'${queryResponseId}', retrying after backoff ...` + ); + await backoff.wait(); + } + } +} + export async function* reactiveReader({ endpoint, request, @@ -430,14 +498,18 @@ export async function* reactiveReader({ websockets: boolean; }): AsyncGenerator { const url = new URL(`${endpoint}/rbt.v1alpha1.React/Query`); - if (url.protocol === "https:" && !websockets) { - const headers = new Headers(); - if (request.bearerToken !== undefined) { - headers.set("Authorization", `Bearer ${request.bearerToken}`); - } + const headers = new Headers(); - yield* grpcServerStream({ + if (request.bearerToken !== undefined) { + headers.set("Authorization", `Bearer ${request.bearerToken}`); + } + + if (url.protocol === "https:" && !websockets) { + const acknowledgeHeaders = new Headers(headers); + acknowledgeHeaders.set("Content-Type", "application/json"); + + const responses = grpcServerStream({ endpoint: url.toString(), method: "POST", headers, @@ -445,6 +517,24 @@ export async function* reactiveReader({ responseType: react_pb.QueryResponse, signal, }); + + for await (const response of responses) { + yield response; + + // Only now that our consumer has processed the response do we + // ask the backend for a next one, so that it reflects the + // latest state rather than a state that has already been + // superseded. An older backend doesn't send an ID and doesn't + // expect an acknowledgement. + if (response.queryResponseId !== "") { + await acknowledgeQueryResponse({ + endpoint, + headers: acknowledgeHeaders, + queryResponseId: response.queryResponseId, + signal, + }); + } + } } else { // TODO: while technically we could `await // grpcWebsocketServerStream(...)` doing so will leak websockets @@ -458,6 +548,14 @@ export async function* reactiveReader({ heartbeatRequest: new react_pb.QueryRequest(), responseType: react_pb.QueryResponse, signal, + // Acknowledgements go back over the same websocket, so that a + // reactive read costs no extra round trips. + acknowledgeRequest: (response: react_pb.QueryResponse) => + response.queryResponseId !== "" + ? new react_pb.QueryRequest({ + acknowledgeQueryResponseId: response.queryResponseId, + }) + : undefined, }); for await (const response of responses) { if (response.responseOrStatus.case == "status") { @@ -753,12 +851,16 @@ export async function* grpcWebsocketServerStream< heartbeatRequest, responseType, signal, + acknowledgeRequest, }: { url: URL; request: RequestType; heartbeatRequest: RequestType; responseType: MessageType; signal: AbortSignal; + // Produces the request, if any, to send back once the consumer has + // processed a response. + acknowledgeRequest?: (response: ResponseType) => RequestType | undefined; }): AsyncGenerator { url.protocol = url.protocol === "https:" ? "wss:" : "ws:"; @@ -846,7 +948,17 @@ export async function* grpcWebsocketServerStream< // suspended at `yield`; the loop re-checks after each one). let data: ArrayBuffer | undefined = undefined; while ((data = messages.shift()) !== undefined) { - yield responseType.fromBinary(new Uint8Array(data)); + const response = responseType.fromBinary(new Uint8Array(data)); + + yield response; + + const acknowledgement = acknowledgeRequest?.(response); + if ( + acknowledgement !== undefined && + websocket.readyState === WebSocket.OPEN + ) { + websocket.send(acknowledgement.toBinary()); + } } if (error !== undefined) { diff --git a/tests/reboot/echo_rbt.golden.py b/tests/reboot/echo_rbt.golden.py index ee0d4e1df..8842228a3 100755 --- a/tests/reboot/echo_rbt.golden.py +++ b/tests/reboot/echo_rbt.golden.py @@ -20844,14 +20844,17 @@ async def Replay( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='Replay', request=EchoReplayRequestToProto( __request__ ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -20867,13 +20870,38 @@ async def Replay( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = tests.reboot.echo_pb2.ReplayResponse() - __response__.ParseFromString(__query_response__.response) - yield EchoReplayResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = tests.reboot.echo_pb2.ReplayResponse() + __response__.ParseFromString(__query_response__.response) + yield EchoReplayResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -21021,14 +21049,17 @@ async def WaitFor( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='WaitFor', request=EchoWaitForRequestToProto( __request__ ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -21044,13 +21075,38 @@ async def WaitFor( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = tests.reboot.echo_pb2.WaitForResponse() - __response__.ParseFromString(__query_response__.response) - yield EchoWaitForResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = tests.reboot.echo_pb2.WaitForResponse() + __response__.ParseFromString(__query_response__.response) + yield EchoWaitForResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server diff --git a/tests/reboot/greeter_rbt.golden.js b/tests/reboot/greeter_rbt.golden.js index 0a064c8d2..f753520df 100755 --- a/tests/reboot/greeter_rbt.golden.js +++ b/tests/reboot/greeter_rbt.golden.js @@ -5509,6 +5509,6 @@ Greeter._ConstructIdempotently = (_j = class { export function importPys() { reboot_native.importPy("tests.reboot.greeter_pb2", "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"); reboot_native.importPy("tests.reboot.greeter_pb2_grpc", "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"); - reboot_native.importPy("tests.reboot.greeter_rbt", "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"); + reboot_native.importPy("tests.reboot.greeter_rbt", "H4sIAAAAAAAC/+y9a3fbSJIt+l2/Ai1/EFkjs7rO656rXjz3eGxXX6+p15Jd7XWPx4uCSFBCmSI4BGmVuqb++43IB5AAMoEEHxIobq/ukkQiE/mIiNwRGbnzRfAQLqYXwSROw+tZdPIiiNNkuboI0i/xYjSNxUfL9ZQemSf/EdIfdw+Lh+z5l9FymSxfjpNJNDydrufjl8totV7O05dfw9k6Oj2hfy+CDwkVXgU30Txahqso4MeD+9toGQXx3YJeF02CeXgXpcFdfHPLD66C9DacJPf0BT03D8JgnUZLqipdRON4GtOjaXIXiVJBPA9Wt1G8DBbLZJUE3OiAfl5H/HGQ8iNhGiTzKEimQbJeZi+l+sRrz4PeNFkG0e/h3WIWXdDbltF/rKN0RXVFM9m2SXC1XseTq35wHwXX8XwShLOZqiml1+m66J3hKgipa1TldTyZUOupgWeibWdBSAVX3HP6lgYinAfz6Gu0pCGZzeJJNODher+ip8LlRNc+OJkuk7tgNJquaWyj0Uh9QZXRsIarOJmn3MN3P/7y8+UH/ZTxpZiDW27RbJbcx/Ob4Mdf338IwsUiCpc0TqItPFZL7jMNEv+uXn4epPF8zF8nafYhi0H4wCMcz2mi40nQu14mX6J5P4hlaT3XEznZMU9teheuxrc8pfHqVr5jnq5oGMVMzOLrZbikmR2cqO4to+skWQ1oeFLqBTc776T8bpR/d+L6YkCvHH8ZZQ0acYPoP3cLGhwS4d7pd4P/PvjraZ9H6dWHD29/+vDu559Y3IPVw4ImVIgXdUDIVXqbrEkirg3J1b0hAVzP/2NNw0FSwz0y/gk57UWDm0FwJSaTquYOqZ6+mj9c9Qc0RyQ69+IF45AEPhjPwvQ2Sot1ifexOrycRNN4Ti24i2h2Jkr0bsOvhuDziwfBr2lUrGO6ns0eXmaNVaKrGqhGUjZxINomZioKJ9nchOnDfBwnxoyoT/QD1+t4tooLgqk/0o+Mk/kq+n31NVyaTxmf6gcn4SrkoUgj80HjU/3gTZLczKKB0LXr9XQwidLxMl6sSLnzcvKhkX5olD/kqua3NJmPSEnuWLOd9RhPuSqiQU7Dm6imEvVEVsFyMTafpj/Nr0akPqt1OpCDb6pH9p38SloQo4iWPOMTa2lRWD3LHTSe4j/1V4lZPMnmY7UMx9F1OP5ifJt9ph9is2p8z3/qrxbx+MvMHC75QdFAVKyC/nqW3Azo/8b39Bf/nxTghVDuiyC+mZPx+yRLfM7aLbXTaLT4oGSYwjgZcEeS6bRqmejLkfpSF+P1cZUks6KxVp/JGQqvx5lxv055qFZSuU1Fux6Pil/KsqQP0Sq+05Yp/7ugMuKj7Bd7Sf59Es1Woa1o9qW77D95rXUU5e+UNBaVw6yAhO9uMVpc/5caTSk8V1vj/ZJXumXaUKH5mLW+QXS3WD2IWlTNb/mDmiqzAiPxpEV+eBatKxvLj/qy0Bg2CKoapaLWXhkqnHVn9c9ZMg41aGGUNRIflKZLPTYqfG9p+pgBkLXd/I2jQLQcFbS9VEp8bSsqF4XUUVJ9ayl4S4tWtHSUU19aihEUo89W0Xz8YC9qPGArTu1ZzsNZSuCDcFg0G92FczLrS0dl+vFR6fHaqu8IXM6ie4aaDbXmT9ZWuArTL9SEkABTU43Gox5VkrOwENBv6Vdv/ryl8sWM1o+7aL6y15V9bSlKmOlrPHaKQ/a1rSjpUqSnxVW+8Iy1kvW1syx9ZbMPPCAO68Bf2YoI1Govwl9ZipDyiAmwl9LfWgreJ8svU/IpHO/LvrYUDdcEY62l+BtHAfGfZBn/0zkJ/MDIeMpV0YrdFXYTGADXVlZ60lbhtfQE7HXIL0vF0mhFUPjG8l79TanAnLyW39LB4oF6Nq+Wkl+P5NfS3KuC5uL8hgT0A/39kVwI/vl/ipZf1SXWatujWZOuySv7LpwtbsPvzOLX5Hepj22PDnQjCwuWWWqUP+GC0OH8oWEdV0/oCtIHc5DpL/3F3XghLEK0HEzDdEV/Gs/RXyP55Uh9WZoPLq3WneoIcmn1paXYOraXWMfCBZ1MYvbaaTV8oFIvo98lHKTFVjkHqYgiRPP1HTmlYmEng81jcpdM1jRWarUndJQO1GtvllFESmxil94JO4Kvk1myPFe/ko+3XI9Xr+aT9+QNRZfReE1e9NfoR/neSxkU8X46XdAzkXp8GZFAFWtQH5mPvQnnZDuTdfo9B17SwvNvOdTE4vgPDi3Jz/4erT7eJrPo/apc+9+5x7ZPzNf9yKuMGILCk+bH5uOXhBdqB8X+QLGK4rfy0/fR6tXkt2i8oi8KFRa/MCuiMV/cczuLz+eflh5umE6PKfxAD/+QzG8u13OOq3wflV/OZkL+9lHZ/bwCEV35lTQq0EEL8smX0TRaEoSKjFBXUe3DRTwwAlkWw8BP3K5WCw+b0RwlqHsqw/KuB4oOic3+JYtKLwrfS/TT+G0hDOBS86bvZSUn5A0zLB2WPOSBBP/8XW804ujQaCSm8GMU3Cfzs1Ugwn4czP3lYRLOV/FYuCMR26CIPNz7WxGFvY0eRCx0PZ+IIKeyGTQKgxPxfDq6jkiYRtlX0eQioCXwE/31mZpFv/boxSLOE/xKorS6EBK2oL9PTn796f3bD/SU+IKfOzkh8ZKaHi0/JL/w3PTEiy70pwNhK86DbL1QX7sGaqDK9c0XG2/5noytfI/43rM2qSdxStiXrD15W6ocPT+jDn1PYJi1Jnj5v4rtlo2QQXb5LrMtRZOq+6+KyA/zcSg+LN/lbHbx4UIrdM0n7paUxihvi+f7igOxaVuEqSoNivisOibiY88hkVUUWyHLOxtRGQ/VDL932Udjw2a8my/WK7naysas4hXvgRSDwD8vJCSRavmfUuGkDLNxaPF4qJczzzJK7TjMS9bM2mneXeD9pZ8Yokq9mooP4lRsMNAC0xO9OpeV9uUuDH9iFhWfloqd6IC5LJ/9SW2Uf6jmiVEP4zQKPpCLJZBKXlYE3E9f815PssqNYGaBNK4TOy9UPDgtFT3zk4uzC7VfdSZae6Y7V66OXsOiES9p3RXvO6MGneVP9R1jyDNdGEK5++Y5gqL0oQwgN3bn45eJfmEQs0+9RzKv51CGM2vxFmMqNXs0Cpc36WjEO9BjgRLOg8p+FQOHP/70MgX5cOmaPynt4UrEbx7aYKtFiBBXwr/4SoStonzwuLbsrxPT1FvtYj7j33yjq1NSUlgTCo5RA2goPNuwQBaebV6mC4+3RwyWllkb7d0QD7hgPuk3GH6rtPlwa6xQbZStua3bUAEKLRf+u2gV8pats0iu0Fy4EQKY7fNBAM9x9TLHYM+Ll56+whDqD72HMasl+4RnvcNjqRvcYjyLcryfNWwXi095Rm31ZN3nuvQf1pXHHD7fhccW3WpYf2xFGiyvrUjzImAr1X5Rcje3rkNtW+exUlkKtBo2vzXDUqb18uVsaU1XNm1YZU1r652KMsvreLUMlw86ecdZtk2fBz/Rf6KJisSWXrnknMHVKJxyBd+N0ogs4cT5Wo4pNS6nlib4rKpH4NNYRma3no1jZMtiVRzh8rf+I12pNw9ybCyfBzBR5W63mLDNx8Vjnq26XJhr6xPe822vP/uajUP3Z8/aiRYzyL3cDxLbyoVvqfnWqityLV5R/nQT4bO9zj4R/ErrN1aoaJlpX8T4YRnO01BsIG0AHhtK7wVHNrxzH5Cy4ZVbtNkDaNaX3QPmrH/h7uFn/ft20FyAUs+xBj4FPgU+BT4FPgU+3SU+rV91/KHqw4cky5J8LbNBvYFqTVkJR5zpaQNx1MQH5NW8wwlLG15bhko1r9i4hV4g1F1yk+GzwTj3G1yYcxdj5wsy61tXgJgu6OWuogi8NjBVdq1zv3AznXurzi1so3uOOvaig4537UMXHa/ausWtddNewz501P6mPeiq/UU7a21r3bVX9Qg6bH+xty5b0839VLim6K40t+YVO1LYmjds2j4f9XQXbAje1JRsFn532dYRnMYeeHR12wZXYjjpLIoW8mSVRJ6pMzISz1fNgRH3632iItXWFBy66tfe3pyl5uw76lgnPLmawcs9umpHWrhz1NP9eHPuibM5Q5Y+iDMVlY/txtw9TBva8I/LmD7czIgXy+7HihffsRczXnzFxi1sb8gLJXeEr2resBtcVfOCrVvng6NqqtgPfqp5oXc2b/FIpF9Wr62MT0JrtPRIp7VVvmF+b7QsZbTa6m7dJJ9MX0uJpgGyFGnOurUUap8B7GxsXXc2bpuHJtmK7kWDbC/y1Zzvw3jG54vf/j6OBBjz1B5nuR2tUs76d7NCOavfqGUeuuQqtZtVyVX7TlYkV+VbtcpDf1zF96JDrpe11aNXkvmipRaVSu1Yh0q171aDSpVv0KoW2lMss1vdKda9U80pVr1Fi1poTbHwXnWm+CpfjSnzJTSoSvnxBiBSfrxZLssl2qM1exNdHWjTIg8VKT28G90oVboTpSjVuUkbPNSgVGov8l96h6/gV/hevOTfUWpHS4Wj9t0sFY7KN2iVhx7YyzRYC3uhRtG0F2vtutQ1ub5bW7SwEq1tPKtYjNEWutaihJYg7yJpNJu2eFxRULUocR2FS5oJQXnWqis8kS0KMMlrm36v1tctHjfIGVukTEr6vpp2+RBT2IXMJya/rwOWXYm620dmq5OW5TC7K4dIclQVU9Yq89KQpGbwXB3SqKqG72FQFbNXcVTlhy2G1SQYO6xxlS3f+cCyiS9uxtEH/ttvXPrgBpNbvfOBVItfYSw1YaPvcOo6Dm5EVcN3PqgmPiiMrPmF9/AWaju4MTZbvwf7yu0pWVfBdu9vW0UNB2hZucjOB5QRZ2E4xbUDvoMpSh/cUHKrd79AERYvLlD0gf8CxaUPb4GiVu98IA0vpTCeJve877CadXXugFLT6BqN3/kpJe3UlSRWfthCalUtBze2uuVdIF7bnHDGy7GzHweR4yEPgMiYkJ9DY69NgX5ZnYrSNeN4a24WY17JcDub+kFYWzUa6HFNmnHcH7rZaizAGq7W/MALrdiHTqzqcuDEJT3Ny7StHrGkcS3imqDmFco69GzNxdDTL/7G2VaVabq4RvNaED+DZG+gUlrZSPmHNexuV39v/qU60u8mIqa6sk3HvOvKepAf1RXf4EB9c0+8Or1xw33om2pKbjbYnrxJNYXbH61v7IRPd7dusyXav+EJ+fJLmkmWaprmFyOunrRue77a/1S1/a6Cpz6GWzOEZjB5Z2eoy+/aFzZqPElrnp/Vp2at9Co1I+S7MtRdZNGwMNQVbTBVdUWbrWtd6farQnM3fDq8aas9loSaghsNs59xrSnbej1o7IFHV7dtsEf6RE0Ne0mlqHmfr/p6X87TdEWEbz1NVyX41uNxmYNvVRvcOdGut60HaSed87nEwrOW7SfN884Jz4ra34rRqqNth2en/aqAzkm0WN1udQbQ9/U+wFK0pgArxSfeoFKW71xc13eIcuAoOtKFk36FGbHBQdlSrkT8Zr8OwLP/tevKyYuaf8EP0U04fghuLn95HbzP7tesKyIuo6cBTiNBscJjvYxm0ddwvgp6yXz20A+myTLIL+sU15rHd4uZuvYzmOXvpMrUg3xPexhcyk0yFQobBO+E+MfL7A2rJBjPYqonHUhl/jH8EslO/H25GKsuhHwxvBiAF8Er831Zs+T8j0O+C+uar71aRkG6iMbxNB5zi+fBFT9xda5quY7kle62utKgF6ZBdkN9cP0grvQTz1wJNRhfqWoWs/VNPO8Hk0QITHorrn+dP1CP7+5oMK9DdW18GiQrvnBVNiW5ZhKbq4HKIpOvHckrsPm/0kLWXIk6MAbmQotsnKbra/GyXqHO8/pbxwavZ8n4ixYW00RI6TW/FhNRqLy/9dv5Yr8f5f2yNY2oPuVqi7Rs4lZCadqmp7/Ov8yT+3mN5Jz9Uajpz7NTVjU5c5UB8JwY1YvT01MSWvk5fywV6I7knDSB7GqSprH4OAluk7SsUFzDVWGGrgISLKlYA6r7RK1fUzJGfHvZaKSC3bKWkbxlvipjn1oIxWdjQrjywchZORlA53d5U9XH4iq7VLRXSPwsTlefHPfk6pH9iYp8rsiHT6lecWUSPTzrfzZaJWK7XE40LG8XL7j5K4tWNrcaE3ET3234lU0Aw4NkHAsDIq/i43oH5XbnKIAbMI1n0Si//zBvgONu1fzRwfdU9E32Z2V83DtWb9+/vnz3y4efL/NmyFVvxY3Pm7Bak8X/1BimskhPDkQc8Kr48etwNmM9+VRY7T9Jm5kt3OI1fNvve3Et7OfzwtNiWPUfnz+LXz+bMqx0f9gkzr2+wTk5Ga0SfQ3tXbS6TSZ8KVHtQHChwmDkVZSnSL/33PqmzBg5DOHj2ySL3X4k02R58/O0UEZHYaj2Y6gssnT09soyJpubrXp/RTkI+jXBj/FkMovuCUbv2GvJHBaastwx0d+zZ0JVunyT8yASh29FnewLTEPyiIXNTJO7SD8m7tYdhbM0GQXpenybe0NLdm9eBN9TcXJRBQ0XOSuzGdV8L9yWgJ2RkCzwDfsrIm2TXn/9wPfbqr/llfdjcfUye/9UX7imMV7G/5Sf0XyNv6QDGphIFSH9+xqT7pFzIp6ll1MP7uTjvWhwMzinWq60eyYfSYU0XvUHJ2y1ZWNHomEy6YD9aHJjSZSmZ/r7l38oMec8gAH/57/1+n+e6UUru/ZFDkY+yZZlS1eZju6yxwZ5CbLz1VXFkXD9zXlFg7Kw3L+SZ1ZV+HCxmKkhNo+eVGz2q/y5d5PiW0j060pK9S8UEsb8LpyHN9w+y0JuPpDKi4d/lH/ltSxm4VjI90gKo62i7JnBL/q31+LhvJox+afzaFbXnHyCSg8PRq/lB5XGybuyxyFJaH2NxoODD/z7a/7VqEgIoNQEo3UOA228gkV7VCydDj7w3/9QfxoWOZpOyayM1J3aVKWt0Upp0sFb8fQ/sofPDQsZTvIjT2H6MB/TAvD2a2SJx6XrRbTs9QdVma7K5bD4Z3EpyWRwmP1WeqAIHvLLxquyyk9yiNCCTZQanfWrb89gE1VdXBSNNbUWBp3aXvWjWFDS09IbSytpWQ+G5Q+Kj5dEeFj6u/hwRS6GlU+KBfjads6Y4zDQKL+Q/i4dzsK760l4UVT+wYyvYF8Vnjw3o5lFhFtABfLX8hNm7Vnykvq7+KzUvEmcLuTCbxWLsqLmj0ttfZP9vbH46iqHolX6r+IzhpUYGr8XHxLKNxT/LU15wlCAVYCKDi0DNSg8YZ2AF4GI3wosIHyKZBpE1IZAop6zNDvSliYKJ/Dz2Um3VKz515FRIS3TZIlIkP5Jj9FAJ6LycUJ4hLFGAZOLRquqpCZfPyjANZL3gOaBbuFQOWC5CuUPdMKMiIEXButMXmF75nsZenGoz4Tqnnnejloqa5J9n7W7IqRUk4NBfNtKLQTJZ43nz2trKVG0tq/NwhF4thk3Z33NkgqtdfsKdFBnLSmzSnVVaHFat6ZEEtK6vCZZaF2wlCZ61voAfllTbHtJZxum/pXqtqU/nG2WRVKquXE37GwHe835O/80rTfJV+Y8sesaT3nX5pw3qvhaAvYRp8vkjjyy5XoWif3AaMwVLx8Gxi7rVBcY5ZWNuMQono6yEqW1MH8ykQ87YawHdhK4Nq+SPJPs9+A/2z1/uZ5FRWSVr3z27aiayi5OClW9CN5NtROqWkeusBzbVLupk/MsCEQrH41uuJ6tStUYFdzfxrTgkhOd3KdiAheL3Lmm2vNv4nmplkn0NbhLJlHQ4130WXKTSj+eHEy2bqmIe0azhWgIeebLUnla8XidpiZEEgQ8CNf/Lk5TEV4w3fL+oFCYG1qRAO10X1RmXA2Ix9i/keOVT0GvUlm+JJPtPrd+Hacj7q8AFcPvCelF1ef6J+UembeRVDp33l4M+86BUK1v6uVISc+w2pym7qgXWQqWwLUhisMN7EAWesqLGMG7AtaUCKsQBqJypebs0zWmDjoaXyzX67PiFT9zwOeYhEWoVqr26R+CiHdr0yBMZa6JTjRJpYLJvX25uUsf3JnQOWaMPHsIXrLiThIJuqmMCHHTR2tZJrhSS/1VcL8kc8GWX1qR+3g2Myok6DERBWhebmK2J4UWDYKf57q199HZbEarA6egJDIEx2aBN/uNCjkaqN+ZyurDYp0itBjqnAWqTdR/zl2REUKjtvBrErMrsVo+sLkRLpD0MrTnQh1a3VarK8tM9vVI9obdCO3BO9wJsQHC1CsWX6HGax9UwVZ1eXNnDomNfC4utvXPaiMAtc0wMNs+3q9zSBkaFMLhauNL/nHh2BSwbOE0R+uLHazG68uKmzejrJkiQKX3VUgyVrrRwjleRtOL+kjRZVTYA9KpVVzruxXn0iRLX0c0H4DT09N3OnQv49bkal/l8eCBbmv/Smw5lrgi9I7JWJhQHbQrjsktQVZSy2G1c+qbwf8rf1bXmlJgQ7yqLrqRx99oOIfZb8WH+o8Yr5NaPjxVo3haDpWI4ZJooCYEeinG53WZnsOw+FK2hFWyRVzIoEThHYnLaCmqGhkn90ZfotLSWeEBqcbEBqORMW6jczsEH7KyGe3ltUcUS4sARLaeLbQ8MHgelNrX53Q3W0n+9yByGcW3ZUWj3o5XI/JUTHRQ3MRQMmjTvZJ4np8UZ/UiPxZtJPCSjedWBuKHCkM3aa3cUq1HFE0qfV7YOxf7RL/++u7N589FZb8U8Eus+TmBEak875bxYnemImzBDfl6nGJo3lgnTa8RRxNOHFelXYyMgkkOw5mYVBG5k/OTMUwsJgJyiUVV2A4CJrQMTqeE+OerrGkDE9Twxhu3kxBhT8zsYEGSkd4ma5p/ud0+EwHJIJqna5G1yvWv5EZmwSSLvUglp2z3vkZq75E+Xi3D6TQeDwzlEpnIQgPK4e6B2gWg0iNqUTnTV4tQndHSz1jMVT8YDg3NE4qbj8hPP394exHwbmywnhMADqRyK/GU26XperEQiKBgvV8EPylERVoSzwV6IzlYLwLhcaUCPaqdU1H/RIVZE/oiH5hZSBPdSOznKcBkeAvb9OENrcc3nDdRtlakXXZZ5w2R3KuOp4HelR/mgday3zz/GpI4k8iJnscK6CnkLEWLU0+FeAnhmwgpKXu8GiJfr1dyxFa3y2R9c0vGlPzgPNn1kuW2VJhRJfWcd7glXC6/9zoiVczrkJvlpUpYfMU+ie40zd2Ed01o4So8Su44LwnKF6+uuad/T1ZiB5/34IXpzILtEvXOyRgX3iQx7GmlpumpRE3B2R/yyT9FqrkubSYQZDnc1VpO/31u+fBNEjwka6X1wfUyuU851zS8DpIFDZZA+yS7M9YH0puUkY2lGk6yZ5039POcfSzpLeT2yPieAx+kOTfCB/l/inX2i66ucKYK64pAo6HE6IP3D+kqulOIveeMRl2vRl+/C2eL2/C7gfIjGDO/k8Moh7jXrwIhpWBDqwdfPzd1vZLLrTAhyvGWplMkiLN/xsqf7/XOimqodixObIDDB0yagPK2vC4/CqQzYJ3qTfX7LYGdJWwiVM/Si2U45vFOF+G85xgHHoLh9PQPnYZSGp0/e2elr2IShv6pZVjpJbK2U9HxXl+tw7R8zh5sJeSaPRfQMyCxJ2W9ExuYafDLAw0hKRsbTDZ0PAnvRdbaoFLNQjyr3enx8MNybYmbzSJqxtA9Rh/oZ/QDPzR4/ev7Dz//+PayNOQXromUqTvDILwPYwUECFs/XEcyDPMg4zv2WFlZWkvC0xQvM6BlTXZZYaOv13fVMPglXMqzgu9XS7b+BbRmeXODX5HPvr3vVk9iA4+i6lmYc5B9am9ErrBSeGsDGC6N9rY9ZlOHpvi4H1WTMFza9nEcXmutP+XtV6UFx8rdFzcUG1D3ovmkV6nYXRutHPTghUwwnCSRPHxGCJMP9hAeJfDOeHycLET4bbxe8hI8e7ioqTGNouB2tVqkF99+e0PSur7mLINv5Ry/nERfv2WYShDtWz5HE6Xf/pf/8V//x8BZ4f/2zJuT8rdcz0fT9VxsgI9W9xzdWyU6aSUaySSW1D26ubtKFcmAU0+nvJDLrspfiMvh67KAS4jaPV5mHN6waOrVtcUatbqy/jQ/Viv35r/qoAyrH9VXUyOXmTus7bwxHTXFCN8U/KDgLzlbVv0USCRlcHHV6Fm/tqZiA0psXbZ/0cyzcSKCU9+wjczGeBaF5oZMGScWE0ngtMFpg9P2ZE6bM8ELegm9hF4+oV5acySfSXDF3rsjDLZYBwLBl62CL3bhaheMachKRRhm8zCMr+4jLIOwzOOEZexG+EnCNPamIGxjhm0caybCOI8bxmk4f/MskWq5l0ePWEsDAuS6Q+RaFjYg2E4i2GabACQLJPsUSLZsnDuAaMtNArJ1I9vK2gqE+8gI13om/LkAW1vnjhHPWsYBMHY7GGsTrR0lw9XwLgDSbgFp/awBkCyQ7CMhWZtZfhoAa2sJcGsBt1rXUMDVJ4WrmmgIiTxI5EEiz9OdiioSdz2X01GFXh3jKSlzAOAvbndaqiBMuzo1ZeHBg4e4uYfYpPFwDeEaPtIpqoLpfZrTVIUmwBksnKoqrozwAh/XC7SQuz4TzFnt2RHizsogAHtuhT2rQoU0m44gTh99B+oE6nwc1Fk1vE+CPKvNAPo00adlfQQCfRoEmvHVPjP8qft1xOhTh/CBPXeBPbVAAXl2DHm6NR24E7jzcXGnNrlPijqdW7fAnOaqCMT5uIgzv5oAyS5IdkGyy5Mlu1SuZ4M+Qh+hj0+mj47LAaGV0Epo5ZNppf1i0GcSJbV27ghDpbZxQLx0q3ipVbR2lC5ac/kuIqmbR1I9rQHCqQinPk441WqWnySmam0JAqtmYNW+hiK6+rjRVY/b5uFQwqGEQ/mIDmXZZED+IH/2uWF7N03Wcz/x+3XOPshteD2LpKNZEMe7h8XDwH4R7926eBTmSW/i9cZqj39rbuGuVo9rTD1cV1nO7qxu4qi+ULfP3kfsZiV3pCA8GGwxViQIYqZJZdSiTutspNflUjXS2tzf0rDd83LNFujKvL+dQ03r9DUt5oNff3r1j1fvfnj1rz+8vSJFLNUkYiBqirgNZO7iMVdKfg25WPyFfFkRGJRqWSVkWubkXRBIG3/5dpakqZjpZD4Xt57Eq4fiqv6iVMGHn9/83LuO5rf9C2rI1ziN1RXEk2gcC2tEM0qtisg4CaeJZiZN5tVm8HgGVwXN6V9J4WE3TdxEHCRsi3iQ5zyGy6hUzX1EokWwhcAYQ3A1AL1ocDM417bznBSYHOTfKpcklzDSeRCtxv1i57mNo2saqGQ6tYYL1XeDf5U/S5JHoIsGmgNPF5Yo10eOa31hKz9dz2Yvp4QAb0hZbi5/eS1efB6k6lrieFq4utlS1z356XdxShLIOK4XD6KBeTE0r05sBAtXQluqkZdER9Jx6pMzz0sjTdM8uQ9uEp41IX/xze1KTtCAY3WWigi0RiRMNCW5LyurUtJHjZvfpMEspgGQjpOlFu1c8do0n/BwUANXtwNLTElcYW2/jlp3nn0HrvXv63BJuJxviL5+CK6U0b0aWAKj6+saoyP1txjseU9Feu7QFK0qpGezLNhF9mCkP1slbs/Xfjd3OJmQtU5dl3M7Aku1l3W7ylgu7656tn6fVj8RlmAohlsZcntHvKJYtJiEJDOhjp8NVomYqJH+woYoqm0iC3tx0hjG4JZXnpJeVGAaeQZHr+LkcjF+yziHo2oC8NhfQeouvh2wJe+JS9KbVwy3+5w3VZurntt959hKPF9Hdjea17Mxu8Lxai3ut49kS/VN9JG2N7QYRvfn3BM2IdTdkNeHWci31su+nbgCNus0C4Boe0uzJ78ZCcg14EVixB3q8X/6rkFUtRnq7x4kCWk1WJdSqACsfJ2srF7D5DNuDZGrW+Ea+FZtEHLMyw7/FMPobo/4+qSxHY03WSOq4eVVChwjcWG0qVuZeS5y7PfjUgrfseBXkjaT/d2Jd/lcPMvNghgtLvn0cGnM0nBs4NjAsYFjA8fmYB0b05zDvYF785TujSmLT+vkOFvymK6O3/3PgGyAbIBsgGyAbMcC2RzrAtAb0NtTojeHWD4tkPNp1ONiOtsN2whnP0U42z4XCG8feHi76fJjqNpTq1p5TqByh65y9tsYoWlPoGm2qYCCPS8Fs94ftSn9HGJ/iP0h9ofYH2J/hxD7sy0EiPwh8vekkT+bUD5x3K+xSY+atFq6aBCO0RMkrxbmAB7RgXtEtruUoFaPr1bVeYBqPRPVyi+JgGI9nWLpWYBaHbhaOZiwu0pakHc6azjrh9Cw60yvv8aauaLH0jJP7vu+41FPSOyR1liqAJmNiG4iuonoJqKbBxvdLFl0xDUR13zKuGZJHJ82olnXmMeMZfrQDPqcSbFVAwgHCAcIBwgHCHewEM5q1wHkAOSe9GCxTSif+IRxY5MeE9Q5rj1B3P/x4/7WqUDw/8CD/22J2n24ZZuqhDcFbwreFLwpeFMH60012nh4VvCsnpSRtklAn5istlXz9utxbXgvyC6ci0e7GAQexaPcD1K65mMSpwuGw64rPlZh+sV2vwd/ng4+0H/fCsyRl/gm/5U99OxKN3n3Gpmd70OSZ/Oh0SxJFiPOsheTYntdfpGcePFIN5uE7ef5D1T8nS79mqZU3HMyDHqz8O56EgZZzRLA5m8apVTDZD2jtrHG9atXjvg1gYfhUl0y8vNSLh2F20je6GflhSSiAsaAEm9HwXo+owkOzgoDJvQsJT/HcGBWfOMnOykygjEOSSh/W5NWR/N0vYzSfI3gdwSk/mvhbEW/xwy9snr4MkH9LL1FX8QngWWeovXN9cM3Qbm7f9NgNquNhS1eseBIBEJDlVSKiStSzDtS9M0ovPTywwPj+smiuaOHi6Jku2DV8Kb0c8GZqFdZPjGe42TJISRxBdPgxIE7eo2Xssi5Jk2VglN2eX9NI2liZzEhZWVh2VMTxckazaP7IB2Tactdk/tI5Mit07JrJiJnLNE8MAroX6kLA68EnL9S9/RdsWTcrWereMEX/RA2Z5ErVSc8XDES5Nz2aOqo7gfpV69EcI4djKwSIUbiBuG+WDnILSrVdxuvhMcYinuEylBFN/4slbdeKZzA+IYkkrH3SdH9MK91dN2coDpvMxTZDcM68/C162bFb6ofuS6MrBotYScu2l4Ey4M5ulcN2+AuWC5v/6ZiRIeVT+wFN7z/Udyiyg7/LFo5AJ8T3EtFK10M2VPYQU+b2/0rjdTQ6+rMzOvKbpcd+ThitXd36H+q5YX7mjg49gufoe8pESXh57veyGCven5XPp0HpvHq9+s7eB2R2i7l/cvDUbZYkejdxGP5seu64MzK5jdIWm6PNr4dvMt/b77alKQpTIfTM14kgz9Uxet1PBn8+uu7Nz0RMxyKrgr1oM/FT36i/+dZw9WjNXPXb/LVlPT2hFaZl4QKk96vkV25SJQKWJ8vuqnCPBBofE2GOeIF9q3bP5XGlRAym0sZpwylNc79vbGuh8MvoVy0l4O6e1SFVaqszLHENKOsvp5jPpquw01p2WDg1SgU4tLTxqc2htt1lTkgeDYnvX5zw/oc8FAeab/pdtxa5bCJohzHvs/Vw/LRLS6hFX6Nh+ha5kCNPq8E6qOLepdXXFpO4jE9+0PXkV/mJwMWo9F4FqbpaES/3SUMzUejPwdej/8HIV1GSFTgrL1G5VEWViy+9TqextQ5uR9QU59oUTCNZ1Gt4hkDwJeHS3Cg3zJScnj9oC96HxlYmGObvdrr2BWQPg8+ffZWUXXtsBpYQ5yfVGClOJ6cOIOBdbBQBobFlxoH2k2Dvo++8dpKt2Uphn6H4tW+4eAcjFj8aobaIvpIOGBatMNZub73bff567hiIU7W3RfjtR/o15/oObvInfWdEWESxaH26c7rwK1423Ab7K7B8NCNiF8EhL8WIV+OLUcgUChcboCIT4Q6Kv/LUcnVer6KZ7yfxqtrGvT41NJVqYEDYU1GItwWf43IU9Wl+o5q2dOLGKOpfTtRit8inELhK/KFrfnrHfXE86+JlLiBI5CeNangigwt7sm5Xw1i8ho2WLQZYwttiN/IV2z7dVvj+i6pAwobiBYjavA4UQMx2AgaIGjwVEEDhwBaYgbKLmwRMjBreNSIAfxr+Nfwr+FfH4N/LQHnsbjXjuUL3vXTe9dKEOFcw7nel3NduC7ukHzs4k11cLUfw9Wuv0MKHjc87sfxuJvvMis53pZrLTfzvy0VYeMeG/cILCCwgMACAgsNgYUC2D6W+EL9Yo0ww9OHGYpiiWgDog37ija47qlH4AGBh7rAg/c91ohBIAbxODGIVlerl8IRjrKITCAygcgEIhOITCAy8ciRCRcwP5YghfdqjnjF08crnMKK0AVCF/sLXTx8SDKSGDUHXQxcNF7pjVDFfkMVFjlBoAKBiqcLVHgJpDVMYSnpE6RoMEE4uAAvHl48vHh48Tv34m0Y9Xh8eK+FDh58Fzx4q6DCf4f//jj++9vfJYqEHw8/3sePL8kL/Hn4893w5xsFs9GvL9UA/x7+Pfx7+Pfw77vu35cx7HH6+Y0LIPz9rvn7FcGF3w+/f29+P4nrD8n85nI958tTvo8ICsHdh7tfdvctYgIvH17+k3n5XvJoc+4tBbc6WFBTIRx9OPpw9OHow9HftaNvA61H4997LX1w6zvg1lvFFN48vPlH8uY/LtnLgDsPd77enZdyAn8e/nxH/HmXQDY79LLkoe3SCxsMdgCEIxCOQDgC4YjDDkco1H2k8QjX0o2AROcCElpQEZFARGJvtxNGq4+3ySwS0nt4txSSJUMoYr/3E5oCghAEQhBPFYJoEERL6KFQYrt7Cy01IXsA7jrcdbjrcNd3fX9hAZIezT2G9csb3PMO3GdYFEy45XDL9+WWfx/Gs4/ku7wVyxb1HUkC8MxLnnlFRuCdwzt/Ku/cQxgtHnqlFI7vwy+HXw6/HH559/zyKiY9Ft/cY3GDf/70/rlFQOGjw0fft4+uVih46PDQHR66E0HCP4d//rj+uZczU/LOVRn45vDN4ZvDN4dv3l3fXGPRY/PMnXYAfnl3/PJMOOGVwyvfl1euR/+gctl1oy8VoIRjvl/H/KPTdYVH/uw8cjlcNXPuPUglR2Jzx7e++g0HrtnfgNsLtxduL9zeZ+P2ZmDv+fi75kf/28IzooKg6egunkxm0T2BqsFd+HBNTiABm+l6Li4WH63ueTCpbxq06nXDAxXV4AgXjDnfPZCyTKdz3X8RfGSYeR+dLSOjjYFqI33hKLaIlnEyiXkBeQhW8V1EMLQMnGfJjaO0eCoM9HAFd/HN7Sq4joLb9fzmPIgH0eDcqUUvGJEvg1u2IsH1+mbgxGW5d67XURXQ4C/da0A90G0NevaCSuyf6okYiuWSrQhbrurbhJkP/juPZRpRJyaptbr7WzJSwYflumZJmAibsIjmE5YbDR1Lw86f1Y/kJ56Sz/UDqXo3VD83AXIvgte30VjYb5L5r5GocxJwbdzb8W1NyZRcrdlEeL5BMh6vl6qWZZ2xr+pUrdGfRfMej2ifnfC/1ttlWsaipXV22QPVoqDcO5aH2tpIWdkdIrPIDArNAGl69n4Vz2YBTy33bkoLoXKr1VqTWangrLG2M3bF1QIRhFMO4Syjl0tJ58B+ehZC0KN4tgWG0mPzL8NmHTBVPZ6voyaQr9wVXrF61VZM4zlbTPvEKnUVNbAQ9GoWZvGQRN+9OnH/KZJxr3C8WgtbLfWTwYuwkGSy42lNeRmAiFmmFL6jRZINPDXwbBUQ0AjCmuJKnKR0TfIghFFVmNaUn0dfhSisljH9Njkne7/K3z7mwAjBkfWqvgfG666jcUjLh1rxeJRFaKChvBht91zUedU5AOJK3HBXtLC+mgVpfENY3wOJHHtgXyxsepioUe2Y47q7WZBDeuwSYJdgX7sEb8I5NTdZp9/H0WySIncPWwQlZ7gkIdgpQO7eU+XuNYqiJXevVGYr9ht7XSDgBQEvtmmwTYNtGmzTNGzTlNH2sWQnNi7cyE58+oBDRTgRd0DcYV9xh/erZElqMl4vU2rYj1GaUvMPKlXR2gPkLT5OUMI6+AhNIDTxVKEJT4G0BCgcdmSLMEVdjQhWIFiBYAWCFQhWIFjREKywQ/RjCVl4LugIXDx94MIhqAhfIHyxr/DFJenqQUcvbB1A8OJxghe2sUfsArGLp4pd+MmjJXRhNyJbRC5qKgRjEtx8uPlw8+Hm79jNt0LZY/Hy/ZY+OPlP7+TbxRQ+Pnz8ffn4NOrparker17NJ4efrtDYG3j/j+P9N04EQgEIBTxVKGAD4bTEBTxszRZBAt/akeqAVAfEQBADQQwEMZCGGEgz1D+WgMgGAADRkaePjngIMEIlCJXsLlRyYsQvMgd7nggZSAV5lPDH1VvzoaB3L1cjsuRZpGMYnIoPTzVfUiFgIpnNTvWfpycFaxZc8mzcRQIGFkdgevpqtWKqCDl3f1Re/Kdcus7+KEdw/jwLTktVJfPgTGui5BULJkkkvf7od/L58wJqaF5oX0gvhWOlq6lcRPKYwGj0WtjOvPk8YfkMeDn/y1i6XUXlFBN9ETg9KdXEvIDylWqKyLZqD+vEElyoZ0bsBy//V0YoJit7q546cXrSoh+0ukdc6VibOlpaw8mkpx1cKdWEsQtFWconIzUQ+r3C4JLg6et9MjdUPHceEJyP5/EqJvdPfDKsvERgEEer+v3yGpv5/lUlNZmZcxUtS0TrOIBsttF5lykR8zhUP5u1/sTi7X9I5OCZb5MNKA2Ea/2TxHfij96JK3JS7cCnRiGVJUsshMU+iZFXtKFsUZTMaivBmEIsJdWGSYK9ofxRbZ3h7mcm3jllhvUZnhW148wnbOcVw6oVnL4NFlr11AIAhbA5xEzP39A9kWLNyANV4s/qU6RiM15ZScbWCxYYo0jlK1fnbD5Z0ZTKXv4jm/7LqGKO2AfKCSCDXFTOg9/W6Sog9C5Xv4XGO0UoUHQZt3YTXwTvpPslwxf6oWCyjgRToHTVRLBduEmylScVL0xBM65JVxGTUSNIHiTT7AHu+NWv8y/z5H5+VapER/3DYDyLCUwJULVahvN0QfBgvpo9yLYMynsk7s6TKc6a31MfWvwwiQbU96VW/ZDcEMJ8CAgC3hLSnJGUyCdZcMdfuIFjWstpqO7CL+RdlocmCtOYhpUxzSS6Xt/ccIiy+EypxE8/f3h7kdMakonIqEW1x0yTyTEoZty8jhSdYnVP42qxvibf5ls5MN/SwHyb8R5/W4lCLR6u9IyVNiDkuAgLe1Ei7f9Z8CiGs0/85WfFNOssnS+ayii8sgw5x9dSbghHhPSknfsGo/q2PbKfEjGMPPRyV4f3HHiA5skkuuLRpNEOZ9SkyYMYb7HrU0XgZVkbcfnf0tHigQzwfCApYUeLJY3ySEiHEA4Xcacvx+r09FctekGPWm118bS97wc6WvPn3wpaR508U4p39u/z0+BfnO87Oxv8RhYqi6pzH66pMwOS4btwNcroMzON8iUllnq2VVixIYyoeuiKCha3S8WO24SUk2SCZzwgHWVMTsJwH5L9WSVOL208W0+ksTtb0NDQ+jzQzopcjTXQJ3DgqITJUqkFvPDMQ+ln3Mhm8DjL7cMv8ZzNp6OGU8MCnf5N8TPHqzNynNYL5sSOZovpesb1OWrILNI52xPhlES/LxKapJjDSHdkdcXS5BwHKRJOd/VOhg+G09P1RiJ82oAp7QFWUlO78BRskUGFzCEEawF+wGaMzIr6ztLmU7wUTaLxjFYyFW/UtUnxrSpL38nRHhnrra5TLs6pXEElgfpt+NVFmT5O7qJgSo4LtT0RMserv6ZaJ/nPa6AnXKEUpahXgoaXhypz3NX2Pn/u5m3Py+vNfvE+weQ+L26ax6mjDvUiPQqD4AO/nvqS3DMf/CT6Gs0S1gWnLqcs6Q8B+YJCnYvjycs6fRovgyvJIOmK23AAmsybGEpq85y7oriqx7y+iiAVc1g74/0vzBg4b4nL95Ixy/CUPXdDSbxGszKingq5dkec2/B7T09/MdaRXJF5dkvDtZ1uuxcOkVLjp9NCnx0Gz0ud/RVxV7Bi99Ci/RQ/LsTYJcxw7/Ip14aE4j5MGUqHFfVmVXXfapFZWVocqXOZ4+KIzW6PbrZHODtDOTtDOrtBO7tBPDtAPZ7IZz/opxQ9bwoH+CQ8kJLw+C3IT149kGBQr8T48Rp8+ctrXsGuozzV4W9yuFmA1mnEY12SH1YbMlI0ncZc+UcwJF1zvtGsxnDwJuLkPNF+VsWJ+FMCqXJ/CB+tU3m9QRpF0gCodVXebiN2G1bLB71A6+ArtVm896SMMUQTlJjH7Osn1ICIYcOcZjKaXAS6veoemll8R5KVTIPv/vrXUm2yhK40HQTvI6leokwa8BJR7lEQ3K5Wi/Ti228zGmtCNvzHzTK8Y+15ebMmHU/l9y9lVd+enOxnhfFZWdotKHZJn57+IaK65mT3B6ORSjP44+wiOAv+heRsWXxEX51S+aIf/K/gr3JP6OyMFi/7a08FhqT/aSkSd0SoJJ/CvOfTrqbzPBcS1hAySgsJ3ahsNnW0NNrfa5OEzWbetfb6r7nFcWtww7Zc+TZf8Ta1sGbvnHLwlLKwa3moD2j/a5hGb7NLUcI0vyGlbIl2AXkP1xBlw+KwQvn3pgnKP/W0P+0xtb9eG43pqlJvDV+3hq3bwdXtYOoW8LQBlm5qLJ2ifxH8kX38p8vEWO+4cm7JL6O75Gtk2ZUXxS0XOfIY80ZEdmNjugjnvZMCGqTR4502ArRX1v25q9ze/U1EnBTA1VEoI/8kWqlsvBG9Kis1FOcdTvKOG/kZ9ekZG6dMbJHX4Z1twf9ulovxqPyy8uaPxu70rDAR71Uqgnq13hcycjg8N98vzESh5YO4+i1axtMHeQ8Xp9WzpQ3Vr+I73m0TWTXG3XpansL16rZ0obXcvZe1ykT9oi3TaYfZbrH64DzPnpOacmJPb+I0V7ITZNSjWRJOTrkPiYAC6zk1Ut2ZyV/RyPNJGJFdYoaUX+TZAKvgbi2VP5XhWxGyDFfhdZiKzFbyumhmZpFReJms55OXq2W8UNFR+t80XkYv6R0vyVyQXfsb2aXrlEVM7LpyXpxhVl8EVyNuH6eziaNVY740cURF81MJq5FumEh6k3cjkuqbveC2qlHg/WVqtUzd+xIvjGCnfn2ha/lMvjgpLhMXPPlLqjGZ6j3Su/ALG2h9VZ0OLvN7m8Y0+ioFaqXGSWzI8xY4T7lo7b05tHKDdi4u1buN7gbBa71YiWshVWf1fYj3Qh3T0tyKDe5wLN/PqEGVsLbPiIO/CNbzeTRmm76M2dXlqxV7sokikM5NS0hD7+J/6rv2ONcxNNuvJSflpE8SwFlCMjWNZ9TOvn3MP/K2tByfkbiZcaQ0UjjTmVLyRYLZbZOFV0bzOJy9TKYv1XIchCuxWH4l68PZBXILQoyfzEhIi1fyqUs05XtSXr5pCGPGgXq8UyrtkB7bMTNVqqj1xQUoS8M9tz5kOxxVMALGLaMZOBZ7HQQGeMEW88PbJmqi/9I49NcRlYtGYoh45M8MMWKD0uuf6csNTZlXks2lhBngYIopgXo/ZURyNJJ3ohrFddPNVkeF4isVYJGKUcZnL7hJvPNUfOciXJIZjBf8dI9wb0zwmeoQuletQl+sWXwzrdg6QyifbYt1Khn/oiTU2zXb1Numm/MXLC82thsvXAl+nqtir2+tYPBLuEwjTkd8TxpB/pClGQP9sDVjS3+Zd6bpiGZJ6k4aD2daT0CdOzNGhtZ8EUPN2EEyWnFx0uKAqTTIzgOz5yetcqEdj9f3VbSSQEmyJCs9NBFJ9mmvJnVf5fzVHk5x5QHWghv7Vhs1aWhCKa+0UEs2uCWJL5/CofF79UFGPbnHkCyHfB+1LW/wP9aEcdKGR4X46LxdKQ79i5Pq9qO6SbloPHzybGvya2sHb7fHj08cicOyx4PszJCqwfK8Blu0Bgm4o3Gm9qjSK+naivNgcl2hJUblrIsD/ZZdthfBvcCJc3UrsUqgI6zMKwIblFNyxOcEL8ZBT2gxveGlWqIIsYqXRemJdTteLIuJTEBgwybC8fy7rpFeQsrDiKzPyDlZTkSaAJX9XaySTpYEfed0ZrgZxYncuPhmTqvyJ/ncS5qadfT5pOwQpmQFxMm6es/wmx04iUqbbU5i6cxUg8Pn8uxMj25NMvTJ2xv1Xes+X2zu8pK+Np4u0xbQavj2egir5D5aoWXzySq7i98/2QpddMfrhrMNZxvONpztPTjbeh3+C29qRcUzoy+4sIYlego0quG4f8poQsEb7WhrQTZqkVBBnLZkMiDtC/ZIBOV2YhhcSUm9OhfJCtc0PPce0gD//9n5/y3d92rSi1oIhKwLldYSbsB19kb/UvKR+ciT2Ky0vVAdYyeMPBwG39lKmoDR7GXhWfOhAe+i0NzFLLnMtBCy7ai6UYUy1ef7lr1Quy/WnGtXxcUfXr3/t9G7NyMmyakjBVj2HJQ6dYP56a+fDVaX/tanqA3nRPudzyKWc4DBHO9ABqI+2wdzNonliPx4vQroS9SUEDBHVrrtuWlv3rT+oC6ApMnQTM8+P2quackc7VCGvzLD0uror70iRXnsq2osCxqoD786BtDjJG/jaeD8uO8n/vHZL9QllykdtZEUE+Y6tXVwrGkhrF/ZPFfDDVfE+vWv/lTAtqtjwwrpIDmryfI/9zxnaJmj5uXR/YSi5Hg7Xy0fFgknN09FEtL8pSZTIV9hxUyVmlSG/SqOCXLAIbjhNGrxhQL2eTBwT8khG8fw2mZlKHmwGodShHEgjL3Zsp75R/+kpE26eJGfqXBqj2lS1iEtsqtIplVeqXddDQoOYTKfxsu7LIFMxxtEYFicc2MQIIO/15EknRH+dcGVU5MxcPOMqLWbsd7XaKTqVCHIxSwci8ytkTzbPpBfC2cj5PWsqon2ATh3PudYaTzYC7LG6ay8V/kra04MJGkaMy1ARmxLzuYymAh6k0mkzqtxEpXRg+Ddm5PyqbdQJrmxxygiiOfiZJlIlwtnaRLQ4k/+efl1cZnEV02QIDii9Y1aE0gvWcbCdB/5t/mck/DCSXDDlS4WlcPzet/AyKdjKEufyqRBo0epbHTQu2fRiSq948MHg5tBIOI3wdXymg/Nfb2izo1vwyQN7pL5l+hB7FCQH0wmIvhenXus9C9MmSRCkg8IHFwhZygd3BfrWGHREIWdyZrCRLwX+W2vk0k0+PWnV/949e6HV//6w1sLeDs1xCQ4+8Mur3+eqZOh6/lkwOexHpK1Je/1lI9kjFlRJzxHgkXCqF1Gls9VlkT4wHqqoy6Wyrh4KtJTWc/TFfMkiOHlrLXTWuoSkfTKdNVzIUdiaMXxVhX9exC2n2mdB6bHb9X9vyjlV7oeV5g3dIT4p58/SAoORdItC5Ak0Ar/uFP6Xrb87I9iw/88y8KLZkfzA7+nlrqUQv5Nm9ezP2yjJKre4aRkJS3John7xegunkxm0T1JnabvWc9HWQ7p6p45IFdJxval91ZLvrTYz6OSxdFvTqrcbLG17YE5MjFtW0WlZMwiz5WNfZrE2uo2uENZZZ+7SlytnG7XFqjLU611UL28Txs0Gpp/+GLL2nSZ0gD4bEC26urjskLWxRC23KB0j6+Cf15+VIF/VIpWnUTVCketGGyYeNFS4ErcFrsgm5LrzHaEU9Ujm67mteYnlrn0hhjT8Kj8ejawBvmtFx3ui+AntWcj6BzsewzyIFVld8Qgx1B7KlfVZXbEsCtrwJVgYLIdwxB5III2SrJraF890L76IPhZblqqEbdU4my+rkPzJivirjEtZpakFfJ/1M6eAM78lDz/epukCkzLP6M70qCvUSEEa61PoP/4jnfV5e6M0FAhSmk0V7trJnJm8lNa6R9Ih/9mqS/lLSHpFglO9TOuc8b3MERy4EQCAGFrm2jnR2NvaGrW1xyvUYRXL/lkHMHr5Ns4TUnxv/3vf/2f3524qTPKjDD56pcPCEfvm9e/og0rlXfukVSUQv4yIOUS3ot7mayEgoaqaOWL4F+yVpkyxWolpL0+/pQb0nAyEkSrIUMovWbR2CfLSTwPyZ8dlZ45b8nd0HdE5Rp0Uv5wMU+1xPWbHajfx6F6z4P1tZba95CnfNcv4l2CkiYrY7xXdEZR2+W0dmIn3WbKVFaI3BY2D+eZVXJGjeb9UWfVbKl9wuWgkox/pE8s6xdhNh1ImCScFXH9wBA9XM9WtlOGvN9uMR4sYfI/ymx899/+5//9f8mgREptj+x8RC/0/qvYeuXzg5KWT+dHKCeIM1ZUtkYaTi3z53Om9Sw/05rNzr/PzzY/HNrrb3wqVx5n/VR3RLZ4TvCzV7z2RXCp2JJKQsjzf6N0SA7CX6qFnfmroqTgTbQok87yss5u3gIZAipmOWQEjdHv0XgtTu5+jUMrFSE54b+lPnprPTmptTPj23SghHOgg+eJDjbdO9pi/8hMv+o6asg+FgFS93lh7b+KXQnVkp762b9w33Ihwj39SlL3SPjU25CwX4p3PwYJuyiyJQd7U+Xl2FXFMT1MZvXSLG+WIHC0xOoF2ThUXnXx8ylp1bOo404DRWAlBys5WMnFT5CS74yUXBpLcJKDk/xQOckrEgxKcsugg5I8rwOU5KXISVcpyT1U271sgJG8C4zkO8MXu8QY7vAUCMlBSL5zyOMJe/YCfWzn0MBHDj7yA+Uj1xIPOvIAdOR7pyPP7CvYyDdKVHm2bOR+Zghk5CAjPxYy8sxU7oGLfBGm6eHSi9fmHWyaC7BFvkKnycUdyQkd5haXgg+2M7Cdge0MbGfVfJ/OcPqYO+fe9Mya7CY7Jt/MguPNgOPK0/Env/Egvqk9dthvQ18k7cD+6ItyuqF81C1cyDIhz5ntVWZAbs6H6wgBstcJThtJby2++mZ7qHWQFL3FRL5nz9BrMyWPStBbGO9u8/MCsAKwArACsIKeF/S8oOc1hQP0vKDnPQh6Xl9XHuy8u45NtItPeMYoGuMUDnGukPOKXYgjYuetCW6olpkuPbh5wc0Lbt7myNvBcPPuZWd158y8ji1NEPNWF3MQ84KY1+gdiHlBzAtiXhDz+hPzOtZa287XgfPy1rg+jVtyrfxOGy4CLW8tLW9d8MB3V9KRvOce3i1ZeWvkCaS8IOUFKS9o9xyHx0HKC1JekPKqd4GUF6S8IOU1yoOUF+gApLwg5XWQ8r6PVq8mv8kUr224eR1JvHvg5jVbvCVFb0aqa1SpdoGfHS+vfaI3yxA4WnreouwdNkuv2ZenJOutUcLeSav8Co8cDZl+keWViD+rT5HqzRI+Sz4ZrRcsQkaRylettyzBOQzOYXAOt+EcNk0DqId3Rj1cWAHAQAwG4kNlIHYJMoiILWMPIuK8DhARl6JFXSUi9tdw9yICPuIu8BHvGnTsEni4A3SgJQYt8c5xkCcW2icesh3DAzsx2IkPlJ24JPggKQ5AUrx3kuKytQVX8Ub5O8+Wq7iVUQJlMSiLj4WyuGw4wVxcys7wSc7YMmFii9yOTvMY23bqD4LOuKAUIIkDSRxI4kASZzECviRxeqL/Aka242Nkq2NMta2Qvf4uiN28Dpx2hsvLklzizc59EIxe+yXqakgjrAU9j83X5c1ttjWx1/kmzF45V1WBQdw7c7cjROJbE1JpFPZRMZhm3I/KBUuvpJM7npF3l5GaKi7Tc8YJ97YTWPcCQGpOVJWARyCalwq2Mafkks8Jd4yDnlBpesNLtXYRlBUvi2wnbAjbiPVSE68wHQqH6vl3XSO9hDSJoVqfIXWynEjOnmn8u1g+B64j4pr3K7PoDO9Ebp08rPtJPveSpmYdfXaTtPu4kt/szKs8SMp2a3L3s2dur7Hfj0rg7oAjHeZxh6cOTx2eOjx10LkjeAA6d9C5g879UOncW4aAwOp+DMGioyd3b447ZQ2shAJA9Q6qd1C9N58tOBiq90dIRdk58Xt9Dgj436vLPvjfwf9u9A787+B/B/87+N/9+d/rl1zbNtqB08A3O0mN23ytHFUbWAIbfC0bvEfQYcudTvcob0kK3yxd4IYHNzy44cH+6uDzADc8uOHBDa/eBW54cMODG94oD254oANww4Mb3sEN/yGfxV3RxBtVHhhX/IYhr2fCHt8oCptlI4BI/hkQyTtk4yk55bOI5k4DTyBjBxk7yNgd6g5e9p3xsrsMKijaQdF+qBTtHjINtnbLNICtPa8DbO2l+E1X2do3Unb30gLi9i4Qt+8RlewSmbgDaeBwB4f7zoGSJ1h6JMBkO4YHOnfQuR8onbtbB8DsHoDZfe/M7jU2GCTvGyXiPFuS901NFfjewfd+LHzvNeYU1O+l5IuWuRePwAJfl7oBKvh9UMG79AVcc+CaA9ccuOYsRgCs8KoGELuBFT7Tww0oweqzXPwJ4kVatCmDrlxo/57vj0zsCZnB/JMIa7HTMyIJ03RONpowx6n0jdJ0u80an5Fa1WYMbUb0lach1/TWHO4GRrC+x4Fwq+WzEba3dADB3X6E3O1+RhM07rbZgpcNLxteNrzsfXrZYHSH4w9GdzC6g9H9cMI3IHdHCOe4eN5bBY30iWp7GbC/F2YY7O9gf68PDx4I+/vjZqOACB5E8CCCBxG8sciBCB5E8CCCBxF8d4ngW3lRjduHrZxaG24CJ3wtJ3y7WIXvDmpdirR71LfkiG8leKCLB1086OJBCOsgFAFdPOjiQRev3gW6eNDFgy7eKA+6eKAD0MWDLt5JF//wIXmtN8dflwMC7cniL0VbdsgTL8mDBhnxRXS3WD2IMm/5t02p4RuqfYZk8LUTvVnCwnOngm8QksMlf7fIAqjfQf0O6vfnSP1uUXYQv++Q+N1mTEH7Dtr3w6V9b5BokL5bJgGk73kdIH0vRWG6S/reWtXdywoo37tB+b4nPLJLTOIOhYHwHYTvO4dInjDpUaCS7Ywe6N5B936wdO92DQDZewCy90cge3fYX1C9b5RE84yp3jcxUyB6B9H78RC9O0wpaN5LSROtciba5zFskWXRBUp378SKTpO423QB5HIglwO5HMjlqrlKHaJQcm/2e/Nfa2qhjEOgmXOoBd+QX+qRP9OQB8tQ7WHMfhvyKGkn9kcelZM95bNwXuUqksmHLRim2+b+dYRf2uucq52IuQVE+2YbtNZl5uWm9MUj4Fputjb7YFpuGPiucysD/AL8AvwC/IJZGczKYFYGszKYla1ZG4fErLxZWAC8yvuOc7SLdXjGOxpjHg5xB6uyf6Ak41S2lACjcmF2wagMRuW6qN4BMSrvdeN307Cg944rSJOr6z9Ik0GabPQOpMkgTQZpMkiTK6TJ3ousbTvt4GmSvd2ixn2/Vj6qDRmBJLmBJNk/8OC79enINnQP99bsyN7yBm5kcCODGxnsh45z9+BGBjcyuJHVu8CNDG5kcCMb5cGNDHQAbmRwI3txI7/9XUajwJF8JBzJzgnfLA0BXMnuvhwMV3JJJsCZDM5kcCY/d87kktKDO3lP3Mll4woOZXAoPw8O5RrJBpeyZTLApZzXAS7lUtTmMLiUW6m8e5kBp3L3OJX3gFN2iVXcoTRwK4NbeefQyRM+PSqEsp3WA8cyOJafBcdyVRPAtRyAa/mRuZYt9hicyxsl5xwJ53JbswXuZXAvHyf3ssW0goO5lJyxUW4GuJgPnou5rBugpQMtHWjpQEtXzYnqKPmSPZmgg9zMzalO4GjeG0dzm9zD58XV7AnlwNl8HJzN9VYI3M0AywDLAMsAy+BwBoczOJzB4QwO58ZTUxYn5fA4nNuHEcDl/FhxkXaxEc/4SGOMxCH+4HRuH1ixcjuXSoLjuTDb4HgGx3NdNPBAOZ73trEMrmdwPYPrGVzP4HoG1zO4nsH13FGuZy93qXHfsJUPa0NI4HxuwfnsF6A4DO5nL/kDBzQ4oMEBDZZHB18AOKDBAQ0OaPUucECDAxoc0EZ5cEADHYADGhzQLg5ocix/SOY3l+s52+3vo9X4tlPUz84itpZflj1l8EGbILTCB107+ZtlLoAG2t2XLtNAW0QB7M9gfwb78zNkf7boOkifd0f6bDOl4HoG1/PBcj03CDQoni1zAIrnvA5QPJeCMp2leG6t6e5FBczOnWB23hMY2SUgccfFQOgMQued4yNPjPQYOMl2Yg88zuBxPlQeZ7sCgL45AH3z/umbHdYXrM0bpdM8X9bmTYwUyJpB1nw0ZM0OQwqO5lLyRJvciR3lM4Cv+en5mm3qAeY5MM+BeQ7Mc9Wcpe7wK7l3/bvBzuyXgQRS5l2SMrdNADx4LuYWkO2bnaM38DJ3mZe52f6AjhlYGFgYWBhYGCzMYGEGCzNYmMHC7Dq0ZHFPDoKFebMoAciX9xz2aBf68Ax/NIZAHMIOzmXvuIk+rugOD4BhGQzLYFhujvEdDsPy428Lg20ZbMtgWwbbMtiWwbYMtmWwLXeHbdnbUWrcBGzltNqAEUiW60mW/QMRneVW9pY2UCqDUhmUyiBNdJzPB6UyKJVBqazeBUplUCqDUtkoD0ploANQKoNS2Y9S+WMp3aE9p7IjnXhzTmXvWzzb0Sc7ckhk89U+8nPnUP7oSG5pl4oAEmV3Xw6HRFnKwlOyKPtoZO+kVbqGR8qHzObI0lTEn9WnSA9nCR+zn4zWCxYjo0jlq9ZbnWCFBis0WKG3YIWWNgK00PuihVaLA3ihwQv9THihqxINYmjLJIAYOq8DxNCl0NKBEEP7qLp7WQEzdAeZoXeHR3aJSdzxPVBDgxp65xDJEyY9ClSynSMENzS4oZ8HN3SmASCHDkAO/djk0Ln9BTv0RplBx8IO7WmmQA8NeugjpYfOTSn4oUuZIK0SQdonZ2yROgIu6L1wQStdAAEeCPBAgAcCPIsR8CXA0xP9F7DNHR/bnBcrrK1gS5o6rzOuXWUmK+SneBOYHwQz2aMSjjmTFGsR0GMzjnmTtW1NTXa+CTdZzqdVR6/ukRvcEX71rdmzNCT7qKhaM5JL5YalV9LjHc/Iw8vYWxVp6zmDhnvbia97gSY1+atK7yNEzesGm59T8s/nBELGQU8oOb3hpVrICNeKl0W2Ez0EdMTiqelgmKSFQ/r8u66RXkK6xbitz/g6WU4kk9A0/l2spQPXCXVNUpaZd8Z6InNPHg7+JJ97SVOzjj57c9fXu5PfbONZgqf+cHjqrfYbRPVw1OGow1GHow6mesQOwFQPpnow1TtPhlpclgNkqveOB4Gq/qgiR+Cq9w9C2cnqZQmw1ZfON4OtHmz17iMKh8pWv+skFTDTg5kezPRgpgczPZjpwUwPZvquMtPXuUWN+36tfFQbMgI1fRtq+trAw5Zbn+7h3i03fZ28gZwe5PQgpwf9rIMjBOT0IKcHOb16F8jpQU4PcnqjPMjpgQ5ATg9yegc5/d+j1cdbkkvhlW9DSu+4221zUnp3EbPJlauP21HUN7Xr2dHTO+Z7s6yD505L3yQdh8pLXxCCp+Sjz+KUOw0egb8d/O3gby8oOXjbd8bbXjSe4GsHX/uh8rU7JRk87ZbBB097Xgd42ktRlq7ytLdQcfcyAn72LvCz7xx37BJ7uENb4GUHL/vOoZAnHNorJLKdlgMfO/jYD5SPvSz54GEPwMO+dx72ir0F//pGyS/Pln+9nVkC7zp414+Fd71iOsG3Xkpu8Mpt2DbfYIvciC6wrvsnQHSYdr2oCmBxA4sbWNzA4lbNKeoMV5Ftb96bs1qz92Qn+ZtpfbwpfZoyg/xpfDwofGqPRvbb8DJJu7A/XqacRykffQsxtEwGdGaYlemg/XPxOkID7XXa1EZV7IXEvtkdKOsyYXFjUuGzZyyuMzL7YCpuGvFuUxUD3ALcAtwC3IKiGBTFoCgGRTEoig+Worit2w9q4n3FMdrFMjzjGY0xDYd4Hz0lsUcgRLXQ5vaDghgUxKAgbo7WHQwF8aPs224c7vPeMAUTcXW5BxMxmIiN3oGJGEzEYCIGE3GFidh/lbXtkx04FbGHO9S4kdfKJ7VhIlAQ11IQ+wQYfPcyHemB7mHeknrYQ75AOQzKYVAOg1TQcdwdlMOgHAblsHoXKIdBOQzKYaM8KIeBDkA5DMphB+UwB+4+0iuzFbZTtMPeN1m2Ixr2vlrrmfAM10zyZukEz51ruEFADpVquCIHoBsG3TDohp8f3XBF0UE5vDPK4aoRBe0waIcPlXa4VppBPWyZAFAP53WAergUbekq9XBLNXcvJ6Af7gL98F4wyC5xiDvUBQpiUBDvHBZ5QqO9wyPbiTjQEIOG+EBpiG3SDyriAFTEe6cittpd0BFvlBjzbOmI25snUBKDkvhYKImtJhS0xKUECO/8h/Y5CQdORuydJNFhLuKqDoCyDZRtoGwDZVs176gzxESuzftOcBL7pBCBl3iHvMTtcvcOnZvYG459sw0y6zIjcVPq4bMnJG6yMPsgJW4Y9G5zEgPkAuQC5ALkgpcYvMTgJQYvMXiJg0PmJd7E/Qc38T7jGe1iGp5xjcbYhkPMj56f2DMgog9jlp8GT3FhVsFTDJ7iusjdwfAU73Ejd9PQn/cOKsiJq+s9yIlBTmz0DuTEICcGOTHIiSvkxN6LrG3L7MC5iT1docZ9vVY+qQ0VgZ+4lp/YN8jQVY5iTzkDTzF4isFTDCZCx9l48BSDpxg8xepd4CkGTzF4io3y4CkGOgBPMXiKG3iKK8dVwVL83FiKa8l4wFGs/j13jmIlBWAoBkMxGIqfL0OxEk/wE++cn1gbULATg5340NmJLbIMbmLL8IObOK8D3MSlCEvXuYm9lNy9lICZuEvMxDtEH7tEIO7QFniJwUu8c0DkCYr2DIxs5+HASgxW4gNnJc5lH5zEATiJH42T2LC5YCTeKAXm2TMS+5om8BGDj/jY+IgN8wk24lKag2eWA7iID5iLWMs/SNpA0gaSNpC0VbOLOkdFVNyk7xQPsTtNCCzEe2Ah9snNey4cxA0gDAzEz52B2G5bwD8MYAtgC2ALYOsLbI3DUGAfBvtw8aAA2IfBPlyb2gL24W67/OAe3l8Mo10cwzOW0RjPcIg4mId9giAl3mH1LFiHCzMK1mGwDtfF6g6OdXjnG7bgHAbnMDiHwTkMzmFwDoNzGJzDneMcbjyaBMZhm7f5yIzD9aGFrvMN18oY2IbBNgy2YfAJOk67g20YbMNgG1bvAtsw2IbBNmyUB9sw0AHYhsE27GAb/pgsv0xnyf02NMO6jorbvG/eYCeDsW7RpYp91DAIV5KWeC9AwiXFQCmUn4CtVig+hmp1yV+wS3qWyhDxUlpk1pr1nTTAtKyrRNV0vYxs4fOrUZYBMhpp/qYSr45Sw2q+SFZwQKs4r4xpVRvrSpFS9orf97clOq5KV+vUhfbUxXvlIvYWuUNlJdb9AB0x6IhBR/z86Ii1foOHeGc8xJnJBAExCIgPlYDYJsRgHraMO5iH8zrAPFyKtnSVedhPu92LByiHu0A5vEugsUuw4Q5sgWsYXMM7xz6e+GdfGMh27A0kwyAZPlCSYUPowS4cgF147+zCppUFrfBGuS7PllbY2xiBTxh8wsfCJ2wazD0QCTftCbND37dQDztp5ZpyCp4tn5z/5vCzZ5ZzbCPvg1LOe9S7TS6XjRhY5cAqB1Y5sMpZjABY5cAqV0r0AqscWOVqNzHAKveYrHKl9CrQye2DTq4mR9WE2OCRe2oeufr8b9W43E0Dc5wxh2COA3NcXXrFwTDHNYUDH48yboPzQiCPq67qII8DeZzRO5DHgTwO5HEgj6uQx22w3Np2xPZJI8dGJ9tOdx1oDu44XMcLpw46/cUFjxs56ZwefCMdXb0v5UXM5sU/tzHxl+0AJ5jBwAxm26ECMxiYwcAMBmYwMIOBGUxkTYIZDMxgYAYDMxiYwZyG5JGZwd6EczLbyTr9Po5mk3QrgjB7Nqe8mdsdJlD7g5adAmeRUqMvy45uO34xvalfqlVtAdaQivHCMRmp/ulaRDZtzsSS73OqLd04HcXzeBWHM1ly2Csmj4mwsxy0dHQdccOz/WJxNHdbti7njG+2Tzw0RmFX3F6W7eMPiRxF822yAf39UoE13R5+oARgJSl4Sh6wev3rnbTaV/fYm5fb7lk+gfiz+hRp3Szh4yiT0XrBomMUqXzVeqsKjGZgNAOjWRtGs5J1ALHZzojNyksB+M3Ab3ao/GY1sgyaM8vwg+YsrwM0Z6XQUVdpzlopuXspAdtZF9jO9oA+dolA3DE7kJ6B9GzngMgTFO0ZGNkOZ4H7DNxnB8p9VpV9UKAFoEDbOwWaxeaCCW2j3J5ny4TW1jSBEA2EaMdCiGYxn3vgRZMsZ46DFjrrIjtRkS5C45SEAIE0MrwtRzj2yrqZd5Ubtb+JGJTCtTouZdLNrHQWOb0qKyXPk5/kfTHyNzzTN7ZPqdgiAcQ7G8N56NNxNsR1FlRvKxk5Hg27+BfdYQyr0Blk1GFlfQCDGBjEwCAGBjGLEfBlENMT/RfQdR0fXRc1rWFZ7PV3wfPldXKwM9RO9jyTOoanYo70IRA87Ze3qTm1sBbvPDZ9kzfb1dY8T+ebED3lpEWmHWmVxVuTvVs7jPYvN8wL7W9PTqQB2EfFbJlxAirHK72S3u14Rj5dRnapOC7PGSLc205m3QvsqLkyVVIe4WdeJdjYnJIvPifIMQ56QrHpDS/VskUoVrwssp28IVgjlkpNwsHUGBys5991jfQS0idGaX1G08lyIvlbpvHvYuUcuM5eaw6ozJgzshP5dvIQ7yf53EuamnX02c3i7elAfrNLX7LL5N5N6d7PntK73nrvg9m7GYR0mM8bTjmccjjlcMpB6404AWi9QesNWu8DpvVuH/sBu/eRRImOnuTbK+Ck2mgPAIDyG5TfoPxuPlxwMJTfj5Z8smnwzzvrA/zf1XUf/N/g/zZ6B/5v8H+D/xv83xX+b+9F1rZptk/WbxLnRqLui9p980a2bi+nqHFfr5VvasNEDQTe7jOstUTexkj4bF226upetzLbbWnuaGvTPdBF3sR636rA2SeFzUvGasWlVjA2TOdoKYJ9UMSDIt622wmKeFDEgyIeFPGgiAdFvDhHCop4UMSDIh4U8aCIdxqSR6aIf89pgZek+8s0/hr9KJevwyCKtzZ9R3Tx1rqfK2l8gwxsln3w3Knj24qlrOhQGeWtneoCr3ydooJdHuzyYJcHu7zVRoBjfmcc8/bFAUzzYJo/VKb5RokG37xlEsA3n9cBvvlSHKqrfPMbqLp7WQHrfBdY5/eGR3aJSdzBQHDPg3t+5xDJEyY9ClSynSMEAz0Y6A+Ugd6lAeChD8BDv3ceeqf9BRv9RmlEz5aNfjMzBU56cNIfCye905SCmb6UNtIqa2RXmRwHzlK/WcLAQZDX2xUHbHlgywNbHtjyLEYAFPaqBlDT1VLYb7ZmHiOzfV2OC/jt/ZnLfBMda4ERWO6Lu6J2lvv2acfgugfXfckTzdgaWrmk3+zeO+0y7/2GuerPng7fx9jvgxR/Y1jTYa58xAAQA0AMADEAMOYjLAHGfDDmgzHfkel2OIz5m8aUwJt/VNGno2fPbxHI0i2tCSmASR9M+mDSbz4qcTBM+k+SLLNxaHHLLBWQ7VfBAsj2QbZv9A5k+yDbB9k+yPYrZPvbrr22nboD5+Bv4Vo1bim28nNtOApM/LVM/G2CF13l428hb2DlBys/WPnBu+vgOwErP1j5wcqv3gVWfrDyg5XfKA9WfqADsPKDld/Byn9JRXdJyn8pmvIYpPy2lm/Jyd/yXeWo2DMh6a8Xic1yHI6Wo79Ocg6Vot/Wp6dk6M+inTsNQYHRHoz2YLS36ToI7XdGaG81peCzB5/9ofLZNwk06OwtcwA6+7wO0NmXAjhdpbNvr+nuRQVs9l1gs98XGNklIHHH0EBmDzL7neMjT4z0GDjJdsIPXPbgsj9QLnuHAoDKPgCV/d6p7F3WF0z2G6XePFsm+42MFIjsQWR/LET2LkMKHvtSokWbPIsd5T5ska7RaRZ7v2SMDpPYW5UG/HXgrwN/HfjrqvlNnWFpqskF8Cb+1vRFGTtBM6+RN6eRZ16SP52RB5VR7fHOfht+Kmkl9sdPlfNJ5ZNgIdmW2YrO3LcytXbrZMGOMGt7HZy1sT+3AXLf7BzTHST3c20O5LOnfvawSo/K/Fw3G90mfgZuBm4GbgZuBu8zeJ/B+wzeZ/A+27NCDof3ecOIAmif9xwiaRcm8QyVNIZLHMJ+9KzP/jEW1dCaUAI4n8H5DM7n5njgwXA+P8HG8s4Zn/12dEH4XIUJIHwG4bPROxA+g/AZhM8gfPYnfPZbem3bcwfO9+zvVDVuI7ZycG0gCnTPtXTPLYIWvjupjrxH92hvyfbsL20gewbZM8ieQefoYAMA2TPInkH2rN4FsmeQPYPs2SgPsmegA5A9g+zZQfb8Wm+Mv5pPWt0V6pOa/SEXkcegf27sy764oD1e/EyJoVuIz2Y5EUfLEu0tU4dKGd3YQfBHgz8a/NHPjz+6UfFBJr0zMulmIwtmaTBLHyqzdCvpBs20ZUJAM53XAZrpUuioqzTTW6q9e7kB53QXOKcfBbPsEre443ogoAYB9c5hlCeUenQ4ZTt3CDZqsFEfKBu1jzaAmjoANfXeqam97DJ4qjfKGnq2PNXbmy+QVoO0+lhIq71MLBisS9kjGyeP7COXY9uElE4TXG+QYdJhtutmbQOFHyj8QOEHCj+LEfCl8NMT/Rfw5R0fX14d2633Wtrr74KLz+twbmfo13yTc7zZ3WXSuCmirkxx/zHYH3XbE/KwbZIPWQu3nhEpm6bLstGyuWjot0tN7ggnvSMNO6MPq0152oxSLU+9rumtOfAN3Gv9XVLtb+xxfrNf5/MgSfj9U8yfPSN/W+P7qPT8bQBLh7n64fXD64fXD69/r14/iPsRiABxP4j7Qdx/iJEjsPgjenSslP4bxqtUq31DFiD7B9k/yP59YpQHQvbfqRycnV8DsEHeC+4EqIIO3AmAOwGM3uFOANwJgDsBcCeA/50AG6zDtt3CA78gYEMXrXGLs5XvbMNauC2g9raATYMjvru8dWnl7vHf8v6ADYURlwngMgFcJgC6YAfnCy4TwGUCuExAvQuXCeAyAVwmYJTHZQJAB7hMAJcJGJcJiHiTM5fBmYRvJDZc8A7fdqn0/OYWQSZ+fPCK/vPZsh3mqEWFGtSWF8cjUssB7vomqI/Z2jD2+vSp/l1Z5OPz5/NSza94HkQd3IDPn40M/dPT00sxWcz1pMOHgkpKpFDqSQqzhYQN5E3MabtyUox45SXb4zS4+iVa3pGFoBJvonnMNJsxpxmTdXyl53wZCOc5SjlWrsg6gzInfzFg+8/IoJumZpt5yUn+UKBDpHIHVHCKcpCdcFL2zV14E49lQmshBq4l5joiRVrKdHXOeRtlcdeRKCq/GY2sQl8MySjLJYMwYaH71fhNHpPNlUPd8eA790KuqoaUFi0Ri8tMs57KvEl5snoYXBWut7yqMIZPogUtTJJqPckXTV7DtdUrlMnTsmgq3PFAHQvsOQgO/x5lu6pBupYiLQnTRbSmIKyDumgj2bLFg9i6lDMpTzaoLR/Oey1U1ev7pCTtPUap4pOGLXTeXbDN9aUiGUqH4l0vyI560A8bEv17tCqJF/Pcxal1YgqDPdLPlcLqhqC2yIKrHax2yVlD/1tFGtOEOLeDpG+cb5hZBsrCumsNVm50yYh73O09/LQp/+fPX843pw7lFpKVYc2MJhvXU16P7BV99gsus95m3I1WBE3rqbTStOSV4wG0sC6WyVf2aO+SZWS3loX8z6W+EEG7i2V1YK/xLhE7TqM/B+5nlGd56gj0ZP3qOWi+jLU72wfVzfvzzMkOJldFzmaYS/YhnVZxJptqF0Kjwe6qRfhJHlY4+8PQdCpCQ+0qdWWzt7189z/LQhnwrnH/ysIEL73e6MR+P0qmv2qNv+J806tzfXlIcFVgB7uSi2MUi6h3WKrSgqVyvmsBqWj5vRLJr1f9QEbLrkp6U16+LXkWhH3KNNR229Cs7X3rXuv2NZc6tYP7MAr1yfMwpJ7ekrQraXLlD27PztzGvmsCNIfS/H/JWkQ1inhckszTuD2u+lVSKLMWVY6C1x0/dXqbm/iUsv+Gc+rh4Fl9zIJr9o/8NK70SdRpPw6m2A7m5k6V6ZYp/45r6SWqDf3gyhQq/fqrILn+jYx0VphWq8l6LJMT89OG+Qunxqd8DdN1pL90eGtUQq5OJvIuOkQXJ45Mjc38Mqdv9nieiTlq42NwT57AMyG5X89WJa+hKGQD9zn0Vv6AKD+0SaVPJkdxOZTN3tHyZ1k0pHlpR+mv2tRIFC+fG2hWcRL3PMDVPA55NhFVUrHpUlVPXtT8C17L69/er9bXaVD35InKVEyjjFRoGc2ir6FKrdfB8nDMW5uSwvRSDF+gmVGD97yRdfJCf8Dnyoth/mS6YiOoq5qliUr3ZKplfuVNNBdB+IkgNxXn8+/Ec2SsT8Yz8teCURbQWV/3bOdfqKcD/lKfTyqcS5OIeVvVNiK14r7Q0chjzfRh+tAcH/9peYg+F4Z88Fb9Yr8CloHBRX33Ls38cVM3nUE0WrNLwVmTF/OjJHjOBEJH0MRullizmJZV71nKvaOztLBen4uji9n9SEbl4qBuyqlY8epBcNhmSdkv+Q20pArubHlV0Gop6BHmD1oI9Q0AOvhWOrivU9o5VXsZcbwuJnEbBO/k7X3nyl3RNxXx+r3kY+r6OL/cCOY85pd6oTWPgvOJPlb6hMzqMp7ozS+mmIgkZ+zv3B8yxuZg2A+2v9PDp1yakhiQ+3Sb3POmFxP/psGVObFXfF+KeGdKDqZYKWezB/PI+UOppzr6uVgvBXkwH+SXJBb0aSrH0+Q3EZPK6c8tUlN1mYHcLnz3ppKcWlwIsrxSf+XoW9jJ1SyILfXKKEq+DXmxQ2kIaX2cle5zLMKtLFZhfuy4IZRjzSwY8s9qM8ryoXZc370hebqOSBFKEZFsMI1mZJ/lx0Mqd7KZ5XymyHKRceEsQH6ateZIi+GfCErrHgczyoZUtO6Wz3HMyjfiDkqfF2v3vko3P1HqOFdTgjr+4lg26Cqhobr2m5IydMOkbB6G2W8OXo9X7KOzgMkRyvk4lD1MpciJIxO82yHSFm4SzW7DCTBGbSJF7JyzXqSllVvunIeScSWoF0mjdsumlq9WGi+TVNz1ZlQml+aT0tzqTOhRaU4H9JbsM5WgWYrSKmK6yvJ+ns+shSFKwV5e2PWUqcx8xVQiMEQNf5Q8b1E8Ly7QiGptP8Mq2R4nw2DxiIleNEDxwRE+4KHgF1ghhINR7D/bUXw3VJ0sv0xnyf12UOabp0Y1PlsGmQH45O2tBf40c+3y41tMSZv108irarDUdV5ho6H1MIN9feZXaVCGZDTB0EU5tCUebDytq+k2xM/KAdxihoXIR2mBcKTI/J3MxY+qcFHeNpfU0jrXok1GqcG7/Pc25PlqqMoHlHYcPzEmTqxcjZXKx9xVKlNt1Ky2RobBmXjk7MQM6tGao4+bZndtm0LyIZG8Dye1p0H6ttwFXsTLl9VU2FnEQ01BKhvNSj5arhCUi8ulaVGUI1ktXRit6tfrebh8EJwiNvoRNo/OL6WMyZCYnzxaiGJs7DriZ4VBp6zrQ/1L9RFP5CYjcjSVF67zSiaiFBf9OjKT+vWHmLjsicNxUgLVfqmouE+/qtRZw4oECrAxhCQXkTDkell3glvwFsbs/otkGMazHO7ha4E1Yd9yPSvnlZqKoZyAnDuqzMNkUZRhs+Lki5R4TcOZ+7KuDX0Uzxn71eRXdSw9nD7RoGkecmvM3ND43ZbLLk4TaX4/EcK5MnXpSp5u0EyQg3rFq/o+QjVMZ+1L9ODWEkPg6rJZDWZD4eXk8qau1A6uBuHsPnxINXdoPLUmCJ+rTOy76C6J/2nJBzcZ7GgtlZVe1J0KzRW156asKQ1IbWcL9Va1+l4pM6HW1WgWhelqlMxdR356DZfPXlhPZ5jnLmoqSJbxDSeek0cYM5EUp9tnoV75WTxvqCMLfA0W7ACvuLQid73/NhEcFFxRv/aOVxHV41qEI3tVGuwr982v07M/ikDkz8EfGj/8GfT+YFKdUm39P/tndVf6/vTzh7cX+U1kt+KyUd4evPrl7eXo48+X//b9Dz9/vKqpQdMjcLyTg3bZoIjbxyLe0pRHLGrqkPfIK87K6yiiaQjlVuVSDPe1Jj2tqWMtNgSqEzNoQSmYC6vZe1/SvxzD1G5LiQXWvmG1DcLon9Rqetkx+bB8+JBkx41fl3dUGxwVa2k4LobjIq8VHmTXX9Kzqwcxj2/5t+fhsVjFoNmDqZOeY/RorOPxVB5Og+B6ujbWLsHVgasDVweuDlwduDpwdeDqtIYaDT5OnYdT2lPa0NMp1QKP57g9npI4tPV87NIED8i5I3/4nlCpa/CI4BHBI4JHBI8IHhE8InhEe/aIyGT/kMxvLtdzPnf7fbQa3/o7QpbC8H+Ozv+xSIGH2+OWnaP0dizDceBOjqVH8G3g28C3gW8D3wa+DXwb+Da79m3KJ22i1cfbZBa9L57RazpxY5aCO+N98iZaPpMzN+b8e5y9sYjLUZ7BMcehm2dxbPc620/hmH2B0wKnBU4LnBY4LXBa4LTAaWmPMVrtyPDFq8xclV1f5O24VErCeTm2vZiKCDT7Ly6pOUYfpjIWh70FU+kOXBm4MnBl4MrAlYErA1cGrsx+c8s0/KiwVnv6MaocvJhj9WKUAPj7MEWJOWYPxon0D9F/UZ2B9wLvBd4LvBd4L/Be4L3Ae9l59ljZgWGO7Eu+4iONv0Y/yrtyvL0YW2G4Mj7ZZPaRe060zrYeNns5NRJ1jK6ObTg6l3dWJ8ueXpCtCrhCcIXgCsEVgisEVwiuEFyhHeGPZgepcIGUvBlo7xdI4aqn7a56wrVM1muZim7Qa7750N+7l49X/Pk9+sxdDhfU+/N6rMoevMPNLQytr2NrQduW+xZrkHcZde/wju2W+LyAzbcPPxQrV2j+TA5yaZXPsHzV5fWA8Q0Q3gu+Wx1g2daKy9uMwj3DGDu+Tn3XU8b/7PPVIlgiy+8jPOL0+7ziI0Xb4BkRcQjEZr4ki82w9LdlnEyAaD5ehI4l38r0geRVq47Rkj7YsOqWbVrh4wd5zgOJSOgh74DPcVyKuNGthR62a4d2a9c2S11ceH6yyUHi6mV+vtccWsGBxfFymTVnxHf7G/9a3vbXYMN8ELBdtXem1o0q/Z66NvktIr/jqz+uNgsBXfvYj+KIeWJsyzADae8HaZtDfRh422zxcaPumrlrsaCZtXQPgdvshycOrxUUoPFDQuO4CnDDPPsDx+n26/o2wu0eV9ZtetnfI+H6VgllW95x9wwAPm7TgdGw3HizA+NRe9vLtvfmHKgx8bkm5jkYlaMlpD8uE2Ijjd/McjQyp2/IOH84dsKXaf35mQeZgbKpfZClEWbcxP74XetQGGFEGPcTYbSO+WGEGq1NP+6Yo89sbr48yuqeLAq5l6tFHFKDAOQBpwMcEXN7S2r1Q08MKLCrb5Yg4GYab8vJ3omEgbI93pCS/Bmg+2PkPj0qt7/KT7qRBWjg6dyE2fRgvH0/Us9nZAyOhT7sKA2BpvjaygxYNaA9NdjBmYA6XqyDNAAlC/AmnN9Ey2Sdfh9Hs0nqbQFK5RDg22GAzz62CO3tJ7RXGu3DCOqVGn3c4bz6GWyx2JUqOvAQXpOMIHh3uMG796tkGW3Mm2UtjSXc6yiAfeh8zwTUDDzW9z0dDrCN+YGcErA1/ciPC3jMZptzA7bqOniAoM7q+J4k8BImgILDBQXHy6W5C7LLA4/2WfkuNwr5NZM+bkiW+dQ7gf5ETduRRB5mXLDEO6UYirZinvrmEEiowDwF5ikwT+2cearskDT0ZL2OJ4Nff3335vNeuKvgNYO8CuRVIK+CbwvyKpBXgbwK5FUgrwJ51T5h+hb0VwDr4L8C/xX4r8B/9YwBvRG33AgIOMoDE3QYE9TPGeDBvg6v24f9QI6v2xt/5AfYvWa0FTeUtcJnBSV8JQmo4pBRBUg1Qaq5DS8eSDVBqrmBsQCp5sEZDZBqPooxAalmAFJNkGqCVBOkmiDVfHr7s7/g5g5oORHaBC8neDnBy7mt1CCEecCZjuDlBC8neDnBywleTvBygpcTvJzg5QQvJ3g5wcvpZQHAy9nlGOF2zJ6IDoLaE9Sem8UCQe2J+B+oPYECtqf23N+JyR2QgwIigB0U7KBgBwU7KHAF2EHBDqoNI9hBwQ66u+2JLLf71XyynbvSWBNcFy8SxuZhfDx+Rs8phUuzL+rGpgk4EFbHpm4cOeFjy1luwwXZVHUHaSJ9DaAvg2Rr4YNrdEiuUYnt/EOYfkm3ojrvLr/5N6A6Pyaq810QpR4zxtYvvF6Nvn4Xzha34XeDFZsHsc6woXg3eQQU3UhlCqS8PVK2kdB2FA3bmWCPCvHaZqtN6nyVNrgLyLWGErilMACBdhaBGtCz/NU0WQY9HvPgazhbR/0gNpHqYLUM4xm9aaQns9e/YDjAL7sI4ps5+Saf7uJ0fB6Eq9XyJUGAeB5NPlfeI6Z9GtCbguHQoqDaHn949f7fRu/ejHiVurDWYkBqn8Wy56ykuOIMd2yDWi0+A7IBhAd6DfVw38QiPiwv6D05e4PrB2qfuxKLcxLGJMaFvg+o7wOl+IP3D+kquqskgtusrTkL0XKZLOU0vJtLbOvq3J30aAVPoJC1zIIEJFgpf8BCyn0P0vFtNFnPbMGFPui9nz8sBW3nI6amgNUbrN5g9QaOBY4FjgWOfSocC6L6o0G34KcHPz346cFPD3564GPgY+Bj4GMvfLz/KxeAjTuAjVvefQBkvAtk3HzLRWdxsc+NEkeGiptnsxUmbry35OCIDfzvIQECBgIGAgYC7hwCfpz7hICIO4aIW1zkA2S8a2Rcf5XTQSDkpmuSjhgp18/uxoi59rKuA0fOPpduAUEDQQNBA0F3AUHv/fI84OWnx8st77EDTN75/Vi26woP43os++WAx3w7lm0u22DhxusnDw8C+94nCeQL5AvkC+TbPeSLe2GPAvviclhcDtsGyuByWFwO2x4A43JYIGAgYCDgbiPgfdx3DMT79ARmvvcQA+nugMis5mbprhKa1V7qfFzEZjWz1wLR1twN3oWTcdb7vjcUD0BYQFhAWEDYjkDYyr3krS/sLt/TDijbISjrmiTA2T3B2cqAHwakrTT7uGFt0yy2gLaVqg48UNssKUC4QLhAuEC4HUO4laZ74ltVDui2u+i2OEXAtnvGtmq4DwvZqkYD17pncANU6wR/B4lpXTICRAtEC0QLRNsRRKtvh/OGsroAMGz3MGxpbgBe9wRe9TgfBmrVrT1uuOqYsxY4VdfQvZyCXO9bMe06BQMYFRgVGBUYtSMY9U04J/iRrNPv42g2Sb2haqkcEGv3EKt9igBc9wRcS8N9GPi11OjjhrH1M9gCzZYqOvCoa5OMANEC0QLRAtF25VLgFYnmZTReL9P4a/SjfIn/7cC20kC3HbwmuGaigHH3dV+wbdAP5OJgW9OP/AZhj9lsgXqt1XXw+jS74Wh3ubCXMAEYAxgDGAMYdwQYX9IYb4yLbYUBi7sHi2vmCah4T6jYNuaHAYptLT9uTOwxly0gsa227iFiu81oBYi9BAl4GHgYeBh4uCN4OLvJ5tV8sl3QuLEmIOXuIWXfSQNs3hNsbpyAw8DQjd04bkDddpZboOvGqrsHtT2MTivc3V74AMIBwgHCAcKfDISfnIxnpDbZPr5cXJYsBumFRFGjsbxT8sIigeqrdCCpx9Xtk7Ico/rRKJ7Hq9HIBd5bV21F1ZlIXNQvwpcmstoQM+f65XqVtEIjaVpUq4NPvh383D8pLrzqMWqF+q30fdZ5eiL7Xc7ACz2tQbqIxvE0Hiu4l16UvS9aT1uQMcvHK36UOSVK6Jo8BBLZaBXfRdkvwX8G5a/4P5NoVnZ8Cu6LMQksusKOvZ1Oo/HqotImqiWap+tlNLoNU1H7P6nS3v0trTv6mXwWhA4NPV7kch/26Tk4PAY5y9JhOJOTdWbH6Nr9MifU6mNZ/SwxDaUWqgEc9ordFjP5hjtMvzBtAP/8PzTug3ly3+sH/5KV7AsAka/hVUCqHjx3S0oJMQjYkRWzuYkFXRuouQ0Xi2g+6fEfxqNqHeVPT8rU5jya/pTm/BNKdBBKJKqq1yFzOqFCm6rQ+2j1avIbSQJ5Tf55okYhKNRBKJQ5ZfV6ZZlcqNem6kX+wjwNxyzuG2maozyU7iCUzjF79fpXP+VQxc1V8eFDkoUMlfvXQhEtpaGGB6KGlrlrUkL3dEMFd6OCb3+XQbftVLFUC1TyAFWyNIdtVNM+/VDRjVXUcsf7ptcli8JQyMNQSMvUNeihe7KhfjtSv71cVw4FPAAFtF6/XK+BzZeeQwV9NhX2cF8qVK6Tmww190KWNxt8b1uFinmo2D7vc4OqdVHVmu6qKqlbqxvhoHItVG7XF8xA3bqsbvYrNBzK5nFBDVTNQ9V2x3wP5eqicjkIv0ta5UOZD3XyUKd9kfRCubqoXPU0pCUda0HyC1XzSQZ7BPZAqF0n08M8DqeV88TaHhuFCnqo4P55iqCAXVRAD+qVkv61JTuC+nmo31PSIkAxO3mcp+UR7vJJn22IFqCyVpU9OXlR8y94tabpW8b/jJZpUPfgyQtabWfR13C+ClaJpn1Ypn8L4uXS+GI8i6M5ydbJSYZ8lOSV1ZM/ezWLw5Qk3nkKXlVykplxOf8s03X1/XuuUs7z9eapMqPAfzY0plUJS05yoWDDtQt+L6nJLfHsl2W/zq+k3af0HJsaBferoWZR96vA196UDiLnOiNVv2p0Q3pC/Eep1iAv8qmsF+eBRbg/n5+o07xe+lOuU5T0VRbL60X5N9GYjFwyryvbqusDXaP/GWxjmZcK61zkT+r5SWqadUkm91PJhuduOr3z3PGl46Qx/8v5EqqESOPn0hFRvEv9sB9aberGzfPohrnWdKk3tUexmjqVRtSwZ9crx6mlLvXP9yxdU1dXeT2jzk7mrjprPQjTrY76HMxqntOH0UpwhMh6KiQsz6antccnutvdpmM+rSc4UhV2f6a37brNmepUb31OjTTOLz09mlEto6WsZjR9lv205nx3uJeOMwjtp/P+mfa0EKnoFGSvzWhv9EAIGN1zcRlkfT4dq6SmdqlrzenRTd2bUg0j5l6lBfJZdrCU7djFzrlybf3nLnx+ndP5dF3qkzNxs6kz98+pM6WIeZf61JQD2NS1iS4/mj67vll3BzoVj/LaNW8Mt3Et1FRVzejuuXbUtnXUpV56JSc1dZJ5yLs9mTvpZuMuXqe2WlpnujRuJ2VRmnA+GR2ABu9+CF4EP/384e1FsBbk0lejq2CxjKbx74Jn+mo0iabhera6CtKE+dmZ8J0zFZLZLJ5ERiXiFoVw/qByWgLOaUkDqnMcBaGqMpqI+uOU676OJ5NoHlw/GJUk66W8O2AcLGbrm3ieDrJvdUsuth3ppnyJc9u0ymSDkU420KIxqFyB8NlvYzecEQAaxdNi/gt9OvzkUTpOR+FiMYoVmfhnI+mlwmYdT9WmaYGvn8RdbQqbHxc55iUb+j+YS/0tM5hXc3Wmp6/DOReWNNQPwXVCUqCJicVLzsb6j6z9wZLmJD0tZvGUc3Vk24a67SSLslazX2LyKt36e/nTHfVKMsXKTt2o31v1STZ3qJpNPRI1mh0qbPJUOmZur+yhfwXiQNnNQnvadrfYmWGpc9R984XmKDi3vSoj4th72sPguAgW5Tg5W9x2zNxdH9YMC42lo33FYbXvPFlG1bL9s5cxtbHl6RG1N7b9gDo6PXSPhxhOS9NqB7O8y9MwqqWtlr2Pbpn4zDHK5V5sPdyVYRl6DF1lAkqtL0yEfTumOvyWPZF9jLqN3UoNtr2lrYfY0eGhcyh4OC3Nqh9FuQvSNIwfK0/tZxwVSZFrIO/111uOpOr00D0e1bGUTSvAkuKORBWgmNsC+wAqBbYZBViKbWoNXUpdGlY6yXDGfK85IJZQf2VQKvH2PQxMlRtEDo6lfW0HyNbFobXjNFCVdtgHS8XWnUP1qvr9jgdKszqUhynMPt9wkHTXhpbuGgOk3m8Ojw5oV0blo+WLHQ1Hdg5fjsN9/mer7mdNH+a9oM7q2s1elsPBld6WYrJ76HT5fLTse7lhbceg0rFhta80JqWXF3wke5Cm6i3ZoiP7cJusR3WU/2Rva2tPytHloXMw2LuytcscSHuEszKOtjDjHobReixRjqK9oW0H0dHdoWscaAhtbSrEVXyih9WwS1MIbx8RmcazZSpY49Oj1rEcr2Eaeg4nR4KaelNqgA4d0jv0r+XjmFmPPA5TGKf2LkgDl+1uvbsU1x1Wbr2rT14pn1H5bDkPWl+0dEAm69Y3X+7D5U1ae1TT51hKIeBojBBfcFl3m606P3FWEnR5Ck/evSkmsXyRXWnIh+PygJaPSRaHZxymq57f+bZzXUXpLGQu5tGsZZ9lKLGpy6VLx7x7LESpVX915FsW7e9mEAsnMXY/hoUwXNNQ2q/EObQRteXX735gXaHOpjFuvIEIw20fblsUtHmwa++Y6ehQNxzZ3fvolqOg7UbZeY0IRluPti362TjItRdBHJrRqMu93/uAqzBpyxEvc/9DnDVMKwRSG+Ganc794GCbLWl992NbjcU2jW8NlzcktjSqOnDrO6bOK+2PfkSz2G/TUFbJeDGGagzLoeSmoXQSsR6aLXVkTu/BGbbG9Bq94nresYPz1+ryIXc/5taIddOQ17MuHtqI16Ug737Am4PYjUFEf9K9Q5sK78Rgj3lJI+tA6sDw9Wr09btwtrgNvxtEvA2Rihb8Ei3v4pRjwW+ieUxgQrGqvQi+T5ZeMeBBmSOxFPN1RuS3iLtX6RSrfD47CYsXpLFXyHKl4SluVPQH0e80fWU3olYWpRwWc7tNYarQ+/lPjwxXl2enFJ7ex+SoTRFHZnz1aqwK98/eZi7L4d3VxKXVrP8dzFwhgFueQJ974p9kHp08Mnubzko+bben1RWiH1SuQW4IyXdgsn34g/Y277U51V2XAdu+wWCbu+ifaP6byIb2OPvuDPBDmvzytsZgF7ehd0AY6viIHk8obOnpHZcO2zbMYIv7t59GFppYjPYnAu5E+oOaeLUdNNjm6ucuTL2F8OgR5z7P/O/25Bd3qwabXDb8NF6bkyVpf95b9fBCt+e2uls22PSm2yeZ43o2pb3Ns+P8xWHMtd7DG2x2weqTzrONe+kRZtk4QtLtOc52FQctr/R8klm1EjbtbTrNszHdnsXyvuZgswsln2RO60id9ja1tqM+HQ+gWveZBttcZ/g0IdVGrpj9xVbdBzm6PffWDd7BFtfoPcnMN9JE7W3i3Qeruj3vzfvMg11d5vYkEtGOQ2p/m5++x72eSFoaLv+6FGMRvNeXeTXdAPavYRoF4iqkSPBfiWvAouXLNJ5E/z9779bdOI6sC777V7CdD7Z2q9SXmXUe3KOz25XprMrpqsoc29k+++TKRdMSZLOTJjUkZZe6dv33gwDAOwBCIiWRVNTqtp0SiVsEAogPXwQs93npkWfi0xbScaPr4iIpP70sbELL+KC4LqxwwxJUlLTqvCq4rMDkIZEsKhOgwYVH2cNiVv0SzMl3D87sG91+p1VYThw7syfLsf7fG+shdOcg0Ac4YqHfWOHKhyvdJtYdobOI9iGkAxGL8qinFj8R6yEdNUhA9rxeri1nBq5cxH6zwYQLAWkVSa0QPgkX983pBBWF3UuG5t46J5PHieX6vHyRtyzZfUYjPsntf0XpkMEFfiQk/qwSqHfpr7l5sbOH7fQhoZMvTsiMC/z9Tyf8og/Yy7f1ay6rmLywbDKcfQqDF6pTyQCBpuQHh48rnWa0IzG3YW6QTJ+JdZYVRMXiEzqM8ZPD9O2BWM6DR+DPeUAL8lyfWAwdi1j0KNj7iH7ONDpXjpMOau4GQzGbc4SFUWkEGSkosm3a9SyBm/KORv6O+oZGYdyTixq/JnWl1z+y6lhtje6BrJZrm9zRx99auB6hdi6ahe6S2kP9q++ubt5ef/h0+/FaciUY2MxcErhotaTGYDRJvx9V8v9xUQfWU+DN2ewLmKI8u/O5R15hbtIJ+Eo1x/Ez8ecTAHJFoDUTSBxGTTb75HwymYzORlkevze5d74nM2dFJ/iZnVVzloQ/U3XyvLW1DN0XwOjiJ/r5PKBVPBPHzxVCC6CW5tlZQ7OWQRS5D/S11NWAF/3HaGw9rGJeCCvfeqbrTa4Uz/1G6GuPdO1hM2RNp8SKjsST80LV3gPdXlsBNdghy1uYe1NkuMt14Xx0NimFIGdf1sb4ipn6c/pGkrMxE3O1xvr9hbNceu6MrS+2O79Qavll9tyHef4yKVittG/esEcKL7FZ8Oz4dCUPZS8WHhAz7Gf+r6yUpefM2OJo8xVPVlD6zORT8tdb9nBug/Xk+D7xdM1JEipGdunhif2Wf1BpHLtL1J7RVY7oS8w9yC6jjd7Cn7mCgm/Et+kAutQ3Duvu4y3vxIpvR5Nb+Pc/xT9z8d6EXYFrvzieO3cKOfdl+01+Ye4/04eL6XHX6btiFZlcvaQjzraNSpW+UE6P3IWMlbdKN/eK76dFla/q+rT4z3GlFKbX0/Qv2VW+Qg+mhX8VHyyr6bT8QfHxkoZNS/8uPpxTnmnu79JDBR2YFv9ZfLSiBtPKJ+WNMpX3lP3Mb5JL+/uyMDOLlXkKfGnKORWGGi73NbJrqM3TwX6t+CVF61ocuG3bq5+RmibYkN11lacg0DnxnpoQAj5J2kq6FzWw+g+EiiHkjVHaFFqL5MruxF20b2jhd8T5dp3ufstOq3TTlFoRsUudPJL4PHfTMk+gkmQ/VCU7ueZOgiLdydnPwDj2H8v7WItuj122Wb0Xn9z/Lbclzbam1OCsg5VIfsx2B9zZgOOEgG4YuBf2n2clrnRZeuqxKrb5jXX78d3H86c4XkYXf/rTI61l9TCZBc9/4gP33Zy8/Ok58IM/0X5Rj/RP/9df//o/RheWM5/DHm4ZhDHzHWd0awQtDuhOJcybu1zC5Azt8INX3jfHe3XWEZi0Ne+i8AZyBfDdPt9gRNxVEOLTWdgq7ZgbSvpVeut2egf6pGxiqWO7YFXBVs6au3P/LEtg4wgd5tMSdqCw1Yti1/MsQr2O1TKVHuvId8mSW3ivXCHfDDrxWQSuJ3VY5uCRQhHscvuAtweGudjv/Hya5v8xNlmbhOJwFeOLa3ReuysSD+a28/Lbf6uGoGQMcljRZkmwQxItqW6Rul1JTZbsavLxdG1Tluy5USwxsfwKd9hH8dH5Ki+bGiEvoGpK5vZqSYUS11QUr5YeAXs4Vj32sKZD9/WrpL7RRU0+eL5LBgAojNk/zjkiZX2pk8bXnMWRunN5gCuV1jT5Y8zHmO8cxpJBmVY/2jJ4g6s2/yhR8C7pb23KHzFiqKEba+imRWfa+cVQKoeZBk2CLfh0yH/Rq0lRJOTj1OjS1JDJ5lAT5KQVhiqfLNInujhr6uLocZ7sc57USKP7M0NOJuJzovQdzgacDX2cDS1wrsSGSvZEv3ZWct4FbrE6tcXSCelwKwrrIjt+5Zujt47nAdZJW8aTHFfZG8AQOFO/cza2ZgGDTP14ehuuSAGokr13XqzjE7u0LfC+qOv4mpN/xpyybcDY6qel4TzMlC2HYOeZFBN1A4vqOZlM8mOQUKD55eknW5mWBBRUTokkFl1QNabpGyeSkYOzGEmNRjyypDfl+3QKuL/oar6G09NToKAVGCQ8gkaAyRnVY0KfVWdjqSL5rO8cnz4f5c4GJrxkG44BvPNR5T3IViIpLi1yCUd6tDsMqpaW7AXBUlJwWnhaTNI1ycPFT0YTJhxRz0gmPc6NqFEYd07X7SAm/mxtO8C/KqUbN6UNlsRdLICHt10YT5Yvm82qr6UFxw7YShHl6FH5JgPgzteSSH6olHvgfKRdusHMy+pIGV7MMkoPELNH7M/UVsvPt/IP/XJzdTtuz/jQufOJhIsgfLYc3zrNU61OJVOtuBDdQ8en7JrNQKzKF5wjFzy7MV1OxtY9F/r9WSSmZfFsBy4QcJI7eFYRmVvnC3HgBAw/oAaxSs5hgR/RmhbFgX8iobjEgH49KfesIiQ7putf3RDTdTPwXghTABg2mzecL+aV+cj7N2bFq/IcmRqlogWpzMkNTIrCnFSLLFkTibHITf1x2tvc5OJdn/LhVR1e8qXN/pDUH3vri6IuqZc3ucWSTMP8yie1MtXHha3TnFZX33nK3XEv1aAfg9eSJlzI5S1dgOVPOoIUy34rnnliF/7Qn8WR1S3k7SzmJgt600VdnmbNlnepOsJj6TPJZMrNC3lhQu5TCe0qe3Vy+dPd5X/dyKsa8VtXUznpjRAviU/jjRrJ9GOa05mxtj9pgxSN1g7bWLI5KXz0dxCuO+N8Z4VO2iql3Gge58ZGyo3LCelD9vdYZei23+PsYxqYOJ2pxf5i3pOynymoM4koCtw5KY9mEz5NSowR0Qe5sl/F7d+cGjKX0Wka0moU+iqxlkyedb6gfBS4OJTDl9y7JB/BoqWrljApUjcmajtYWL+zogq8cdPBodqQn0rcibrQ9UCM0PsweGae+znvEh9bSQ0llnxjjnylgjfW54iwqZfriSWGEfabz843unVahUREI1CVkhQSsvgokOMDAc2DzSLdvS4CuG094QixG6sm1S0jXGBfsep0S6RYyIpDMi39e6x5KSQLCStK/gYE1sQp3csR+VKBin+fD5O4V719z1+4p3t+EeNE/yTxzGL6noYTTRSLdVaDhOKV/Mer0D2w4u7ElLEYxwrN5JFY2mqcuRM7mkdyyjN1dSsKH5yPvrdO4x6WYJ/uRQYBJsh7RrVLGh/Jxyj/gqJlI2p0Cr78N7LWGqfSs7V2KeVbJZez8ums28o4se0RJ4rtoMJRzP+n/iZjM16wYaKFuUDeIw+rx0fQVdefeas5m9Q1hQShS99wPL5Nss5paY/EB4cLWHnsM9evKYOz9SLG3Lsvgz731uufAsupKyNx5/woho0ALelfqyiueem+JKz7ifaFReLMC1NFKzn7rWJffz+zzn+jfs55qfDR76PTcU2DeDTPKyzYvgh44bFb95+uru27j9f/eP/Tx7v7mlIeRGSO46+tJZjUZDTBRNKlyo9qCoiequEzDwRiaxygcc7A/gSLulasuQkPxU6iKln9aOtmQH40lIWMxrWrt/IB6LP6W+6eb3SspNkC6Nb2onUYqdxQBcgg9/Eb78j3jzzuGn1UQB+HQyGzQBMy+2bzdtDXPFoMHPGoPaStIEthDTfBHqUbOL7DrkcgVZUnmCSrVIdE7hB91COQVRRSgaIoZmSt8RFVS7/LQ4QnKrsE3YXYXDE88hakWjXN/qzFHnIIA9qbndkbIb96s2NgLXZgJlZ+3r1iKOtGAJwOZ6KlnXcCVCx18uCY4YnBLkJlg9KoQP/RJoJlszW6W+uX7dG28b8bGbiqQk+L/9SUvgxcP81YMsk+kk11YxD377og5BxU9eysHwgkObUXK59nQI9fwduPg0TeJJG21oYbaUf1GZl56TPGjCtMKytMdT6pnsrmS53g36ZP7mA1M8H9CwezX/RSkOH9eLaww7OFBFfcIOUCH/0fwuXsZ/FyMUdHaTxz4s9jefKhLD4/SVpX/2K+L7Q1skKkrcvXoC49V/K5ZBCfGJwltzHiu8mP/LdcM0oBxcmiqEvdsD2qzkElqEc+F9l3k7fsrw/vNHu07RutQJYS65kvLveZFskGiOA+ezhByRiMrToeKOBp92xgWKYtccpCFO8loDjoDMvcNv9TSGaQHoe66jARFe9lMGI0C9gsqxmF5Plp7THapPqS8pXSiVlhEPhWXYm112/NCrPlj9NkakzovuqRWgw7+U42jcqnBDUmabWiavr584d3X9s+zmp0vtfWNK2eP7FcAf4cJhdLOlbIQhZOao+ntno/Ob2qombSw6st28jPtpI/Wjjfqp5Mbdoy+cGVatVy/PV5/OXPX+VOfDILPry7ot/dXv3y9r/sf1z9l/3j1eW7q2t2hBRDcrpkAEbqRY5vNv7peKu6rQY/cXkXsJUTzOPZb5u27PezbDLTbUcILu6p+rxAOTqaMz2D5fyP05qjuPNN+wW3T1bPlzTnHYquMTsj5UKsIpJsPDVIC2/ktHbXMFmEwXPJgKa6om51y8yFsU5UYGXOClPqrPb4iM9O3Y6dOyE6TIRNU15h8p5apd5YzBsClXzNTubYMd2SU45Zxkeqnond+4O6LE0tkNMz4AXZD2QByV1TGsNZ7to1yPF3PjpLDhw1JboLsdunr8D0AZPhWLmiEnIEyydLe3f2oisu6Xq+16RQXPzE883MA8hHw49TgxPtmWlAVazYpqUTxu7MXcLb586j4/ojKBNOlg2KFIhcqWWMts3DiNTnn9mab6e7tTorYs5s4k48HThbUo++kgwoSbRV+/hoU4tUNri5/hsZ3RwRwyM5wndWziQZ/ZH1h6n1Z21JyaOZ5SknyXkNqb9AxCW630P4HFvazkdG5U4+OXRNgtPemzikk0vf3roiGaazGSKSdWzpzr55ZOIFzjxK4+smL9AZjaiEuDJUiOWSBTG5EVAxHCCoCKBWf0iXPc8RkRxQNRpd1Ook31bACmCwq8h2FyxIcC4GjyWOgj6c/ZZEGbKU1bbILkt3E7COWWdifbBODWsRmkuLJ78uyQyYMaIe7ZCAZXPi6nD8fvY3bvMBSYHMg4+0QLO2nIIxOoPCzriXCEXwRlnOAm7KogWDled+ITWHvM7/rC++RkuEMeTFqR/l+LR6X1KyZOW16MTcbumpONLKefLGuRstnZiqfKgvwoBcVtgE5PpSZ982GqPX0hVxbQxPcYgKxNdNXtx6bPMEtncsBZzYE4lVGbYvwH765vqMC5bkk+QrCWw+SimQ1ZXwYYl4tr5XsDJANmSEJhDqvZXQFBa0vEltgWlmyxqVSAH7TCumub/1LzJ9KnGHxsVkqOJmPAPT+gbS5LuOR9vM9jKcp5jlk4ac0bBkx4ktmphoAC9wnrIei42dpFXeBmJpNLJvc1j7nl3fjei+TePzb2C4klOTrKmbkbTUi3XK9RQzlMec5+oyKEm05TbgLcm9PLY2blYnVvKtV3O+1l5vt5TT+Xu6QS1tL+fmdZ/O3TlbtdMUm4AEzYIwhDWcL+3/aVacieJTq7zJ0Uo5cQVV8QQvhO/qKxR7d3g4v+EfW2Y6cHrDmasiVyonsPLSGKdMXAtKP0ux9vvTNiwE914TmGJxmsQr/QZ1T3Lf/l7E7U6NZmUxQoRxqk2dIVkD/zi1eCRygXzDCz47tf4oqe+P1ulZ/UARr9RYY7Bss6bSYqfQzhIKBtUZyEq6/xCMCjA8diWdNjAGw7WZCnrBI2QE57/GRq/kgbw0o7jpNqw0YtPc32YvV9kd0+pHZkVp7/FRvpRj0yjO+reclALIAgCIBYjkEiKLGzKM939jseHhpQmPiTNUNRhQHl5i+9GI9nC+grAmZir/YGoPActID17YqyNA6v9cPwZCflLsVJ6q2EzN+WbFfGV+Y31iMTp8z+wuclvJJyeCQRW7xz8YF1mKnOHch+K+8g9tbSybbDDrwbCqHdWdYhqeRqtAp+mGUJZxqxlYNC3iSfPV8zJKtl9t9cZg6gswVOLxQML2pUfFeC6mhtF+XQpeAI2ukAyCx/3XZ0AQfJPSbrgYA1JA8AoZjCaFpA/qQO9pHaOTs1QV/FQ5jVYegjNWJalIRiiL+jm2Ifpwe3V9efvh4y/jmkQel5LI39PT0x+JByFc/CEALpbshjAWTEFiQOzYCRj7ikdn3HNkj61Ulfvy3DCHX/A4SXgxc/vuWXz8gfOIbJTdo6OZOQp87MYKu5HSZoqrxpjqdFfFkVemxyqOPgaINKPvtsJuHawKdiO6iker1QYgKOLmS6ukyJ5XuvpvszWPLyFbrnZb3hmRRCw4DzP6f7pyO7M4F9iQizfgr6muPTKyAXI6heENurX3FJTvzTW82CB3GxSDLX8J4g/JjbBkzgBM46Fl/9x4ZNlbTQa22dXE+kDoDcZVPN/+sEoudzAf3fzLHdTe4lUCxmMtu4GgzSG/zc6qGo2+opwmgsgVeTzSWN8G6dXhotdbyEJSyuHsjlHWejbuNU/ubqSvfuXBe+2MeKk0HHnd7STvSTx72nzAJYV0cGWVNbNqbg43+IWrYbYe/bsSc2Xfa24n1fwHEt89BR5hjd58q5h/u4tbxnz7Nt065tMGNh/o947r3bnx09WvM8Icw40Hu1ICWmzpCF9yptzW4yvex9EtjG4CDmw8rMmLjQyvCq7bYsyUkz6pZBc7ZvmNTuaDWHq/g45jqYUH3T7obg3awFOXldJFl11+NY25t6i72qZNsYBVbCwVWSEd3HnImrmBTOSvty+S1Bm89OftzJraEruKtdQ2fBNIt76sDWR5csLPa0XXbqgv45EYECyOvJ9LwPyRCM79O7W3SxLG65PkaICNU/lkwPRU4Fx9tflJQ+j/jXXLcpNCUr9XJ5xHFlArnNh98Ig1X4VpzmbiO8/wD06eYtmg0xzQb5LAP57n9Kyoq2fjNJ+BT15p+XOeQ1q8Og8Iow65iQQYC53qmetTwUORcJqUtpaFC7Dq6WPFigQ9NGmpG0FjBZ0/myuHPsJIvledWJS/L6vsG+tdJpZn91EkTeBU6E9ONHO8t1STzmDkziKfjpQ9Y/8upap6YyXj5Fuf1vQrP9WsaMzjAjyPVVIo5YV+nc/swHLE0nF1GKmcChpkDMRFyAdDC2AxqEDZ4+RmSOT/CPITPciVwxVDrY3AjoggvhNS3DBmO8S8V28IeWNBGozQnRPOFiwMimi+9R2oD2tg8nCmkwWVhnrYczxgNFXFytksO5eblZRLeZgZFbUjpyHj6pTe5xQlvwItDlK3N5in2Wyb7Xi2mSfwbW0CtntCeHwG+MAnncn3ioPN0tdofXtkfR+LmnWkxreNOfrY5zm6E67B8dnpbnAm0u+1h/Lyp9B498h4R4TqTVXfjn4HrRiXDm2k25iauyYrHZ/57ibpKvle0Tq1+ihfQCPfIyOfy35ho8GXG3yDMRro1N0tR/IYl4BOcT0zfZA0S6c+0sfR7vfK7q/hWotZIkV5XlIEa7aa5vWDO6yZvh+C97EvF50hqsu1o9Q8U6WqvIbLSJ+XESLEievJLtcT9SgP2xbsNJ7lCNeXTsXlpDphFIajfxoXkT4tIlSEtkdlaItMgvaiqIm4dGy/dNSN7ZBm+W4j7o5+fTh05KBCGXihxrqTPI5LRK+XCFkC9uM+pagdog6dUO9mCu8mDvgICaHdiGdOWWX68GXFY2jf+0QUJbH9CsLjCWVx698GZVQ1pv2ex7vLQXB8hr5DuRSS7ytNUiuK5FE0+j0y+gsqPxuuIbBJVf/Q8G89q7XjOox5vas0Kce7BBw83UtZ+qJB9WqSPojGv5fG3ylrHpr+Fky/M7z53Hr2pmOx9n9niTOkiUqqaalmXtR2VqpEwllqKZUOqJNPoTHvpjGn6jJ5rSiR0oQPyF5rZtVrX2bVrlK6Hd8+ujOp6ZLvazPRKR9E09ujffQ8kZ69KCne0Z+IqoemQyeh7U3T3SaMPMJ0C91KfJl9b5SUr+ZxtPF9ysQAMqQqJYRoP5d1EXMy1I1Ql7Iz7GQC7zQv7fEZ/27l102+N0unq38aLX+PLD9cC4mGfyczvG5ohzTH95ch+wjTF3c803eaPXXzxN4bvIqrSp+SIqeBpPQ9G72L2pzJm43XEU1zXbr+bbLfH9XNtm+su9BZcsPDrBg3QnPyQjy4reAsSvSdGj/Huo+Wjn+f6ribNwN0bYKZQObWit1C78aRtVh53vq7/3/leO7Cpd8I8wlWLzMOwBWQjCEURsuZQJWSq49hyGwoaLo4lcn2/Ow3IYUJf9ad/342OpVcX0/LTwr6Td2MtBPs8mf2Ar+64XcxuOeywj0YyKm61FsYsZ/gocnbzze3H3++uq4WsmSjZkdLMqMtmE1vw1VOW0q3SkPrYFPJVMOaJjpW0Jj3dAn8BLf/nIvnRpqLqYuqcxvwFyuNzNn2t5KE90a3eEuMubRbkju3Szdeb5N1/XguXsZZ38Ks5zrS6UmfV5faOc+VhL4su2eezuofqonUW53U49pZrbZRBT1PTBS3SEnHRk0SfR/5reFoL1qwFwXF6bTZkOjQRjsGmTKZ7BvkU6vDuwd9emm87B6NSNtGRKVInbYn+uTAG5mWmrTBJlamdi522uCoUxkXzE2ncvzu4BZlNCatGBOZmnTclKiTxzb2cGqmTac8Hm1a3KYekEkqXKW56UyOWDQ7fTA7ZXXpkfmRpxht2Qwpp1OHzZEiiWpjs6ROnJq3Rp3KKKp0lsySD6Jl2qtlkqlOtw2SWoua2yHtROqW+dHk5mzZ6hTycarNzqETVeLmpxcmRqhJn2xMIVHiZuCNLoWiEXSjn2NdPmeWJHXMnzd3I9uh+hxZnzatLhIBbUi7J88Fben2CbREcZqfRMtnS7dOpGUZBJtuRVRZA3OWpEPp9HAL0k3zUVWRTpsQVda2xmZEM1U6ZUqUuejaMifF/HMSY3LwxGxoSrptShIF6YUhKWYBa82MXMpyyHXOiJQymzU1IaVsZjnbUc3qtQUEUpuAyNwwKH0UXb4vNBGNTUSqB522DaUEVhvBGmUFMkEy7qTpyoysxYYmoWEWrdyM7kx6KeVUrk1kg7uDfU79ssJ02gLIdWcjQ6BIj2RiD5Rzq8OYpi4GO0+Y71YOIzV71SxScdP3cVOxCy69VKe6TarXqNdm7HqdnhnR7PUTssMWR5MeKGdwupU3R2kvzJJsbPg6WpsdWBupQnXa2Gh0qzHeoZ9enQI9dHOkKfJhmo0mn06g42la1NkDNk/o0KQsNGK7SFJQq3zdzl9gqIKbpTYw1UWjrAfms/sQW6yTE5YrPovR5MmAzsW/v3ciknxGJcJet4XdEOIXLX1xQmb94O9/OuGXtCbxGG0YaMZHdlTleF8KVucre/orlau20GyozujAv7AMRc5sRscRJj9rFstyRJzZE7MJY8udkMkY7EJIrGdnzZLzZKU8r7zYXXqEpVwjYWSRX6l0RH4en8opJH7s0bdWMS/02X18iq0n56VQjGPN3cWCwMPUzEAz7s8y8YjkTtNfAl8ILV1OLn1qm+gL/oxYwUKYr5DqxtziYkl7w0rldsdOXokuaL2z+AvVr3FZgDCWv/3O62GrTPISm/hjK7ErF/SvMDfX0rLzcb+8yElWceVx+nT6JVyZeZ6Un2mcu8iepvYWRqM4xXNlsZlj22wMbPt8JH1uYj+787lHXp0weyf7qNqlL0mjvuaaW05GlX7Ob1JYhrCUxOt0IPmNlcx6FnOhwpwoLq2yIeRyhBEqjAx/XjosPJHR9cqHtF0sg1HVYpwKrbOS5kJRgU81NyTUVjt+zFYqvg4mjbkXy+OpYuMkBoSVLEaDtz4icSzyhRVHZAzJy2zZtmI0rKHhTX0bLNewsJynvR5tl1vqCFMT7iqFVjXrmCInVvl7TBPYpzSBklRSQ7/UJ5f0r/OTp4Xr7nMZuI7wmvsdJRqrXnwtzxxW+hptY58urK8m5Doe0/jY7YnTwkU41YRCR3j/zW6TrVXvxdAmPpI/hTazT9fYEKoZ8pQ/x2M7FYPQ7WnV3KLqs7Udn3Hdc1K6ilbo04JJFKQm+Rea4F6Y4DiToo3mmM5DgwHp7Uxsw2qrU94do83eT2Y/iYqoE69JFUSTngwNdU8M9dqOmaqIm0dmshRUx2Sn68ajb9OvbesszxR47FZ69wkRa9RFnqeuVm0UWdzQevfTehMhTjTjxgPT9wnagn1Xp1w8QrO+n8ySVWUxShWpfxptd59sNxWh7VEZ2iEXor2oJl88IotdNxz9mnqtW+VCSsqjN8s7y7xZpxyFxIj12lFMf4iWuaeW+VWShPKYTfNrz6dfC4w2Sa7PI2S27TilaZWoo89RqngMrW+fGG8ktl9BeJyEf7TcN9UwdH1yNbetqgyox2df95HotaIGqlycElVQZq1EW9sLW7ug8rMhYMom8vyox2NvtUPRl8nWnu0tpos9Xsu7u6y4SlUopi7VKEIpzSfa3J7ZXEeWTPYYLa7Tx0nW3NaW8uoei5H9O0sEkDM1mUpUM6bOvKjtdMKJhEvpYCU6oMsajBa2ixaWqsvkVZp2d+h2VTOrXvsyq5qbVHl+4+Pbvu4+jXNF8LV5mZUPonHt0fZ1nkjPXkiyGB/P7lU9Dn2YYi2ELmvSIR5hDPOe8l9Xoy7NMjXWPI4WuE/hzSBDqjRCiPazLPPgEQU61w1H3yZfc9usSaF9fKZ5T5nCK8phlvpb/zTa5R7ZZcg6imY5mXZ1o9GvidfcJpumEj/C7JGHypheTZC3eQr0DV5FY96nnJRp5Bh9z8YtdzFl5WaDM6hZq1kJtsoWnL86YleZQBtfDaFIHFr7guSSB2JFT8HKm/O0647PB8CliupE39gkjZ9WUdJba0nC6hx6Y3kkPmMPLdzwmU0IWk60ema8GDBkwjBFq7BiD+7tQhLq+8wM0CJIGGtzWSdvpe8oHo6SrOlZmuk4XBcTXrd25UXDay+k6drTDPPluyuK6du3ujKj3WszGl6dkXQUrs/gE1BVSSv3ZNTflSG5L0N3Z0Z+bkouxqiUU7odozBTlVdgZNdgpPn630qyNhvfeWFwA1D1hoviJwvXp5OmNKU0sxFm7WirjMU5E72rVL5NLbQigWnd82if0T73yD7z2dcr85yfmJtb58I03cQ4/1BNGz0c2yxJ7Jm/ina36YQb30Crzb1n+BrabbTbPbLbhSnZK/Mtma2bW3HZ3N3EmMst2rBsuj5vc8687zmhMZp7NPdo7jcz96op2ivLr0+XvPkiUJNNeZP1oNYEDm1pUCeHLiwM+8mabLgiPAbBo0cmS5Dqw2oxIdSorpltv4K/cotAzZNo9tHs98TsyyZgz4y+OgPzNiZfk6B5M4OvNW1DNvfybNNKs7/7NMxo/tH8o/mvNf/lidjjZUCeuLnpcqDI67z9sqA0fQNbHtTJqvOrwn6yODdFh8wyz+IKgSvEIFYI2aTs18Kgnq9brAeaRNIbLQNaWzdo619Iiq02/zvLFo3OAJp6NPX1pl5MwD7b+kLm6cbGvpiYuoG1v5NkJh8QC1OSZTvPxtxx+unGrEx9Ql09O5OEaO3R2veDl1mYh/3iZ0qm6BY8TVlK7I34mnJLNixrrsrrnbPo+0h4jZt2NONoxiVmvDr5emXKVam0Nzfnykzbm5h0jSkbplkvpgyXGPXd5dJGk44mHU26xqQnU6+XBr2Yq3t7c15K5b2NMb+UpWwfjikvZSTP2fBqZu4tQPTaJMLmBlqJnehydrdknBoYpm2M0lYGqT1j1I4hSvVHVkUr1kdveUpWR2FxSsmr60xN0cyUNU9pX0q25U6ar9zIoNQYk6IhGTXMop2zBrtPL90Ueq1NlYs7PNzhDWGHV56KvdrhyWfp5js8Rb7rTXZ4SpM2sNh5TerBfBD9nvJZNw6vNMv3ten7GHCJa0Cf4uuls7VfgfaaibxFxL1uWm8Ueq+3g8NaGzRpw3NLw57yaTddGcyyAG/4Oq4LuC70aF2QTtVeLQuaWbz5qqCb05ssCnoLOKw1wTRteT6N7aHyeTdOc7t5IuEmZeFigotJn5Lj1k7rfuXNNZzsW6TUNZ36G2XbNTeqPVmATk7eaP6z3nou8ekk1T108sa6hbsTHGoCUsPw3YJplUXfDtfLwIVC4MYBx19b10z5WIcn9B9UMR0/Ztnzg/iJljYTlYKlTe9QsM5fnwJqNtgFF/RZ2t85z83vPj7F6XPWg0MfgaKjMTWW1ivxPFok/StYxITaXcIS8Isa6PvP1Ja8kGg0oSNhXcaxM3sCk09+XXruDKpykysS/k1HDGo+9R0q8FPrfk7HEr65t4IHyP4TTaxL2bdJen++nNBq0uIm1s2K1idet5yQNd0FU7umWkdFt6RaTY0ibX9I6N8R8dkNAl5An2HljK2HFVwWAOvVA2HrDR2kOa0FhjspufDy59u3EyoyaoyfiAer12Lls7XcmruR8/zgPq5o2yNYo5JhoM1x2NgkNyKwBuS7AiNTHRG+DvBbExwPbqNZp6tqcYj5cHxYsNIrBZ2wtSMpAb6B57+j0zMk7HaNKIZLJWjvX2B55CoSrEJrtori4Nm6f0cLvKWvAX0Afv9vWFa5Cp7Afon4sA7bT05kJ6XzufwffCrCHSrplghkRC3mR7aUO94X8XHS6PQP67+t8lfwY0682PlKjSDMwfEJ28LoSxbmmpUg64m2Im4S3AUdwXTFhO6MLVW7c/ZbGFXDdkzg2pS0GFYLt1CiGPiAmhxhluzPVB+9t1TZnQeP3FJZ0DEpDgR8+E+HLrTKV86oEWOXLqfGjr5H916BzzuR2L4LScmXnksn1rTyZvLOSanoC3G7xCZlpkWxPUDatg1aw1+9WixgQhm8+D21gKnFF6/xMi5XdOUO3X8btTx7WHSa7+vV79UF0vBiCpnytyquUEKhTLGXb1IoL4I3NZ81evuO5xtaTPjeoMh8MyWJ8bYqWlKOpPwGbZcVxLugT/PXam9qMgC23jF1KitdVTW8CF3Z9f2oK1xSujz7Srs9UORiad4TdbqAraStKU9T3246U4iHbSwOXXRs45bLYry2M4GSgmQ1NLWyyYqlimhoOtzK+IbGQy2n7LbV3hKBt3FrS3S/ps2sUE+3UYByIbylcqLMVhXIi5LX0tI46/CV7ZY9TYG6GpustLoSeTc1hxVbVakpT1Nfgz7qChR7aEPUbLudsGHhpi1psik3LZ0Pi83hrQw4te3MocwjnoAO8YMJaMYvALFK8d1TgTJyJ5C7CLdO9C1zj09PT68TaCWC2zNnT2S+8sicnxWEfCVlUEz+dk4Ow8H9hRz658cD9H9+ENNSZgGd/rFL/foHMnMA83olHBwK17S4DK4POOKxZqBJRJ4d6h3PoqRIwhuRA06S9pwHYY7Y7nlWFMCZBBlN8j3LINa/sxEo3XjK7xeOQ5eUs17PvGgsu5RTe6Yktn0ZlJF7iIit4aS0RyzW8h/Ff0LnbXeeVfoQ2y9/cbzlk/OXCXwZ8e0c/evDXMlRF8gF7VJyzDBOSp6K3zksmh292a7vxrZdHJPiIVvvBgUwKoCrysdD78iS+HPQKapA/GZa3mKYZBacXMBdsIBErmL2p5PAv84S4D922+6oVOgroMlreAt+wZz45gevrPjcW9aHdwwwpE9zgJE95IJ8AGYqFslQxdJATR7pLHx11vfial2Y8s8w69y4ePL0plQYv23Z5R1erGI4waOtIL8u2Z28gRWtlku6SbJmYRBF3+XbDNBuNKbvlooUc/HJnT1ZMwZh54/Z2DjksNgl2CM4cfNLAyIt9YmEpaM0fn6WezWvEnoMMjOgl9nrH+YJnFk8sStgjun0qdd3yQGSrMm0zuT8rfiFpLOzJ8f3iWdTG0kXjjD3aukbybti0sBSxf/KWUa656ICEnvPxASIx87h9Ty8q51tUrtTaEDZzrDTKWpoytUICf5AfBI6dN38woBmDjdnt+4WEK+vxdqp9b+EwvmhDVtG+JmLGz2xcxnevIid4IaijAmsGYXTs5SOwBpKi2I9Od/u2trUbnJ5pcfAJfnBIXj6WRzwPYH8XM5sa1AQwSTbYozGmxd6TRbS8kKyGMkihyQRZauH3KZGqk/2Y7icMaWKbujj52IwJKVVzvvTMYbDftneCeqPJp99J1xfs7V/DmC85tiTfjvlige8htw79/Q7ag+ZsDOCAdUnGB5leVC/zTciU/h7ckc1S32oyp/kx+6n8Oip+llx9DrVz1UoROyAz5N9QEGiI21rnLkTO5JT+CfGv4wmP/Lf6gHNiAlUZ6YtKlth4has6VRme9UFjCZ01oEK2kl/zzXVORxNYO0udmdCuzMRX09u1lFMngX0oDodl35cMD12YquocvOzfdC6ynuEQTKWYXPgdJbA5ePyuURXQfbthF37Pk1nFZulIKhV9JZ+M/nl4639/uPnX95dqFWUXXtu2Cy9Dsm0nDWTq/lnH3ZT/i0z12pRW3Dgxxf+E2WDq8Pryew6n4NcPDaVFx/Sml0JRz7sBPmwHZ/jHpf+WrolSYUS8fLpM+8dL1I0310o1GdSaejkDvZuH30SLM5PK9+ejkDw6eenGhGXX6UtNG5D8om0dPWolwYECD27aR/7KR9qQWyrFi+8YqUkVS9O0gV8ZP2Bjv3piVbjzA8Hz0dKZVFPOehCOsR8A6VvbzqK765u3l5/+HT78XoCVDm2lsntXxfsxgf/xfHc+WX4uHomfnxes9A8cxxnqn1occo2oIzH9/nzh3dWQp9breiaBp+cP6yp8IrrMFuz2SOj363TmgqeHEBvUl0IFtx/PftNJ6bfz2rKPQVqDvcKGW+GFWmoZWd/qyscAKF1sGKzTzjgDt+qBwvhiochOKR8E/Sfmq1PrR1nnpytWeTKS3nGIxD9Esp1onz7jfXBT7CB/zm1/jz5v/88+WveraY94tMHmGIAJNwL2DtbR+/VG0d3IZlyH6Lz4joCu5aIFSXgZvgzNwU1cyzZmK2ibOOsK1WzrErtLF2Sl87s2zkvqOZlNt/z8uDMHP5uWoSRLP6fVBTiTATwxTB4BZWbk5lH1XDOBRNRsQC5a24tgyD01n/TlJ+CNo77DAIlzyuPMZ5jUYpLe0xbMYcdpwBJi0BPHk+tlk91LqITQgCvfCgm3dlX6eyiQi765VupLskXI82rBd5swQrlebdJOTKYouTfTzJsYpSn/WxJYiq8XIXkE7mo5SeeGCUELkaoEpuXYlM++3R7+eVE6dAXiv2BTmxWzNjwBT6lSq98zdr089Xtjx/f2Z+uP95+/P7ze/vq+vrjtX37X5+ubi4sz43iLzCXVXtfsZhOxOHIV9gAf5FV02L5xcmgab/1R9NBvf70dqsXr6++/0hdqNyrJ5IplbgVV8WtKI+0+SS62iHdSNstoIxUGqIfkobnOgsu54XC4cwXzQSq9LWiOPy63RmHaOTm41Q6tjBpYUqoLZ1QBGzzHRFxykb3pyvCmKiAAPPzRRaL4ltBOCewvSiVwFYHwZim/wt8bw1E9DlnaDPafbW8UhlsfyX6zA8BJtWB4uBNuZM3gDb5M8LnpkTekolYOxk3mIDF0A7lQVm0WsLlApNUNUorBd+cC0EmrrnkicSp5L6irATJPEifPzGBYrnLyP4hALJiaeO8OErd4CAOb8tjbmMHn9tsk8XelZZbKopuSVlpIl6ruri/sX5eRTHf7IrdWBJ1A4dj6e5LhGDxdb+Kl/MWK1Cny+/pp1fvZJIQL8IvvSiL/6bdKn2QefBsF5PM5rpTlGwg2YEBN8qaU5KSBsgLLYkkK14ysTR1SbWwrm4YycphTUkgmjqLgpBXIYZWdSRUMJja7pUlpGIA5P0KOPcXPtCFiQtUsiDJTKbF8C0zn0/VEuYkdlwvkufbW0XVrTWUKLOD4xPNxjun39wNzCm4R/zz4qcj639af+bqXbVsCQScnwoXqgA2oBoIM5TAI+J3wS5NVZ0qdcN4VLl2ylxDAbFV8TjJufj5A/GfRheW40WMnQKH/qH1SOI4CR1i8ACgWBFTnlIZ92JYhYzvGVjm+jNvNecFQFypb92LIbkH5/HZ+UZKxczJw+rxkUWgOZFLfYiTk42GemSq+mwNgKUFfnOTwqZB4aPiFgwW20s3uBYbHzXhRKrHeRlW6y78S+JkJt0sPJcMdtkrNRkEF6YjX4fy3S91W+9JMENFlzdPOhI5fD4XjYM8LORhIQ8LeVjIw0IeVq95WIWIvg7RsIqxisjCQhYWsrCQhYUsLGRhIQsLWVgHYGEVNiRIwkIS1i5IWAUlGw4Hi/1GChZSsJCC1X0KVsEGtcLAKoPnyJhCxhQyppAxhYwpZEwhYwoZU8iYQsYUMqaQMYWMqWEypvIJSpE4hcQpJE4hcQqJU0ic6jVxSpZ1u0P8KWl2caRRIY0KaVRIo0IaFdKokEaFNKoD0Khk+xJkUyGbahdsKpmuDYdUle8dcquQW4Xcqu5zq2QWqbUkV/nCt0x1JSlCBeQjiQtJXEjiQhIXkriQxIUkLiRxIYkLSVxI4kISF5K4hkniUtxcjXwu5HMhnwv5XMjnQj5Xr/lcivUNqV1I7UJqF1K7kNqF1C6kdiG1C6ldSO1CahdSu3ZK7VL4IsjyQpYXsry6z/KqgRLazqmltxZI0EKCFhK0kKCFBC0kaCFBCwlaSNBCghYStJCghQStwRG01rfB22SvJZgDSM9CehbSs5CehfQspGf1nJ4lWd0OR84SxybJ0j0hz8uYH6lfwV9Ix0I6FtKxkI6FdCykYyEdC+lYO6Rj1exEkICFBKwGBKwa7RoS5UriXyDhCglXSLjqA+FKAw60T7dSWwokWyHZCslWSLZCshWSrZBshWQrJFsh2QrJVki2QrLVoMlWJaYGkq6QdIWkKyRdIekKSVcDIl2VpgaSr5B8heQrJF8h+QrJV0i+QvIVkq+QfIXkKyRfNSZflfwMJGEhCQtJWH0jYSnAgt2SseSWA0lZSMpCUhaSspCUhaQsJGUhKQtJWUjKQlIWkrKQlDU0UhaJ4p8C//GaU5jek3j2hFws5GIhFwu5WMjFQi5Wv7lYksUNKVhIwUIKFlKwkIKFFCykYCEFCylYSMFCChZSsLahYEncC2ReIfMKmVc9YF5poIHWCVdqO4E8K+RZIc8KeVbIs0KeFfKskGeFPCvkWSHPCnlWyLMaNs/qLnTBCUWiFRKtkGiFRCskWiHRakBEK766IdMKmVbItEKmFTKtkGmFTCtkWiHTCplWyLRCplVzphX3L5BqhVQrpFr1jmpVBAda4VrBc9JarhYLOtEr7ASwu5ee60SZifneicgNCV/cmcrciLJqQX1kdiGzC5ldyOxCZhcyu5DZhcwuZHYhswuZXcjsQmbXMJldP5D47inwCD/hRUYXMrqQ0YWMLmR0IaOrz4yuwqp2OCZXTCIqdwELPPK2sUER7UQqF1K5kMqFVC6kciGVC6lcSOXaIZWrbiuCXC7kcjXgctWp13DIXAXXAklcSOJCElf3SVxSPKDtRFkyy4A8KuRRIY8KeVTIo0IeFfKokEeFPCrkUSGPCnlUyKMaGI/qPW3rnRs/XbHTFWrPkEuFXCrkUiGXCrlUyKXqNZeqsrJhZiykUyGdCulUSKdCOhXSqZBOhZmxMDMWsqkwM9YWZKqKb4GEKiRUIaGq+4QqJSjQNqlKZSGQWIXEKiRWIbEKiVVIrEJiFRKrkFiFxCokViGxColVAyVWCa8OaVVIq0JaFdKqkFaFtKpB0KrEuoakKiRVIakKSVVIqkJSFZKqkFSFpCokVSGpCklVDUhVQq2QUoWUKqRU9YdSVQIEdkWoKloHMzpVkT9jzJtRJgdkJUBj/gk0DSlJyriSXJvGQ2R0bTCQSALbIQlsY2VG5pgxcyxvV/4beWTII0MeGfLIkEeGPDLkkSGPDHlkyCMz4JGlpz0y/BYOAYq56ou79jPl/Kpg8iq+2p0Aa5CohkQ1JKohUQ2JakhU6zVRLVnQOniNYrlpyFVDrhpy1ZCrhlw15KohVw25ajvkqhnvSZC1hqy1XVysWNaz4fDXkp4hcQ2Ja0hc6z5xrWyJ2maslewBUtWQqoZUNaSqIVUNqWpIVUOqGlLVkKqGVDWkqiFVDalqSFXbhKr2zvEfSRisovcu8eYRMtaQsYaMNWSsIWMNGWu9ZqyV1jVMrYZ0NaSrIV0N6WpIV0O6GtLVMLUaplZDkhqmVtuCmlbyLJChhgw1ZKh1n6GmAARaIarBc6XyrxYLOrkrPAewspee60SZQfneicgNCV/cWdW4iFI0gD1ehYlXYeJVmHgVJvLCkBeGvDDkhSEvDHlhyAtDXhjywoZ5FeZNHITkmsxWYeS+EFEGsraQtYWsLWRtIWsLWVu9Zm1JV7cOJh3TthMpXUjpQkoXUrqQ0oWULqR0IaVrh5Su7TYoyPRCptcu0pFplW44BDBpN5EGhjQwpIF1nwamtVGtkcGktWxJCdOVVXsygPQwpIchPQzpYUgPQ3oY0sOQHob0MKSHIT0M6WFIDxsmPeyaOHNkhyE7DNlhyA5DdhiywwbFDpMtbh0kh+maidww5IYhNwy5YcgNQ24YcsOQG3YIbphuf4LUMKSG7YIaptO54TDDZL1EYhgSw5AY1n1imM5CtX2bpcZOIFMLmVrI1EKmFjK1kKmFTC1kaiFTC5layNRCphYytQbG1HqbbLMu/Tkm9ULaFtK2kLaFtC2kbQ2PtlW70nWQw2XcZiR0IaELCV1I6EJCFxK6kNCFhK5DELqMNyvI7kJ21y7YXcYKOByqV22XkfeFvC/kfXWf92Vsu9omgZlaEGSEISMMGWHICENGGDLCkBGGjDBkhCEjDBlhyAhDRtggGGE5j/COON+uyYKEsC262G5n+sa6gy1bkayRLMVjWjctPgLlcvgxHcMmBcEk/9Ij9UN962Gdp9oU1+BWSR3FTvBzwDx5SHqA+GGu3Vw/ECo9alWCb8TffIcdifzbyjclubqrJZU3k3JuSS2nJD0YlR56F89UOfLlVmCbBLm07YwjwCB52y7Pp2T8y9Om2jBqBZ+XQUwVdp0QHDbQhNzbkw/Z3z/zgqQHZLzakB1Ds9P+Ovlcs0eBaKAp7zV0Y8Py7tijdeUJ6NCsRPFwTZn8jN+kwJRaoSktPznoU/l/yvRPKDjbFPM/63ZsiQ5VqUmKuazZtqXqP6lQk7gmtMGA5Iqi40Gmj3IdMHr0NnT8yJmBgMyKFsrQjI/JxrsyAS7Km7fKZFL7bNVHp9UK5Eix6Nt0JmONVjkjJZHLH8/r67Sq0TKukmTnJ+2/9DQ3HSyJwasbNNkrKSmwuKf1tPX8IX1LssmuIvpcsRzPm/zs/krmQkkitjmTS+qUYUH3hX3IPTtTuBeyvudnmXRLIT/HW5ye/cY6kEz/388sOKFchuTFDVaRt6aioxaH4Ux0d+EoyjmduwvWgNi6Fw2/B6gKdsmCvO7RWULmE1UBH/wopoJNGFyO5ZNXadfICwnXWS3QKhg02GOr+piMxoTq53mlw6P7yWmN/hWsW07/SsaNL0ttGLfDm6Fs3VSYodwaXDej8o9OqxX00wyV+o9mCM3QXs1QTv/KZkgYg4EYotx2W2WK8tv3WmNUeHgqq6anBqk8CmiS0CTt1yTlNbBklJg7PAyLlPrrCnOUef51Eyr35LRSej+tULHzaILQBO3VBGXql9kfjtbb1wSsxgvx1hfFUxg1Xi+3UhLsescAe2FOX9RCytWXm2Hr5lGXGmRcjo6nfyue1eGehVf+XuxUQBXRC5y5IraQ6VxV1rYN3JwqwA7fCGth2xcbLCD6pWkTCLO4iskaKALOgGEZMJFG0NZkdrHfItJM9nbuFWPFZfaQfx8pNKd69n8JQvgQiwDUUvOkgaXw32QyQXmbyLtF4SnsHJxB6W3If1uffSC6Ta3Pv9xc3cqOf3kkn7KYuTuLoSzgcQCxTFvi7pSsrECQL4Ba2gvLffSDkHx5dqPZ1xMpO52fUUcich/CJObEYQshW/Tpmk33Ov5yFY+tc3dCJmNJMeygOiWALFzizTljYTQGsnn0FKzoJ5AG5My258HqwSP2yoeAz1kAB+H2maTQFyd0HfokP1V+Cajddvy1xfZHset4rAbYGy2oJY8j3lw4VeY9OotkDXVC+lIMEaeSb2+fWAPBoNMmZQ+zBCQ8UYnPDrFd3/q0ppX4ZfIjL8ctsO0Zi1JQzlhBDwHtu/iE6k0AQ7SSBK+9gcbweX9muXxnM9nANLyxrtKEC9+FYlPByZSclAk8ELp8QXiPW8x9ESwsQoeTquJENlDnlyPI3JAYF7pxcenIjK1A9fz3o1TP2JhANggeWUAlzLK6sF2ZY3kBkFbcZzIWCumm8RPPhPpTFxZHtSMg9KWBFJPBm0XZ6ihvgZG1tNESt2OJTSizOV0cW182cOqNdXG8gSp+HUkm6Of/ZbnP1Iq/EAhRvLBmT2T2jU9VnxsCancjlw81XSR4KKP1CjGCsxl1W/0YaN2Skjnfx7Eerz+9TVINsLVpsulYUv8vnTPVcc1/M5XNllEL9aWTxqg+zZzfbKJ/ldK/00jDND+N3KaMpVtrRQCegEjkJZnGJNvFVxiRmTEhcy3NNU9vaOTxVrmhpIMjb6424JptHkTjdM8ldkf5rDqcTD0a2w29dBzlEt9uSLPaNhvSojCEtuWVDULcPsAe8j1sDTVZPljCEvhhkEwk+cM4K4adJubYaNXjRgHibn4WryszLNgFGEBTSw7BkG1dqKxoIe5849WZvTV5y/768E5rN2z5vL7YKLlPcZnLKWDd7mGkCpzOlTLJzz19+8riZQpcLcik0gKQY1hxUeqlytVQUFp76X0ltKysjbsARRRqk6o4azxvV3JLq/mORbGovLHuOBk4DctJ/AwWicyGmCWESzLwMf09iwSKZnFwH9LNcOfBfXyKFRVB2DR1aWar0I3XsKdJUL7I+g5qmzk+i26Db9ZWHEK8EHiVgn2YpKlMsGDwKRU1QUPBOabNnFEflvukEYRaM0dtXMp/B0mfQkLrFH2kvrqz8lgSwe+SuDhFTc4qfhqzDIQvJAwhBSEbBhAZbHCZI8b9vMKAyaO035wo49T50PNcD+VMg/dj6yl4BdR8zELL7/N6dM82gtCWJNxKuhnkFQnqdzYySWj5chXSPSarnTqmIvohEg5rPtUo+K6KwivNBqDft3gui1KbGUwxMZ9j6YwwmdE5U1QzmwtGS5ZIpbzH085MgzyElTVGyv2uribqVbuUNis/VCbJszRrQWLXSvi9dki5JvzA/I5gFcrzeUqTeAoDkc5NCbiTVZDpaCG+ISJ0Wsahs4CgwzioTeym7GNR5WrOK9gZ4s7sd1lb8g1Lv5Htt0R2N4WKGeV+Kxz5ludl3aFyNrg1B8sVDZYLZaxMGsiGYFoYKKO8hoX5/8dpfswk6eRk79MNdri2H5zZt2CxUIy0+HbyPf8tyZjy+uR6hGXA0qkAK17pwCizKmYINcNoC+qzdRLLuq1pMZllMceQcFHOalIxGasPh5ToImOnjbcvTmrKZikdbUVSSwbXZkkt2ZGwmmtRklTSBO2zo7r2pQJPmjr5/0DV6lug7Q8vJMkkWVuW8Pgg7eUZk9rZ2OidJKmlxBm9DXi2FaNySu6t0TujyQ0J6WbQ/Te5DW7ikC4TdUm/MgYAAOl06H2bTlU/ePXI/JGkqeWiKczQ+qIMakvd6LwFGjfRGD7DYTeXGKU0l44NMH6iURe1bXtjvfWonWdrqzBd4piEpy2CtDcGhdD5yI8TaDE+2wG4z2yHT42MwetzN6J2yiczSPJgMO1Khngygz6c1wxadvAEL8LeAY5GhBfjx9TD4OdHrHCDkrJ8bXDAQ/cfHmGFiExP4DYAJ8agpBwXyfpG1mwPzVg8IZlB4o/532BgQ5bo3KA48LoeEkZOmskvOUbjy2bE5WtQ2jl18IAn5K1H9N2Q5aVaUfdjBUeYPtv0x+JozaA04Q3ys1LmDiZHmbBeQcFZIrx6TWAb1/IEmPzoRAz8ypJkno4uTkzNTzqPNNkaC0cVNUnRZGVPPjkhz0YlbJakF/VJsPL/rdlBcNEEl3Ne5VtgNFc+gmKn2pzBBYJxFsyo6OD2iieyyXSZM/PCUoGziyjCF+GZOtx0SE+6JJoUiIh7SMy58AicS0OBkJItikVkdOjAxDEojRblp/HUrFzmyIqrMGAymjQJ8szQEQHW3CX1iDzIL5AYm3lAIrCozGtxTIr78I4BD8mLIqcgtDNbr+BsaNt5UvqAOkIsianZVNHuQCvrFcuDnG5uLrP2iy2KmEnGBdbvfVR1bLQdyv9XGa2pyZCON6pntNnjfDWL4HglxW+JH61o/XSKnYVkw9LgIhmYzwGfmVAun56TjQraYr9Tj1FU3PBC/mxZ8oqanNmKeZLl0eaZcBW5iT7/Qr/46ernq19ur95dbDQ88oTVaqncEb5JAd1+glTgic1MzZQfbFDcvWpm3Cc8kNdNWsdAnMB6duffRTFt4jPPN+ZYc7L0gjU7u3ajk02U0IMrkcBsTiw64iFsCRZUpZ8YH+VvrNsblMcH6yy7XiKCbUwIC5uwsBsUJmwwfXVjG5yiLLQX3xTpMtvQaaYw2e0ydANe2F7zdG/Zyqsphz8JG3mwCIwoRCaPkzGXsMuY4g+knFCuWMZqSac/mY8tSEac8yr8mKtvkh1XUwSkJnDg9h1GcPsXHCPw9wN2o9Ramz9XnUvOjTjkw8oA8pvNh98NfJ54p2bP6AWPgKKwbD71q8lpwjRnSgxtl8IkPNNXxP9Zl+CZc+UXjgvzhcE9jpX2Jklzc/Yb++P32rTNrJXsbiM+qpPJ6cn2ZjpZ8UueWs1eGcAq19ekhi8b6Gld8ji9DN9Y14RlRnTjlbgiRChksuFNTW1IXsfsfEBQcUp5hCdmOZb5sCRKmSW4Yg49z/oCW+zzxIHXD5e7SEo2OjwtLEBFporIQlvIuGxk0fiz9ShJLo93k6ZJ0krV1l3N1qhrnT7fcjmt2D8IWTI9CUL30QXC1mLlz/ghaHLCKgib1F+hDgFPeQjTrFRSovpgGoBsyS3mSlzuBZ78WeQ734gNx4ZnKclVdnUZPAzVFHWS+a8JZ6QBbf42XN8GaeJjcZpxVGET0hHobhiForm7Cqs4Xv3opXDrBIfhDRjegOENAwxv0K1iHQx32JlFxLCCLocV6LR0H2EG+vobhR3oim4rDEHb/GMMS8AQAnkIgU5RjEIKMAgAgwAwCACDADAIAIMAMAgAgwAwCACDADAIAIMAMAigt0EAUp9wu6AAnXuJQQIYJIBBAhgk0NMgAXGhe3KB2IRKKV4zy3sFf3UvOkB7QILRAhgtgNECGC2A0QIYLYDRAhgtgNECPYgWkDvqGD2A0QM7jx6Qql43ownqm4rRBVtHF9A5D/jxLBneBHKmWisd99YI5qUTlSMORCg1sy8BCZVm7ycw4Rj1ptfCNhUkBixgwAIGLAw+YEG+2g0ncMHcUmIAQ38CGORau/9ABlU7WgxokFexm8AGRXcwwAEDHOSnnnKFwUAHDHTAQAcMdMBABwx0wEAHDHTAQAcMdMBABwx0wECHYwp0KJmuNgIe5O4mBj5g4AMGPmDgAwY+HCLwQXHAggEQGACBARAYAIEBEBgAgQEQGACBARC9C4AoO/AYCIGBEHsOhCipYB8CInRNxsCI9gIjkiMSZYRESRBNGO/UZP4U+I/XK9+nj78n8ezpuAIkJAPQ4bgIaWt3Fg5xrMrRomjhv/+ofhR51D7ZsAW0I1gY55GyVtePv9J+fvYjdjnL519urm4PpD41qoFxFRhXgXEVQ4yrUC+SHQyn6LPJxUiNTkdqqOfBXgI0dNU3i8tQl9xaOIam8ccYhZFrY9UyKcMuMHZDEbuh1i6jkA35AjGtfjTGiA+M+MCID4z4wIgPjPjAiA+M+MCID4z4wIgPjPjAiI+BRXxIPMotAz3UvinGd2B8B8Z3YHwHxnfsKb5DcxqDYR0Y1oFhHRjWgWEdGNaBYR0Y1oFhHX0I65B56RjNgdEcu4/mkGheR4M46lqKsRvbx24AFAfIjh3y0bUXMLwQsSEZ9QZc/B9IfPcUeORGjlEPOEKj0PPuhmaUmrmrmIzj04NeCVMlKAyNwNAIDI0YYGiEbHXq8xUTppYPAxW6HKgg08p9RCjI620UmiArsq2YBGlz8UoIDCtINESmIHgFBAYEYEAABgRgQAAGBGBAAAYEYEAABgRgQAAGBGBAwLADAgq+4HaRADJ3EkMAMAQAQwAwBKCnIQCFhe2RmzlmaIXJ614MgPSEA8n/SP5H8j+S/5H8j+R/JP8j+R/J/z0g/xc9cmT9I+t/56z/gsp1k+6vbiLy/Lfm+QMw/AqjyrFYYIjkh7kBofs9tUhwPn2V2tVjIvdXet9dgr+kqbsi+R+nTvROqDqBIeEfCf9I+B8g4V+1YvWZ9L+JFUTif5eJ/yrt3Af5X113owAAVbFtBQEom42BABgIkGiJSkkwGACDATAYAIMBMBgAgwEwGACDATAYAIMBMBgAgwEwGGDYwQAVf3C7gACVW4lBARgUgEEBGBTQ06CA3t0LoDwAwbgAjAvAuACMC8C4AIwLwLgAjAvAuIAexAVUnXOMDcDYgJ3HBlTUrpvxAfpmYozA1jECYD9ssB6ZLaSKWhnuFnjhQmJHGSkg+t79OIG0obuOEjgmbeiZQNXCwvgAjA/A+IABxwcU16khRAfU2z+MDehDbEBRM/cZGVCuuZW4gGKhbUcFlJqMMQEYE1A+NCyqCEYEYEQARgRgRABGBGBEAEYEYEQARgRgRABGBGBEAEYEHEdEgPAGm8UDFF1KjAbAaACMBsBoAIwG2G80QOnAA2MBMBYAYwEwFgBjATAWAGMBMBYAYwF6FAuQuOUYCYCRAHuLBBBK1+04AFkjMQqghSgAYR9zMQBijBtwvoHodg0HyBG1gD9zn/+owgBkA9DdWAB5a3cVEHC0ytFH0daIDeMDMD4A4wMGGB+gWcD6HCSwoTnESIEuRwpodHQf4QLa6hvFDGhKbitwQNd4jB7A6IFEUTR6giEEGEKAIQQYQoAhBBhCgCEEGEKAIQQYQoAhBBhCgCEEww4hkLmE28URaJxLDCbAYAIMJsBggp4GExSWuUdu7ZjZ1R1AdC/EQNdajDPAOAOMM8A4A4wzwDgDjDPAOAOMM+hBnIHUd8dgAww22HmwgUzzuhlxUNtSDDvYOuwAjBS1jGJw7cSDn0rZxVk/gX+cEEu99Tkc5ZSsKDUmq9BPZXhH18JrsiAh8WdkYl9n757UnDmwY6La84bsbIM/rwGmCycn/On8RyUiY9ZnOu2jyLI/JAhP7K1LWLb9SnsJlfJuXsh7X3wHRtK2Xd+NqZWsdos2r9qD/6h+ZFRz9bUcXCVjy+a+nnzI/i4N0YW02ZPSaFCdKn6geCuPoE3zDayOWwTb5JVHmowb3eHUcYlgYwO7ovSPjHCbfgU/5sTLOFASPqxiLtyIXlSHUT+HbpS9V4nA7NhO/mbsRN8i+QswhlP4If86J8JpRcS1h4FMzkvn1e+5kKELG0tY3u8hiTcLZ4GVyFTG4pz0YmsifkFU7ET0QsYvkY+V4ESFeroF38Ncr3zQmiv9puT0nvV+dA9FpiA9P42IVsslDwh85WSxNPhBt7M//eQRoCwxLMFiYLw/LxxrrIEDsooEtYl2lp2YaEqk37rP0BTwyQDGpSX84dSUZCo0nW+Exch/T2u+EYOZyotJY1JYZie2XDnU6pyISDcFtGqa07INdPg1dGOyNyVmkxNqDC+kI/rB91yf3LEngKwE7uEX0wevSbTy4q9G9pVHnFW7kYXpAN9AGqaSPWJ/9oEpN6156Jebq1v1XDbs1oEnO1eTIc/2N9Y9C81gXQzEUnvB8aTg2Y0ZUsTHIbyXBuwl9gJoqZxBRkuiHZAcKkNNNvWl7DrlCUkUeC+E+dgMCOKVcJq2fO1jLRyzKox4S83MHKvOfnE8l+456C7FJosFnHd1x/TlBkXOdQJZhGySTYVc5BVAxBMP32G843KzJo736qwVO5KV7+aGbbrZy6zmZeD68VT0cpJ9JGOcjJrEVjMVaDGYOl0ZbkPHjxwGKmwTlyh9WBkZt3G4Pft9mPj6UhP4UUDrMfNHJtcWhaTYQ0BMtz4s6L+tZIcg2QTkjyOVxczdWQxljS0osKbERspUVhQMy8ew/GGaAJnF72BA+hCtzmDjyPO6tI/A8WJ9jSLF80UpI1k3iwwvtK7voeDFWOjsX7QifYEqSrBoPFt7aKvZlNI9mI+d5Q9vH7ReOVM8ppj17UUmjWvPa7lRIHtivqfwQ006SzlqyR+msXY7CO3WowVZVE3JpVf4GqUtxbhurMd1olY9kPOsbTsXA7YJzt+rQ3HGD09Us4GTeEPiy/m/CDvpPj4MIN/7w0IBxZbsCBE4TmHvfovuJIPacJ/uhA9uHDrhOiG5KMtTxopINHryC/1B5oIgY9CMEHIF0CFZQKF/ob4tFdhc2RTaBG8Tj2FLTVdoMaIWiFoMG7WQzOj+gBdoGVu3jIOFVCQC2geyIq22EcAiKbElnEXWVoRb5I1PTY8R5lIxMEZvSe0Bwjbdgm0kk8YYvUmVaJr+pcZxKjo0rXyiflmqSlPpp/2Dh/SOJ6JEu0KJ6L7DzuzgtOA6NcARcvvo48aPFANxWChJ2agdoUpHrw3oRnXKjWqu//W6jbATwk7Dhp30SxsiUGg6Bw1G6dV/H7hUXQsaQVT6wltCq2p6gMAVAlcIXGmAK/38QQxrvxiWsZuLcNau4Kw4E4FdhrYU4mmEa6xvg7eQgidczWKxvz5GjEsyDIdGuKRN2hm+ddR60FUh1gkIIRqEaIYO0agtc1cv3Nxy9g8YZ1DLcD8og67+hhiDuujWEAZN648aX0APvhsevFo/Da/C7LJDbLQvRnd4d+7wGi5amiUiSAaZecMS2bTmA5U2NMfuE5eK65JvXGnaXnzko9WPrgvVVGDoO6PvfEy+s9yC98uHNrYKR+JLy2W6f59a1Y4WfWt5FTvxsRW9QV8bfe1O+dpyPR2Yz127z0bfe2++d7JjUTrhJWE1cbaorH4K/Mfrle/Tx9+TePZ0hD64ZBQO7HpLW7Qrj/uolWD3vOHIo8aIXacgGEuRslbXjzci2TZTkxoVQNcdXfeBu+5qw9+fsISumJfhggFqLdkLBqCrvpnrry65LY9f03Yk7csbX53PyKbvGD6g1mpjKn1VytPqRz2kthv5Eggm7AxMgPHyqADskEvAXoAIAEKQSKY9p5HfO3T00AEfhk5hB0mT9gMeHJsedFWIdQJC3x59+6Py7QuWufPH8ZvN/mPxvAsyPIDrXaq/Td+7UPRunO9i6/GYHd3obrnRBf3s//G62b4YPeH9ecL8Js+qK8xl0+R6RBLfPQUeYbecHuH1l/nuH/gazGJTdnUd5nHKu2tCUwkEfVv0bQd+/aTE4nbdpzWc5cO95lEis71c9yitt9m1j5Ii27r+UdZa9FXRVz2wryrTy977qDX7WPRNd3blIontVxh5O4KhBzXLi6KBa/Lecb07ukhe/TojbNiPzx2tDMFhXVJJc3bklh6x7LsoPJ1g0EVFF3XYLqrKCnfdTd1gxg/WVVXJbh/uqrruRi6rqtiW3FZlq9F1Rdf1wK6rSjd7774a7HfRhd2VC7ugg2/Dlo5uJcTwU5WriKQFd+byIQhjMj9eR1YMQDfc2LQxO3Zij07q3ROcWijovqL7ehzua9H29sV5rZ3rg3ddi3Lbp+NarrkVt7VYaMtOa6nF6LKiy9oRl7WomYNxWJV7W3RXd++uOnzwc86qEEcDpyXZsuzCW9mvz5nUdlhnM2vFjrzM/gusQ0MvGVZ0ENFB7MeEURi+rnt69dMU5iMJQzoIYl7Y0Wq59Ji7d67Y5FP/gar4+ZfCTjLncsUja0F3ejEo4BedRFlETSKizcCBr18VjcvtsxanZ8kAnHGdfhX/pO2nqr2iAnyg8546tfOVRxf7Bd060qfOfiu7kaOJbcM8tu3fz6wX17Hu+R7uC7VyXydJAefsn6N01M9nSdf4F/en0harXQDzvswcn7lWtDugIklf9D05PdlqF7zdfvSLsofmc368QRnmpgD++yr/WDUzpuopI9sQHw2uUjKP+wBUKlU2hDvK5SHOofViNbdAF73caOm8+uc546h80cic6NfxuncMHhwZ4gYI4BgBOJ1SGjHXS1PdOCkbU4Qdqlh/8ZN0TzJNnbwG7vc7x38kYbCKVAIZ+tF+aQAOi7ZUGrMj0OVopb77HMB0QjtzJ3YaZP7ltpw1v3EpQoGaFQMwSMMihJwblvJAnJCEdhx8I37joQFZNyxktXLnTcc2Xj00LCJ3VKAsKYpDo8Y4MbE1faovpiV7prZVCGgioDlsxot8S9KfNPi4BOISiEvgpkvgYAFLuTnbB26pqrkREUxeaEtEMEWL8YIGeeOTlSa7lkHzcKL3Zs/yaWr0MKwNRg8mt8iZPJu384ZNhhE0ehRstlnPqGU2ejBnfw0L5lYW79PoFt1Pbn+MUdtkPk6TP8aaM1dW9DRUAW7lDdw0+UP9KEzEKfxQPyKm4HRWd9qZn3/T/D90LQUBTPkv9WMw+6bwQ9MROu+m8EP9SG7GTbVcwfLGZpr80b8rTWphS2Rt7urUYZ4Mvc0gkIiajJI0GsDRN3EQkmsyW4UR3aj+zLGW4zuKkA7DYQ8kFE3a0bHEkevBPpAZNqTKqiBTczThNU0euQ7Yy4e/TspC2cQDbqpDdfqBgDACwsMGhHULQ59g4e4bn8GCcDoV2gcUp6+/ESCnK7olWE7begTnVOAcXyIR4ukUxKPT5Q2AHvbaVPzuH5Rg6GogoLArQCECAdCBExJIeP5UT6WiaeBVXtOtJIILslE4LLYgb9GOoIXjVoKOirBGPOjYo2M/bMdeY5S7Hva62dQfrF+tkeA+3Gpt9Y28ak3JLTnVurZjRCD6yQf2kzXq2fv0R2a7YXR+d+X8hnT8pb6vTDANvB66X4nicDWLL/05HrKzVad2SA7rFBs0b0ceMurKHs/C5mQZPzXgvO9MZzbRB/TP0T8ftn9uulj05xC+K4ZnsICAqcrsAx0wb0sjqMC0mpZwA+Ne4cG8vPHMBuCxfLfgBlOtNj6iZ1Kesp/9O57fwhlBtGJXaMUsEYbt+HNbfXBfK7RsDGYe1SnLvqGb4A/JsMXe+tzO/4sa8GIMAvVK0jyQ0ghtoy3Q65Mmclp8PKcb69h9Jukf2Q4v/Qp+zIkXOyZJQql6X6fazfp9I3pyoZoiBu/KZwGMRGVG2c5y6YHDQPupDP6Rvxk70bdI/gKM5RR+yL/OBynxsk0nSR12Abrg5jWHid+iPqUT6UO3hayoZlhPwavMZ8m1cfIjS7Slf+bT1bV99/H6H+9/+nink3pet4tSL7jhW3ad9ucbyaLfIcBs8vnzh3dd7WalGyf62Wwu2hONAcgPkWLupyMnLzA/mvWOWmmQq0VuN5J6E/FBOaxszhamtyJeMj9zNV66cLgnucflNolJb8p+yk0FFcyU/l/+JR3zKf1/Xd7XUVG7liS0k2x5m9qHkXS8mQ0rKC0rUFIvZF1mtnZXFZ9IR7g6QjB09fP6w+3V9eXth4+/jHUD6nivzjpiPdq6mfXtufzp7vK/bpQNEVuHz3TT4719ghjE6IaOdLRwSXReHN8fiE9Cd5Y4quIdukEFxO+W7ma/lrcYhc2dkBkVTvGZciIXA/iqVIBoQlkfkqZ9+fJ1XPrqEvbL7Dt1Z4rYq82xWfipeae6w6IbXN+l++MGOyz5INZnxNkqPfWuBrNak9GAlvT24kS+x6oMEZ3+lc8U7yZpJKbJAKqeE+2CB8WfiiehT/Qp+KU6DpjxqSab/BW3rirOxAxHkxWMmJ2UptmFVkZDt2XVhvMXR0P+DMPNssGodeCygYlS42M4YWhb5wzWVGusRr0sOqZeVcuqy0EmOThSCKnLrADE0lwnUyG+4nidj1QXFKQdOU+KqL8vIHlSl8D4veNF5KShiu1HtZKxba5U+WWtvCgVd2wX8m2f0Tq2C2tv1LrtFgml+SzWSTW3+EEjo1sZI2BrbDC5my1pOn9AuufJxcE5Mfl60d59E1rN/2Lewa+11rRksFLLc1Gf51wKWTCJieaoMchNRvm8Dt/gyjPdyMAYJaNJRmNqsIAVVKF21Dfjh7Cy93BL1+aUHvb7wNekbTJRRXv5Qvi1dSJP9wS1+2NtYGk0TPxYm7V07s5iKGsM69TXTc7Jd6sdmcyRkIOEnIPNZpk17g8v5ogMyA7vH2t7T7gJCyWvdy0xTfJFIptE0Xhmj01yflaTtSLzpAvMk7yWG7NLQOpT+DFumgy0PVdQySZR7IiN7ZoRc8SIPbJfZ1TKTTFxSGtHZBuntLAuDYshw7JVJTOqget2G65vg5RGI5bKTvrc0pb2yAdXtH9XPnn3BTsMqajHGn1j9I0P7hvrrGbn7znf5UQeqE+qk3dLPqquCkyjgN7lob1LnX4a5lHYuX9ouDtDf3Gv/qJ2DRmW/xiHaztmC5MItMgoXtJRaM0TKQXO9sDVLLW4ty5npR/7cT27LPBhSal+7NElRZe0Yy6p3LoO2DU1n+BH4aLK5b8TV1VeFbqs6LJ2y2WV62k3Xdfa3R26sAd0YRVrzcBd2SRJk9KnLQ1LE1eH6upPgf94vfJ9+vh7Es+euunSShraJ09W2vydObBdl+ru2YmRRw0ASzhB/R4Iu4raSuG1V7krpYmeMHrCh/eE1Ua5PzzmflqKofrWao1qy6VW14CEZUXjq1MEGckdc8DVWm1MUK5KeVr96GCMZLM9LXrr+/XWNYvWwJx0UBOPdtUOeV/tBXQWXHPJGDSJRSXx3VPgERaQ3M3g4XwL+xREXGz3zoKJOyvAfkuhOrboA6MPfPjgXYk1HNTpr+mEHWqQrES+bQXLSorG01x0Jg8e3irRy66c3tbsrtD/22+AqmxtGFigKontV+ijHUEnYZbkO93AUXjvuN4d3c5d/TojTMU66e1VWtkjj0/S9l15fd0WZv+lIR9j9ADRAzy4B6iykIPyAjeZvAP1BFVybskbVBWPHiF6hIf2CFW62RWv0GD3hZ7hXj1D5XoxLO9wQbtpw47MJklH6aypdL4Fx+LyIQhjMu+0jyja2EMPMW35rv3DLoqx75KQjS96hugZdsYzLNrFQfqF9dN24F5hUcYt+4TFwtEjRI+wKx5hUTO75g8qd1voDR7EGyytEkP1BR3ezZwnKDrewIG4pnuf+iu9O+AMyhraI49Q3vxduYWdl+ogZKIcafQS0Us8uJeoMZiDchU3nMUD9Rc10m7JadTUgJ4jeo6H9hw16tkV99FsV4Y+5F59SN3yMSxHEu5ipeoiumon+8WpdA+b9RP0n1/kzC7atbIrgkuTwUBlzmvuLJ7K7/Kt6pBEW0bFJkezJzJfeaUJVi2/lLrh9Yn4dRubOd1csuDl5I9sP5V+BT/mxIud6nZHt9W5Ea3eZGSTd875lbfOcunB/pc2mU6wcXKxvBN9i8ase1P4Ub3wOqu68d3UxSZssE/kW7HL7PUPc8lWifVFfWe7Zht2Gzp+5LDpKXZi8q2wYtsmfThJqzUppc/6mm6dbqG9N/Hq4avZNd67V0HJxNpASrm3Jh+yvzUbe/hYdYN4UVloGcUPFG8xHaAPs9+qu8npQNJHiB+tQmI/OREbkn/Ttpzn5oH83Vwfi3eTlxcAIeN07RHa2cVrg6va36srnpMXH2L75S+Ot3xy/jJhg20vH/46gUn2Yd6fO5ybCONYb2FtSQPK0jWD6zopcrzrtytaZoIr5R0Ya7N9yteRBKD8/L8s93kZUhP2TD2MC4vu4GbfOOzpE5d6AqG1DCKXj4TlhI8reM56dSLLmc3ooubHVHRrScmP1BOg/qz1eP3prSU0kk2SyaYd9+mHiUpXByH/zVR6228L9eXADIP68O7jVoA2vKm4S2Bbr28htu3EmTdelpgD9I56Qrf0Dzgph9//m8oBJuW54bMTP3g9H1l/zCN64DKUJrBiaPOvjNXOWRViYppZKkA2KMk4brRWc1v5Q7ic/SxeV5opu4DP2e04iFLwT1L1A3FCEtpx8I34mrrZJkG0X2ZnbbkdlM97syU8N1vr9kLy+Vps1iRv4/TtK4u9eFiRFmRSaX54TSsuiqRUef7LE8mG4nI+TyA5ONx2/UUQPjMfH/BOcW7Mmj85qemzfMKdV2XxRBw45J7cXt78w755++PVu88/XY0V0zUzMRM3Cnjrzkd83LLv+Nw8OxtJoGFqKM4LTaUmP14t4dRAatRgT0lnAetT+eSA7TdrzyGrbdDdsF57VpCbkdPS5Je/kJr0fLflj+b1Y1rWJaPTUAGC5sYN7ym3bkh8Of8XoZ18IV2FjPJtPCLkqMui2b1r7yRdb+jfO+GDG4dOuE7Oq5TlQSrNaMLbPnnkusfkK9G/yS/0B5mLsy6DZoTkBbYAzgIK/YvIWqtsCm2CdxA8q6BzA4C1JKLrD7qFUwDBtu6DbRLV2AfmJq22EfQmKbElBE7W1mEAcamJMkLjKobI6C2p3UBAb3+AnkR9jXG9VEGm6V9qhK+iH9PKJ+qXpWoylX6KwCEChwgcInCIwGGLwKEerkD8sFv4IXWq7GzzNi04/k1ueMxcoT4gi4rmHhHI2BOBIdgyTLxRpX4DgB71tgVRSJwYiEK2h0LqZ9s+AMm6FjS7f1RbeFtXkOp7gIglIpY9QSz1mozgJYKXCF4ieIngJYKXArw0hkEQx+zY/ceZ4OwypqkQaiO0bH0bUO+K2s/VLBZuVnfBTUljjwra7IGwOjrSdaM4CHxOPT26mt8MYaaDw0xqpdkPyKSrvyHEpC66NYBJ0/oewUsI4OwewFFryrbZ2BAPQTwE8RDEQxAPMcFDjHwnREO6hoasaedBslxwiYwZGCKRaGvedSl1XT8gkVKjjxYa6bjwegaRlEdzcFCJfNogZIKQiQFkIVee/UMnqna0CKHIq9gJlKLoDUIqCKkoIBW5xiC0gtAKQisIrSC0si9opdb3Qoil4xBLkr5fibWURNzEbacq8FPgP16vfJ8+/p7Es6fOQi2Sth4TwtIDUe0+dijy6MTm2zdOXo6Utbp+fJgINJmghoDZqOdff2LPuqI/CAe1Bwep9XIvKJCu+mbgj7rktjAfTduHEZxVne8YNbVHhEitX8YhU1UJTqsfYQgT4kqIKyGuhLhSm7iSkceJcFLH4CQQg0fFZodcbvYCBAcgkkSe7QESd6FLV/yegEe8sceLHnVTWN3n5UhHcXjYTmF6IA8HgRcT5KOgNAdAXkr1twm9FIreDfZSbD3ybBBFUaEoBU1Bfg3iIIiDIA6COMjecBCV74RASNeBkFcmuSoSwiXawLv+gcR3T4FHbmK6FnUVAik08oigj04Lp/OQR3H0BgB1yKYBQhwIcUghBpmy7APakNfbCNKQFdkSlCFtLUIYCGGkEIZMQxC6QOgCoQuELhC62B10UeP7IGTRLcjikcTUvlN52REIDNbPvAAbOMHvHdeDxezq1xlhs7SrKEWloUeEVHReSJ1HK6ojOADEQjUlELVA1EKKHqgUZh/IhbruRuiFqtiWEAxlqxHFQBQjRTFUWoJIBiIZiGQgkoFIxu6QDAPfCNGMbqEZCyoy+5XKzCaJ0KhGVATZgsN8+RCEMZl3HdMQzTxCRKOjAuoNnpGM34DQjOJkQCwDsQwtnlBUl30iGeWaW8ExioW2jGKUWowYBmIYFQyjqCOIYCCCgQgGIhiIYOwewVD6QohfdBW/cLjIcuiFEGID1/iONnnh0WWso6BF0r4jQiu6KpLOwxTpwA0AnyjpPQITCExI4YGSnuwDkahU2QiKKJXWEgZRbiOCDwg+pOBDSTkQdUDUAVEHRB0Qddgd6qD2aRBu6Bbc8CokRaWfCK2BL/vO8R9JGKwi1draDZSh1MwjAhs6LqDdX8WRmIcGF3BwG8Ca37iUaEk7QBoWExFv0bAIIb2GpeSNaeOhAVk3LGS1cudNxzZePTQsIrd+6XeQBo2hG3db06f6YnYDxZXNygAQOfka0Z87h9DQoaFDQ4d49WHxarkV3Qdsraq5EXotL7QlEFvR4mFciZXHl/hFWJqHEy01e5YvLUYPwwJi9GByCarJs2UUy6DJMIBGj4JhN+sZNd9GD+aMtGHB3BTjDWb7O7GQWwLjy8tSNCz5Y6x8VFQ+DVUQSHkHN03+UD8Kk2wKP9SPiOk1nak27VK0Lv8PXUtBcFP+S/0YzKwp/NB0hM6pKfxQP5JHKnN/68rk02ma/IGXyOH5E54/4fkTnj+1eP5UC3PjMVS3jqHmicDsBZMYVYaSDBscetzEQUiuyWwVRtQX/plEkfPY2YTp0sYe0QlVL4S1D/iWdVxZFdwzEE14TZNHrjtMLOWhO8h5gFyIAzgV0M3OPp0NdF65EINtDYPV6ew+kFh9/Y3wWF3RLaGy2tYPBZtlnUKEb38In06rNsD52GtT8RuRJESSEElCJAmRpBaRJEN3FPGkbuFJEYiNykPIzU62OFO5a9oAr7imk6Iv2JKsrUcELfVBVJ2PupYO4gCQHc3cwGhsRFakyIZGZ/YBrGirb4SraEpuCVbRtR2jtxEpSZESjaJgJDfiH4h/IP6B+Mfu8A8znwnhj27BHyGVmhT9kImzgUdN9/zUYq5m8aU/7xXLprbhRwSL9E6IuydIzMkyfmoQDbcb6KVeUAPAYUxnZn/YNgdUJsR6WsN6TPVyH8CPeVsaoUCm1bQECRn3ahisG2YWkHOzPyTJVL+M+TdMglP2E7k3iD0h9oTYE2JPLWJPWzimCER1C4iaJSK0HX9uq1k5taLOxoDOP+v+LnT5ig7Kc2/NHJ9Ne7BYluOvRUsj2lTr3r4RKn9Pu5krZhmSF/A8HOuVlWYt6MJvzQOY0451/z4IJiFZnI/uaYlzKw7X8EWhhGQuTawfg1daWDi2Xuk4O7RQOqC0LcFrVjr9JHk+VwQsiPASVZNssEQL7ojz7ZosSEh1kzYempd78x5C7JMWUjnDGk6NBBQmVMiBvtOHlP0PXqjyMw/KipwFidfcTWMNj1gLisMs7bx1voAtYAzNGWXSn3l0qbEK9Z+nkqBb+GL4HwHT5PounbPn0rRP1anjLJeeO2NmV5cpSLUQXmavf5h/rRbPrFa51Ld0aJwHj3zZzE+WYxXJ80neTd3D9HMS0u5MrsQfiQeeuk8AAUQ38erhqxEoAXpXN2bpBi/5I2tade+nhkRM0kJttO9SgKfyNZ/NEr4G0VfZb8UzbCpOLeJHK2qlnpyIde7ftNRz+GrK9suKd/NZVab5Hpdtt5AWs1SgSULPGsC3rMRdQLSFya9X4TYgefb7iGD3vstt98Cp7zyThonkarMgzt1ZDGXRrRIt8CCwPleEfUH3h9UO2WTvD5I/JIV8Y330vbV1z3en9xHb5N7HmcjpR9FTsKLew/19stejW82x5UjKuk/yiN+nL0VL59WnL0x2eypR0Oexten5xfEcYOSn3D4OKYr1NTqIyBfV0mFDoXXDOFAA62SU0q+aixEPH3Z9+JDXN+MDBpDoFH6Mm+b6G53Uzpec/TA1t4qJI+CHcw4EJhHPJHxxZ8JPPa/NDJhvT00yvZAs8o9P7PRjxVhMFFtvYwCR1S2WxGnpdERe5Wgi0Dw8EcITITwRwhOhgZ8IJQh0W0dBGovd4+OeXh3lsDxQyYamSYI3El/O/0VoJ1/IAGDLfHeOKU3fMKS4e8zISUapIXDkhA9uHDrh2t46e5tEVSe/0B9kbpbOjRv2F9gtOAso9C92RKgY1IdvtAneYRIQ5tXzuKBViZT7g7DibEHAFwHflvI+VhV4L+keZdU2y/JYLbGt5I6Stg4DDE4NqREiXDGXhvfYSKwbgsp7zCJZVV9jbDlVkGn6lxrsrOjHtPKJ7kIWiZpMpZ8ieF0PXus9L8SwEcNGDBsxbMSwO4dh1xtuhLL3A2VT99rONsjTAlrUABPN+ZsDA7kVPTsivHt4skUwb5jQt0pTjwsF11ssBMRxDiEgfmyAuN4m7AMbr2tBI5hcX3hLiHlNDxA8R/C8J+C5XpMRRx86jm7s0SGkjpA6QuoIqSOk3jlIfSMbjuj6ftD1nAdtl5F2hcAaAbPr2yBNHyT2JIOA3CX9OirAfVhy7fzFXvIBPzbUWD3phnULGIKfRwd+qlV7P9Cnrv6GwKe66NZgT03r8b4yhBVzsKJaU7a9sOyoUTqjbSBidIjRIUaHGB1idB3E6IwtOCJ0+0Lo1rRjdpacW8iPAXQSabUG45SyFw8Opiv172jhuuHIuWewXXngjxm+k09GhPEQxhsMjCdX8f3Deap2tAjryavYCbyn6A3CfAjzKWA+ucYg3NcQ7qvdRiLsh7Afwn4I+yHs13HYz8iSI/x3IPgvuV1MiQOWxNcEJ6Li/SnwH69Xvk8ff0/i2dMQYEBJt44J/RuWVHcf1ht51FzwnR6P2ImUtbp+fJg4cplMjwxPVM/q/kSQd0XVEKo8NqhSPXv2glDqqm8GTKpLbguP1LR9GCHWVauEsc97RC/V+mUc+FyV4LT6EQYiG2CeRptnhDoR6kSoE6FOhDq7B3UaG3BEOPeEcMIQe1QkdshlYi9AKIBrSmTVHvDF9yPDwzN57ccLaPZert2nMUoH/KjhxsKkQ9oiYoHDwQILqn0AMLBUf5toYKHo3cCBxdYjLRGBPRWwV9AUpCM2heZU20DE5hCbQ2wOsTnE5rqOzeksOIJzhwLnuBtYRee4tBrAOD+Q+O4p8MgNLPQDgOUK/TkiOG4ocuw8DFcc6OOC32STC2E3hN16DLvJVHofcJu83kYwm6zIluA1aWsRVkNYLYXVZBqCcNrGcFrNNg5hNITREEZDGA1htM7BaAaWG+Gz/cBnjySmRpvKgq+3sEnJC6cByvLecT1Yoa5+nRE29QaAmFX6dESo2ZDk2XnkrDrYx4WeqSYaImiIoPUYQVOp9T5QNHXdjZA0VbEtoWnKViOihohaiqiptARRtY1RNYNtHiJriKwhsobIGiJrnUPWDK03omv7QdcWVBz2K5WHTRKBUNWtCKkFVObyIQhjMh8QxiZ6dIQIW/9l2Rt8LRnq40TXilMMsTXE1gaArRWVep/IWrnmVnC1YqEto2qlFiOmhphaBVMr6ggialsjasptHeJpiKchnoZ4GuJpncXTtLYb0bR9o2kOF0cOSxMCaoC+3AkPbwAQWtKVI8LOBiC9zoNm6RgfF1pWmk0IkyFM1mOYrKTN+8DHKlU2AsZKpbWEiJXbiFAYQmEpFFZSDsTANsbA1NszBL8Q/ELwC8EvBL86B37pjTaiXvtBvRKXiqppIpAGOMk7x38kYbCKVHuX3oFdpR4dEeY1HFnu/t7KxKA0uK2Sm1jW/MalREvaAdKwmIh4i4ZFCOk1LCVvfhsPDci6YSGrlTtvOrbx6qFhEbkVT7/ZNGgMuFeaPtUXsxtEuGyBjgsYlq88/bnLF20i2kS0iXhsgscm9ccmclu/j9MTVc2NDlHkhbZ0lqJo8TCums5ja/yCac3DiZaaPcsXQKOHYZkzelDotdGzZQTPoMkwgEaPwvJj1jO6yBg9mFtKDAvmCwbeDL6/gzO5JTC+FDwFBJM/1CdDovJpqIJ/yvvMafKH5rSJTrIp/BjXHp7NVK6FFLDM/0PXUhDclP9SPwYzawo/dKd2q4cp/FA/kgdrc3/XnQTSqpM/8HL2+mPQWsQOT0PxNBRPQ/E0FE9DO3caamS78VB0P4ei80QY9oJJg2ptST4NztVu4iAk12S2CiP3hfxMosh5HMJ9T9J+HdF56dDkuo8TAjZGyqrg8rVowmuaPHI1YxIsj/JBTqfk8j6uMyrdnO/TSVXn9RBPBI7sREA3s/ZxLqCvv9HpgK7ols4ItK0fykkB6xTizfvDm3VatQHqzF6bit+Ia9bjmoY7a0Q3Ed1EdBPRTUQ3O4dubmDBEePcD8YZgUjoWAuZ2Ml+cioHNhoAY9dU0weId8q6dURw58Ck2vn0KNLxPi60UTPjMG0Kon09Rvs0mr0PsE9bfSOsT1NyS1Cfru2YZgXRuxS90ygKplzZGJMz2/4hJIeQHEJyCMkhJNc5SM7cgCMitx9ELqQSkQJyMlE1QG7ozoOawdUsvvTnQyUj1vbxiJC6Ict79+SwOVnGTw3i0neDBtbL9LigQdP53h9S4gH1DuHHI4MfTWfPPrBI87Y0AiZNq2kJpTTu1TDIicx4ITVxf+CmqX4Z0xSZBKfsJ1IU6+HQLfbYiI0iNorYKGKjiI12Dhvd0pojULofoHSWiMemjqmtJjLWijEbA8BUuFdaJElW0vOUPHVYT+qMebpOJX9kIER1CatiBMyRTy+SIc63a7IgIdUaMrFvoMkXpYGDZdcFXzLzvKln7nnW6QPVidPM/bbAwFLPNCSlEqI19VOp7GdWtHp0QovOYOt+SdUpKZA5+yvfo8NovZKzSgGvSRNAF8LAs7wgWI6pjOmAubMnCyQPAl5D5Vl15WYUK4dtIrNyFeQgSUM21e0zxQ5z8kioLTop2fNcIjO1+S5uVWYGuEKSUt1sd6tNFTUpDUGu1RM+3DYM8vlIWQozt2lRmSgVW1quJaDgU7ZTk/hixgNCPyYhnRKTD74bu47n/psYDQlrbWonY299LmnXieRF3Xw5l6Z1ndjOcum5Mza8kHBKfMoWkbGV1neisKIzj25trGRGFtNJEFj4XNp125ZXXrXPxcZsvCm9zF7/MP9aLZ71qlzqW2oOnAePfPmyEVSmB31LU0D6cKoeV+KPBIRLARTm493Eq4evRuDpHsyyZE1vZ1evODqSmySZ5tIyih8o3mI6QB9mvxXPwEDSR4gfregi++REbEj+Tduiswz83XwKxWl+nMpbDyFjthyB/gntbHDkxUrcybFWA23e/BST/T7MSWWhCTD7Wj+W7LmMdn8C5DvPpGEa69oc7HN3FkNZdLWjBZocKW2jGGWh7+1s8pCaIJvE/Tl+7K3ytXuCWFSg8SZ7l9HxnB/mVXwfZ4TF+podBObLaumwr9C8YRzogTkwyoNdTWCOh3+7PvzL65vxAR9IdAo/xk0TZI/wkAkPmfCQCQ+Zhn3IZNviUJ31qbWzJoUb3PPzJAkUm+7Za0dJ3iAx+tOcHIZ1rMUySyarepNEtCS+nP+L0E6+kP5jYPneHBYKy7dkJ4jYMAS3e2zCSQapIUDhhA9uHDrh2t46A6xEOye/0B9kbpYSltvJF9itOAso9C92RKjA1Cc+tAneJlDJFlqr0MijQu0kgu0PeIcTpNUJgpDiAfIfV/VmL2mPZdU2THdcLbKtLMeSxg4DbkwNmBHmWDFThtcLSqwKwpZ7TKdcVV9j9DJVkGn6lxrHrOjHtPKJ7p48iZpMpZ8iPIrwKMKjCI8iPNpi5mAtJjI8lLTsjSBYqkhfTOicSHeJ0wJS0QCCy7FbhwWjKjp2WERV0aidgKuDkyzCSJ2CkZrpcr2eHhX6qrdWCMTiDEJMdv+YrH5W7gOerWtBM6RWX3pLoG1NFxC/Rfy2J/itXpMRykUoF6FchHIRykUol0O5xgjM8FBdjWuDAK8c4M2lG7XLYK9iOBuhg+vbIM0XI3y7IaC+km4dGvOVNGlHiO+gZNpFgdQN9pGBlurJ1tX76bZQAkTeDoG8qVVrP7ibrv6mqJu67NYwN03z8ZI4xLRymJZaUwxviUOICCEihIgQIkKIaBuIyMhlGyJApNh/IzykgofWdLztLBVwlgNWOpat4QglL2RoGFGpuC5hRaWm7QEzGoysuywg08E/YixJPin7hSkZKQdiS4fGluSqtn+MSdWONrEmeR07wZwU3UHsCbEnBfYk1xjEoBCDQgwKMSjEoPaEQdW6gEPHoiT7dsSkDDGpxL1QglOlwW0CXFDt+ynwH69Xvk8ff0/i2dMAsClJrw4MSUlatBskalAC3X2oXeRRQ8F3opzCHzW9PL0FkdeI87ggLfVc7k9AZxe0DEGyA4BkauXdCzamq74hJKYuui0kTNP4YYQ7Vq0CxiHuETdT65dxEGJVgtPqRxgUiGgbom2ItiHa1iLaZuTmDhBkU2z3EVtTYGsgeI8OmB3yEbMXMGSAqElGsj3c5S6EO7cHh6TxbnUKSuNN2geW1neZdlEgdYN9zFBXYbJ1nrVlrgQIRB0ciCqo1gGQqFL9rUJRhbJ3g0UVm49sLESVVKhSQVOQhYW4EOJCiAshLrQvXEjlsg0eGMr234gMmSJDr2zMqtAQH8sGOMIPJL57CjxyE9Plr/+YUKE7h8WCCk3ZCQY0ENl1SQCqwT0qrEc2ibqO8RgIG7Gd/WM7MlXaB6Yjr7cZliMrsyUMR9pcxG4Qu0mxG5mGIGaDmA1iNojZIGazM8ymxsUaHlZT2UcjRiPHaB5JTJcSOlJ2BEMFK3V+6Bq49e8d14N18+rXGWEGof+wTKVLh4VmKs3ZCTwzIDl2TRC6QT4qqEY1sboO1xgKHiGb/UM2KpXaB2yjrrsZdKMqtyX4RtlshHAQwkkhHJWWIIyDMA7COAjjIIyzMxjHwBUbHpQj3WMjnCOHcxZ0sOxXOlrUBxDDRRWwMoQtwAGXD0EYk/lwQB3RoW5AOqIxOwV0ei/BbglBPcBHCeUUp1NfgBytyBHGORyMU1SnfYI45ZrbgXCKpbYM4JSajPANwjcV+KaoIwjeIHiD4A2CNwje7By8Ubpdw4VucrtqBG7qgBuHD1YOthHD18DlT5yN/qM1SW2HhWmSVuwEn+m/sDoy7JIhPSoopjRXuo7B6KWL4Mv+wZeSAu0DdalU2QxuKRXXEs5SbiQCLAiwpABLSTkQWUFkBZEVRFYQWdkZsqJ2mIYHqeQ3yYilyLGUVzFGVMeS4Wrgjr9z/EcSBqtItYD3DUIpdeiwSEqpMTsBVAYjwd3fopTYswZ3J3GjxZrfuJRoSTtAGhYTEW/RsAgh54al5K1/46EBWTcsZLVy503HNl49NCwit+Dqt7wGjaGehq3pU30xLdgmtd05KvBRvsr05z45tIRoCdESbmIJEaHfP0Ivt7L7AOpVNTfD6+WltgTbK5o8jJsO85Aav99Q83CipmbP8rXH6GFYYYweTO7dNnm2DNwZNBkG0OhRsPxmPaP23ejBnBU3LJjbaryYcn9nNHJLYHwnZQoAJn+MlY+KyqehCmUpb/GmyR/qR2GSTeGH+hExvaYz1a5eClDm/6FrKQhuyn+pH4OZNYUfmo7QOTWFH+pH8uBs7m9dmXw6TZM/8G5QPHHDEzc8ccMTt/ZO3GoR9eEdvElcYDx/k5+/zZOhshdsrKjmlUavwWHOTRyE5JrMVmFEHe+fSRQ5jwO48UHarcMezUmbtJMDuoHJdB/gNBsiZVVw80o04TVNHrk87eXDXyflQd4EBGyiD3WyPqqjEd1c79MBSbd1EOHo/cPROs3eByitr78ZNK0ruyWAWtv8ocDUrFMIdu4P7NRp1QaQJ3ttKn4jqIagGoJqCKohqNYeqGboBQ8PWlNu6hFgkwNsEQwYVQExYnayqZrKvesGyMw1nYfDA9tkvTos1iZr0U6gtmEJtIPiqBnqowK6NPOs68kIzDUAcab940waxdoHzKStvhnKpCm6JZBJ13hMZIC4UYobaRQFkxogGoRoEKJBiAbtDA0yc9SGBwapNt6IBcmxoJCOlxQKkg1kA+CAehnURq9m8aU/HygHq7aLh8WIapu3E8BowHLfPUdmTpbxU4Oo0J3IfxPZHhVcZTr/+8PR6oL+IT62f3zMVJP3AZaZt6UZcmZaT0swmnG3hsHbYpYEWVv7Q99M9cuYwcUkOGU/kb2FeB3idYjXIV7XHl63hZ88PPDOyEVAJE+O5M2SwbMdf26rOV61g5yNQebqA0xYHPhqAolybi8TB+xEEaZDl9uLE4mm8Pl2Lk1NNnG8V2cd8ckvapzAnTiub6/o4HvnI+n2UWGYWJFLqtAubRKzeNKSvSBYnssXDFZ4WkySVlbycPGT0YSNtqhnJBPHa0gbtVN5wH+sljAFOL+ninlDwhd3RkX0wafrAbljT7yla6fz4JEvpg9ek2jlxV+LtZXwB44bVZueDCNdHugTUiwle8ROwAn9Q0XkIq+Khl0p6urp6eknEsJSZDm+deqy1/honlpcbahnnzSgBK/dM+/3Hhb3QOyWLizYSlrBsxvHZD627rlg7s8iMS2K+JxPNwV8haZlUAMzn5RbV7Ipd8SijX11wnlau+MFdLUXK7zr+yQUtd5b569P7uypVITjUfNHNwd02YY5AtuSJWy/5qOJ9Yn+QcsJg9Xjk8VeJi8kLBXARgsqow0OrWi1XFKzOre++84iv9I/Z3TWzzwoCBbnJ1J6+57L8J7OArCyxGNNpyb7kRbGmkWXPGLNg1ewfcR5nhyvcZHYjpy1GItZP2YTcAo/ThQr5JtkkljRkszchTsTq1aUTYe6w4LMpLGyis2S48KmmPA120XqEOHMCvIpbfLobej4kcN2AGZFt4ZM1x0/sd//p71va24cR9J9169guB4kzarZZ3rPOQ/eUMx66tLjnbp02K6oM8fjoGmJttkliwqSslvT2/99MwGQAkmABC+SdcmOaJcskyCQSCTy+zKZUIaYNsUa/yn/mA3gzuxTM16CGLAobdrTBi1IBzeug3utVPjf3H3yWlQ7raz2O/UnMbYDMAEaK2mtkYbnNbg67EZq3UHAT7a4DYN6Dq2i11xFm4ngGUfvuo/cySo5bPmsqshc9lm9poE3uRk1J1wvspbpVpEXbR4521LUTDwG15K+AKy2am+vdVRNHVGrEU17zUhasyiaMoIm65FRlAxnbIw/KohVfdXXAv34LSELbhOAdzsCrD2zTu7c0DuxUBhgiMICHs5iwlt+4chazmceYOgXrx96ayYCjUoY5AlLxJ4jAM8csltISyLyXuHjLHA4YtyqJwDVH9wQ4buqCxK6vc2avjd5O5z0jDV/IvrGkPVJrhPr8ecp1kQa1m0K1+1eIZqS2QoTfTytjOdLptfcKdGE7ysIh0IwUiYfpJ5UERAGREThUQpSQvHEEmIi89BMsyUkhT6IzEkLBTKrxf4bxUryBgRMVLn9GQxNQ+HerJY6pW7r+RxcD3fm/8uroVCp0FNNj2erwf4Jsbe9uHmjwHXTmPUW4tWNY9VN4tStYtR14tP60GHGx8fd+pcwiIOirufjtSFDsvJyLF0mldq/uehp7WBujvftdRvU7CCgqQtmsmJ/iR/WgMW79OKz6a8eDOjZ65LM213qVx7xMTHA2XF3SAQfjwrtPefkJvPUgnhywzs/Dt1w5TSuSqpYgvZn+OFNzcqUhhgTheHfY4N/diIPdEB//hY8fmZKf9VcJJpFsGlKee/IX8WEEwdM67GL9XhwrLRiMjZNTisf2ZijVrSmQ4F16vUq+ri/hHW68CtZ68LyrrxDuRqJ9O6e9FaopBH3nU7+OP2khrCFuR8XvhlpGC6FCoyV3x41sb6vFHcnvHNtznlo66EeEcx1CeY9lSXxzMQz69+DyhLNKu+9Bt/Mk2uzfHP1qtmvt3y06cI7zjsDdHPWTuw4w3804BAlRuP4GGnN4I+JnNaKoEOe+ih1jCiyQ6fImi+d6qVBRHaO2yo31cRp04LteMEeHL1dvoI2zXRXPb0x6V3ecAf8d0XPiQonKvwVqfBy7SRWnFjxA2bFjYAlEeR1CfL9Fytx5cSVm3LlFaigDm2e2KsMcV5rNRGHvg0OPV5PiZPn0zXT1Yj2XF0FaR0rYZepbkMbul4h0OMi65UC6JSqJ50l+r8TpatSKir/sSXiXG80j542b6roB0gO67Vk89Rw2bNbEMP6Zruo4FHa7T1ghYmD7Y6D1WtCJQNL1TSomgZV01Czu5VYhLjd+tzufguVmF1idg2rbZT68y2rb9RYRlSNYyuM7grE4KxPFxBzxQhdxVS1psZyUJ0osq5o3VxTx0vvFgSxMZqXdJno3s6U0FTJiP59BfpXbVyJBm65AA6cDlZrzXZpYV0fOqKH1c13TxNrhkF08dHSxWqNINqYaGOijTugjUuxDdHH7ejj/RUu0chEIzeikTV4oFM62WhZEa38GrRyYlW1/HJu7ppwczCnH4P5w8VyPodLP3jx5JEouRb0skKeR8UqK8ffJZlMCkscMitNNANr7sT+kyde5oy0T/LnsfFb+830t0I/iX7eDv2sN75Us2MHlszhMdd6hds4YV326OY8tb7VTujpkk7vb2mL4rKi2hMbILL1umNUeKI4S+PiV3T+IFHfRH0bUt+VSIwY79qM937LlIhuIrpNie4S1NCW3zZeRERrb4PWRvnOYD6ckE+Ic48zgmS2YqLaU4Kc4TiSmtKqoR8x35wIYHOE8zFoF6lH1fRTxeRy4ihjiCjjt6FKHjpfmtGSLROmuWd3xZhmmu2iHnBZrymR93j5z4wmUALv/vOJr1bWttq/JR6vJY+3d0IlIo+IPOOStmUObctz4GqsIypm+zpkHp+2IpvH56oB4fKzF397DGbeZezGHqX2NScHM4I8JlIwN/AOyUDSTaIWGyqZTokoN3QrBKXKGBIxWVOhD46QVGnFpolI9TMbE5Cq5rrI1VR2kxjHI2IcVRpATCPlS1K+ZKN8yRLsQARrXYJ1X4VJxCoRq4YZkkp/vGVqpMGyoZzILdCoD17svOBEOBHOBPpc8sw0YKY+uP4MXa33v008pmnETjVnTgvCPCb2VDH4DhlU0lNiUVsqW5kyEZu6FTZVZyCJUW2g3AfHquq0Y9PMqv65jdlVXZNdMKza7hLLekQsq04LiGklppWY1kZMawXGILa1Ltu6zwIlxpUYV0PGVeuvt2RdDZcPMa9bYF7vYS4c3JfAVIrZAGUpzFALZuvsLghjb0q8Vnv+VYjyGNnXdOgb4F5JQ4l5baBoekUi1nWrrGvWLBLnWlutD5ZxzWrGtvjW/FNbs63ZBrvkWnNdJab1CJnWrA4Qz0o8K/GsrXhWJZ4glrUpy7p/4iSOlTjWmhxrzj/viGEtXTrEr26VX3X5XEjsqpidBsxVsoF3QFnpEHot7F+Pzkxu3hqPmUHE66d3SCXu54S8sngV4qtmzt5Y53Ox/iLhcKMzPfXA7Zg/MLyA6xbAF4KYkTXwbc8e5ZpYoGmFVqLIffCse0Q61tyF34cj9O6jx2AJ3+Dy7zvONFjezTzwX8HMRhPo1dRx+rkGn93Qd+GqCA2I+xz4U8udryzuzYBHxFpHK3M/8ydxxLuJFoOPpB/lO+iGcAPIM8ohEuvqkXUq8mb30I31hbhhMZT0jE8Eywd45JcVNA42MMi14c+n/gTz7BnBgzqaWjRs5C6AsYpvmNUEkYAsco30E+3uW+gnwi5kH4Lya4zUDrGKNZYbri0vDGHgQtedaLlYzBjJNxgq4SSo7eBa5/rHQwTRVozKdW3KOo/qkc43N+Wg4f6knwy6z/U1gWzQd1DbJUzWHazhyaM3Xc5gw70HXwqu6v+eJw+HtuPgunScP/rWs+9at9y3ugYrdWMnDQzYr8NU0oNJMiz+h9uTngpVthnDxJ0z5xOGgapgOoaTXq+ut96rhaWuaxD8NdbrTfFJOqUd67V51CtlqQ6M4c6Zp01T24XHteCe823tPulcRcLWIg0UFLYB05ZDfdHCfZkPJKPUFTmSmTITnsSUUhoeFwdvpgk7pwhijeaWqNGBYmySO1aZ/cH56f49TsFMAxj5zp0/eGGwjFSCPtRDO3KDPqbspsLQO6QkjkqX9v4s2oRgbXgCLd88mGRatSD0r3kTyEu0uF2oTIsWZOq5lShwHls0sFz60zZyjJd3LW6XdK88IlTRCTf2nJJxlDfR0tTpTRkdN5Mjq9RbKB3yTYaVDCsZ1kPkv9QWb9M0mO6pjTM81Q12cFCSpqf7e6q8nAnCz5LXXJhoYfV1fKFUXoiWt/Iioa+V1+VzTCq6iEKqvAwtYvUowO5VXiRZN4MGuQ1bX0ipuV2l5qpXrxENlybtJB9GmkAUa3IcqtiWvNsyTj6oL8MFMsYf6j+LpTGeqBxeZQKR/IuuZzgpY/6P+hJcFWP8oek0rIcx/qjOTpI+69riS2GcfBjRiWN04pjpiWOlRB2lDddNG95fcVLaMKUNm54ypkF9Lc8XM1o7dLLYNgKK02QqHJaeGIGe5GanQUzoMg5C78KbLMMIgPsnnkVzHFFG5dCPKdaoEUCHEccj1K4DoMfZLGmbxwMOI5u3bj9wVXIWdz/Z+Xk2pSubqmGVmlFMKEctlhk8igztuOofHF9fpo2bZu3Ln92Yuy9rtgMGv7TX+8zj85duiDXunDUu0xhD7pjdMhb/EotJLKYxi2ng/BOXWZfL3HehEqNJjKYpo1nqHbfkNWusI2I3t8FuRjghIGkxI8kLfaA6yqlqQEZhjcRNclHHVoNWJc9jok/V4++QPSWFJUq2E5WrUCkqTrsV+rXEXlKF2mZafnCkaImObJoTLX10Y0q0pNUuqtaWdZpK1x4R01miCFS/VrqA6tdS/VoTspNTuNUIhBjcugzunsuUCFwicA0r2Zb58S3L2ZovIqppuwXyFqdIyd2q5qkBEwZmF9b4chKfzadHnLFaKYZjol8NhNEhF3vkGrj3qX1TbxE/NnzLv3O1q6NWlMWaY5RMjSBltO6A2h8cQWuqfZtma8370Zi6NX1EB5mtxqPZ3yxXthIpx7V75tdUd4zyXdksjdlPynWlXFfjXNea8IBY07qs6SEJmChUolBNc2CN/e46+bCJNctQqg1XGGXHboNgnSST47jzqaPPla2cRD7myQzWpOVcerP7b577/cK790IPbXvmN7DX6+ID3n16gMqgUIayFOq+PJaUhxRfwyR7sf/kpR/W6D39E/6YerO1pdMdgCOPwWaDvBQ9Py1ZaWX3DXCQtuMuFjM8Jgm6jiWdLP5t7EbfwXnDYY7xx9CcX0SpZjY6JkxwIX03MjHVI5C19Ri8qBgemSf4GytDX37NL+8vnG9fLv7+4eOXb1XyPJf63IJe1QwfxvTdWxfTxIpd9tev5+92eaiFoVSsEfMpLltaspg0KyuVnrpBWaL1uCcQdP2FqJdm9WI814qXWRm4Aboq7tAUn5P3ohJsIvxVW7pcc/QGzuKY/VRvUDBBY/hf/UeQ/Rj+N9ynhM3+EITgIkmWGSaloEjnCIHuZh5TpKySwhYMfrnjiLVWdXPOZ+cWz2fFZ+Bnk0gKm2FKY28eBWT/bvekzJkfxde553O386aT6BrpxM7F5fAIuRb1rCuLrE/9SYztgBcFjVWFIZopYF7B6CxR0cEjPUuUzEM2wiPvJLsdLt1Ta1QvCiZPx/GdgajpNDNtVZXHi6Xgyw/SE71h+4Mf2A8uxqHVLv6frquOxrMBdZRneftTfea1rfB9GjHYejtQdY/BhfyUXyztPpeIRH8aKe+4obMeW5/1eKgqKnok2zrjwyTl3WCMP0aVlxoWv0/HuhNrZX94aVYEL4nFNykQ6sVn0189GNDzsVSdlUb8iiA+240usfzxTOnm3F03EWALn9cN7/w4dMOV07ispUJX7c/ww5tW17nkG9ozBn7de2zwz4AqYXL0J1zB42e1PO+6OqzRUWIFiBXY04K+xfW52zCe7FpHdq1m4djieIlfEJ1OVbKSZCgonsFpbQo92UeOQu/TEVVBVMWBa2pSjbJoRGsTF6mxGaefqimMgt0ZF76pbkRpisbKb4kh6bSupQfyTfeYcQZ6NEDXko96fNyJZvCvSKNoe9Qlo3KUc04g5HVBSAvNrtZcolyIctlPyqV8CyL25dgMXz0iplx7iJMhTsYc6Rp5hUTPED1zPEor+lhuZYm0IdKmirSJ1xrk5AkcjXY1wvWrqyB9Y1N4qfQWRBt+SCHQV2WHlP3plhsiHdolvqlDJaiaZCJRiEShJTq7NrH+O0TMtLMQdfkGvUiOj23YJ5hUuasTsidkfywqm+J6vTWrheoJDteFwysnZlu9KEIk5o2hYcWctMYxOfeA8ExXmDjX1M5g40K/NoeRSbf2BSs3UArTSSfsTNiZluzsus4usUcY2sxytMHSahERpt4XgFLqBRC2Jmx9bKqrxNhqK0dYe5tYO9n3taA7N0lNABJM6sdg/nCxnM/h0g9ePHkkXNQCcyvk+ZpQW9mdThE2KdCOv/QQzcDssRLaImEoanMqVCfqVaE+BNEJotPin10bbCq7/drBbpiemmBfL2zK0hedLs7rXqbRV7ouxAYQG3AkGpuQAHrrVzt7vmglxsWvKHu9UwoBF8AM5s8J+QQ69ziDSBwoJrY93ONe15GUIFANfXewfdKfDYL7Y5jt3ZuuqukgtExo+SBwbcai7nbIucZaboU+MyKhEPPeeOaqnZLAJIHJY1FZNZrMWDMKJW8VB74w2ReBIJ+TJge3efG3x2DmXcbgFVHEr8WhfrIgX/Nwv2w/Oj3kj3RlR1Fp7UnXTSqhUEKhtCRn12VWfacxrYklqHmonUIEhGF3+Kwv/S5N2JWw66GranI8ncJqEVbd5EFyXuy8oMSdCEWOR8rJU9AAbnxw/dk38NPe/zbxmKwJcjSHpwVhviJEVfSlS5hKerPLULXR5JdNLkFWgqy0NGfXVZZ+p2GrqVWoB111oiD4uruYoGL3JghLEPYY1FX0TmfBCMpuEMreg9AddLdgoxZiB3UuTEULaHJ2F4SxNyVg0h7QClHuAJxNe7IJMEsas7tQtsbE6yeWYCzBWFqWs+ty+74XILbcHjSDsFkxEIDdfUSg3LEJvhJ8PXxlzYHXrO0i6LoV6OpyoUvAVUxDAxDyzp0/eGGwjFRTdqgviuYG/YoAs9CTLgHmUc3t5mqkwBJ1p27sNqyMwjcJ1uVWLXDNaNEEoqsWt4u5bNHCnQegNnTi4Ls3byUKnMsWDSyX/rSNHOPlXYvb/an3xCD0ZNXirF+WieOUjKO8iU4skd7SEONBjMd+chNq12C3i3jRBkUbFG1QTSg49WqnKnKi04lhMTi4nZvJ6uv4pFVeiKag8qKk6HLVdfKyNugiSqnyMlyi1aOAhVh5kbTcDBrki2ofi/mVolEiT4k8PXxlFX1T7zq1q/cl1nmcfDA5tJ49ahyqGC/1Ddxgj5MP1beg6R7jj+pLhdjGE5UDr/pPtuRj+ReTkaBWjvk/1ZejfR/jD4MBg5Uf44/qSyVbP5Y+mzyDG/5x8oGqMnbJrU+TFekwEiECM5dbpA3o18s4CL0Lb7IMI//Z+8RZiuMg2JVDf0WaXdOfLsn2I5ztTTIaTHzaR2D1nMjmT7Af+CQ7i7uf7PwE1EKYjbWkSguIDiU6dD/p0DJDvuuk6K6bkHpUVdlMEGGVElbc9u0hPWLgPxBJQiTJsais6GGZ1WtAmLDbx+JfgtBdQugIZwrUWkyVk5jisdonboCwMHt+kwDr2F6zUsnzFTG6ujtdQnRSoB1/66qpClRMMcFvgt+0QGfXBoZ/p1/CqmEe6mHrEoHQ61i7iz+q93NCzISYj0RjRQdLTBm9nbVB+BuC3JXoVzUhDbAL7P9RHC4n8dl8esSB5UoxvCKANehbl2j2yDVic5GjqbeIHzs7BrsTragz64R2Ce3uJy41Ne67HXjeDfNRDwCbSp4CzaLTbJL3Mcxc02sgAE0A+hjVV/TW1C7WDkUz+zFmPykM3SUOnyQz5rjzqaMPSlfOLB/zf05msML543t84u5RmrB+BpNZNAKpRvm9/hwUBx1Z9oYj29ET3Xc+sDtPe7l1lvv7ABodljw/s4SwFz3jly6LpgCxQmSzgzzOp0UHR3JujN6OZW91yo1kBPDNc79fePde6IEdPJUm8xsghuViEeBbfSABhCG3ssUY3jJ/X7pjHli3yXBvcR3MZyu0uPPIB3VzmVahN4sadgdfwITgR2wdcEVP9uThcaCgLOAzSn4NWagIrWeA5i7RQLwdFNuH7ktNpM9ivv+tNGe38KwpqioMAtoCFDBx5/0Yj1SxXKmFMBEK9jFYxoBNngEJuREMEmCKkMFazcG9k98FRHGfql6Ghqko8fiF825Db/K7ADxAer2y2D7TXteHBXuxhKX85L0Pw0CzK/Q/+VGEUyq2kLTlBPKByPg3t/9h9dVNIEBdBUswEdgQw1tMzEwtQGDWBRvfX/pl1ksMbM7e70y34+TtoxrYaNhCGLdCn1GVvGnaf1dWZ1ASCxUaNReMIr8KrLdrJR2xKwcKfsmzP2EnyoqV9FewpZfiWxvxL/8Im4FaAdIWtqEBycO2oAJ5q3sJKyxjmYqDeGNdfXn3ZfAYx4vo9McfH+CJyzt7Ejz9yLXlh6n3/ONTMA9+hIGCR/Djv//00/8dnlrudJoaNjQAiXHjRsVdLGbIIuDmaSueCdsBKOsLH6s7e3FXES77VZToA+6BUiOcjJiA7YqRRnn0EjkXG5fuwtfKiqg289ZZ0gw/AApWyL2tegXtjXV+zx7L2KOpP0VTFy28iX+/QlKEbSAWfw8bTOGTu4JHgGNgeWAkl4t0ZtmgfgCozCiGzH2qh6LrgCPvR7A9TsD8Ty3GyYAxBbW0At4n5vP2WrxRmGjoOPmQvURSspyClejWtvVqYzpVqU8VbzAazEPiEpUw5AV3SSJO2QjW0gcoMMt4zbtNqzlOIjeEdy0p8YzPBx1KaSAmI4Fpir6gEmHCR+lNVhOWT35IAyrPqf/o8kco+yA1bJ+vP6u607QPRo9g7nO8XACcUJqTUWHyCnRgGkmgldP5yqmvvG2W0Gb1uIPuGD9NgpWxH8+8hlWCMCTU8FZ3+qsHqvjc5P5OF2XlwisP6NFqrNjHtr5Km/ViB1bv3myKZEE4aZaQArcJAXU7spDfOrkD//mEgYIIQ/vSPbcLcKyTyxMaIhpZy/nMQyjt9UNvzTbg4g8DmbidBcECSTKRN4D0LIKCFcsgAMsVo0WZADZ5cENEJvlHI8nGUEKGznojXfY16Qlr8kT0BSmG2UnuweuxytRyMmrr1ub4hj1KsbhrLuFEB1W2zGnLuPa6j1L3erpgcJUJVlFhmV7n+C9ZECwSVfWAuqHqvFEbqU29gpaTZlsXI8s3Xh0OzN9RGbcu9r+rMLZ55816XNlNjYHWh8qZda6sbMeSe6ouSi2u+sqKYK7B1NcJ2HY/p7urm9pJLw4p+/BSVa1YrEkMVl7hRoFWpnFj9lMdFEVlG+MP9Z9TNRunn0YleQTerL59NTFfedNVy6jupta31fgd0vZamq63UGJEA8VaqJpvbU5KfuxNtnv9HA5H1sn5/NmdYYJm+LB88uYxA6i29Q6+wgjNAkZ1+s/5ifXPzJ0nlvWDdWb1k/70ObcscsSQpodWrL6oyQK9sDNOR/8vmib7YiSiPXT9dA3Kw+r/5aRUOfdmvTXWV5Pl1+vYQJca5xLDXGmUhxl/V+Pv5C0sKDBztDkUy7rbZ/PVCHka9KdV61OTSjTMO7cZ71hKiDxVhLLeBRgy8+eT2XLqyRFh3GLYUrnFW29Zcg1qu6INQE4vrJk7mJjvLGSzCCKfY4f1kp160yVjf2zF2LhcrH+DkcvdHw172uvKdvNRzzhxaViKDdYybxmtlxPc1F6EINZSDMmnMu2AzYGpw4DpYKhsAs29pU8GS56Qw8WaByHy1jwnfZbc4hrkK+8pfju080x/JrUvmezKjMpac5YyhudzH7P8/X95hrOWjDVd5/FsNWg+BgmAJ/V0G6D6n8PF5JO4XQHt5cBmSetSElXOqCkzq7OC0nWN71Dsl2xGdRWdoDBo6d22XCJeb9hkmWazsNMGyh6SL+Be9qCsiHMPk/+Yk2zWRhdbN91TFHwITOdAyBgrCtv4438PhiaZyAVmZW0WHrw5mgxv3ak4vVit/vyvqAAO22iTFZQ8JP2LLplUJD7wu7UUEb/oM1wz6Geq7Al/4RN/86ivSW3loZBxny/kvvoiuZBynrQoX9xppp3swhSzkjO7XjY7Ia9jvaIhxLuXd6mXlT7RdniaoWwVh/m0kUHB5Urvz44t539xhhgdsF/w3ayiDiR2k/et1FKW7t21J0BMK69WLtsC9aWl0h5V7D/DQsJI+5zllvnKqlxlnlCDicjsQ4MAPUYIM3sfy0eGHdSNjLJzrT+NrMfg5bQCUPwteFEmkcrX/PL+wvn25eLvHz5++ZZNeE7TrM+lnrZNTVCPHIbz3VufWMMs7dev5+92aZSVI1GndZtPqio8JktF48ekwio2JAuvXvgOZFqSCl4ltHySpvLynKmUjZJB2rN0ucJYoszH7GfR5IBIx/B/8Q8grTH8P6owSUpFyDjtnSjCsCBOaC3rMLMWq3q1Bifb6lavMBVZkaKcq1fr+dX7i7Or8y+fzSZAID3oTN0eVnfn7OO3s39capMZcTtkXQIHKv08uA+Df8EWeBUuPb7J8Xxn3dLpqRbCqTlh1KgKgcKJ2N/Xll8/x7LN69Mts142WimjXa5DmzIZpKCbSWV8neIcbXJ9Wub7tM352dRaqJkwSAtgw9mDB2jCaSFqFuIb6+v/s/ynRQg7EEZVTq3Jozf5zgORc89nr+Oooi8vbmS5E3xZaR6D6Fe5Vh9gZJiA93Dxy9v0dE0WZK3D9c7hy0QPBe8rkfHyX8bqhISWD5NIZpOHaQm4zpLrusn/K41QdZ1b1z6/rkE5mIqkOsPEOkfNHGrjGOxd6dzLuXVqv5xqg2P8PdUrEDN/SfX+5P1vC7Qf8wfrPliG8aNykfJXxyvzCEbWA3S6/7vQepUkhrYjmPU/+ieKXDnzfDnjnDnzvDl9+CGdr6riPuqpa5Rs0mwWwZ8JpzswiSY1WXoGC6px8ptRApxBEpxxIpxJCLibhLjWSXG7o867rspGalxtP7KR1ZI8tnLBt05gqz8JkQeeknYWhGMnTwa4m31M6DKdlaox1Z2hyoVwINm2NfK2es0zsdLMprE+O6i8klQmgNwsxlpZ3Eku5lRymLBZokH7AW9tOD1tUlB2GymOJM0A0uYO7n6Fq3zkuPem5D8rKfgCio51kabuAkuiWmX39ADVYtGZuxW7yf41kkrBPMGCQzPIq0uwWq2TCb6wJSqlMlmgFcfrf3iGZ7k2NHjhzbxnl1vPpDEsnxWG0h+4WCO71+OBjuQQMHE9duYMBwC2OplorBgy8+JgnuSdhMPTyhdrHdQV5x7M4wR3GKzDo4ls3S9BudYcQ1ID7wP7en0Zf8opZvoUQlwvjz748xjDya66KQvCL7z5FPebsbrYHn5X1OJr3q2bkSK79skLlvH4/4xQgfgmFpXkV76x3jK+Aozji9d/5hVTphYrSARzOAsesJSWG865Y8LLqvhhrg1WVOvRjWBD9OZWKlOm8TxrlZd5CZdzbMjO2+WZNx+gOIbWeGz9r6Jxgm48wFyLfqjt0/3JW+wFq0nMllL/d/7hj76ya6u0KAxW/TpRtnny169X1rf31tnFe+vy6vzjR+vb2fnV+eefeUG9GJQdl0Ps2dY/giWr2pQs8AVsnehdaBpOCl7ZaY9u2QJIJmPdN9b5db/B4mCGvabZKcv7nQYWCNrDVemGK2Z90DNh+oUdjwKUTDqjWIZn7j1jtbPJZBnaJ73qXNHEumVruGC+sWxJPwcv0DL0mlmJeIlEl3XLFP2WDZHrcZLLjJnLbARSE4/uM5oTGBDY+dCHbk4t77eJt1jXpnnw4oiryFT9RunnL1fvT3nBmxemhszvg0bXDQmRC9VhF8Bznr2sOQ6WD4/p1LCJcWdYKG6lUfwnsO8RfJAaeQpC3D48N0yXU+6piTCwt48r8UYueCqZV1zjCZs/XKPRC3QmeOG/rtZjWsuCWxYu614a7XYcfw5W0BlggTnJXrF6c86v0bo+2Lo43Vj8dV1lUbpuMLTykQc3jsMf4GH+3JverB/tLmHAof8vuIc9HLlYY4YPb3bWLUT2Wfr5phC2z3c392TNOI0GIm0nqAODjABHvVwhvtMaAZL1zb9GwTzxmuTdBQUGv62HK65Z5zDhnTaGRKOB3Ijk6LCsCrhB/IXVgOuzL/vyVZxB6j8GL1ikPLlaTg9at3HNLruRE2vZ31WZVUmmSyRSI5SvRfE+qt5zEvMr2n0IAvACHFaT/m55z0aP+/uTG9uinudV8F+RnMCSXRzRcoEKbDOfPU35t9nEimka6jxG0VccKQjouoIzX49bzicb1bpLkddyU6g+1k40ujcjsoLKpCyJVCIFB2CgBLIwlOSk4snrtCTFo3WTNyysXpaSu5Hly5N981EG9FNYfVgWohrl/nqGgk/Lx97UsAWKgHCSbsxkdqpTCVEVN1GHHFvCzllQxCxCd4L9jRauYlVx7MuQ//3J74mzk0sz/2PQz/3JB29teKIovQcP4a2diCEhEpPwwImqLiCe8wA3sZ3xLnjGgoOwb3oJVOGIDDkApIAuJ6G/UBRKXLBrHV7F0J+wZKziwwDDeLOxXkpX8K/3ES+y3369vPry6f1FDoEWvV424aEXLWcisT8FCWJWlT5g7WXPmh5WoezGmrABbVBqhPWDxQJo1ttgsarWjg41xFxLOtEUjbZwy59RFo0rIF+liWJwG4uSRApQH2gwULZf3DDy3vmTuLwoutypa/6GcP+mvPY5d+Dkd1ecQUm5dN1rcGWBsz7vFvN85B6WSB/knh2LaOKmNOaHnDC/kGFgsOeaR7CtnV/Z21Hvb4vuX6nzltvXczu64pVUUQJ8z/w8ladWz0tr6aHV9c6SmUnrbieCZ8tgDLqfvrgjWD4rsavJqVWnFSUqG/hw8nm/uYL6p1bmNbYH3ilncfdT8krbSJoUxoGX3JKJsMjVwKpu4AlIErG4W46ZtN+K+dhrp2y3vWAuYM7/eCF/b9q6hQE9LQI8vwAxxu0hOsV3K1gnLLgrva91FzvPf3Zni0f3z84c1PDXiC2crDjU/sd3fz4dV7Sj2hdytqWqCWFY9D6Q0Vuva52SarKr62mXvferUUR9A5yJzryIOV4T2IW/lTQUBN/9dQf4ryX5J4uFk1SBT2+Svyy5dRk/jstdTpZvsD7nwsZbtDV1ChuefJcdB9z5dZh6llRpKPFPk50W57Zex6U7zfuPL6UrGmjU9XidEO6EuMprD0HRQrOhKBqqPSTN12y58PL1GGzkRvcquIxDDEppbhL+wFj8a3bjUHVZFqiksQZNbPIaRXeztpHZv+Zb41ZV4JZczFPDyOcex8gqZYJsHK5O94VKiNMd41goA8XMp1GetTQGFQGRcoiujLGUbRIagFbQff0lazdhZFj9Rg4Vvnhp2PI20fPoEXOgbuVYJcZ7WWBb09gkCENvEs9W69ArC0IKMWO8V8SPWaiRB+E1bWFRs3TcdhmXoJrRsmM481qgS0XgAhgoms/lF7EAZP7ut0nfWapdURfXY4u8WDQ/wP4qCBppmj6Bvq+le6vo3K11501cHpb3I0Vb/Mwu7uPdYpz8VtpD+Pld8KC3Z5/xqTA6b7JUEEBvrCd4pg+zaUU+fnTnXrCMZitbFRCpmCP1UhVkB1tSZQksBktcv3D62Qyq/siUNWPRa4UiqKqcfXK/I2OAlaYTrWaB8FspG0JIRWRagsykQ9vWLUkRfDycJgxe5qyqHg/nC4WGP+GgluGchdcVzWSyD6zvmADmhuwIZ2giWIYTD5uYgUCYUfBjXe21J//hEY+wQ31bsuyocDln6TTBPfj4T0G4YqkYQRh5I/4gxM2Klu7D4AmG57Ns1ESFeTINTj5/cyEUu45dsp74J4VPqpgxZWqgoql92c+FAjAOGpls7ksdVzigDk6+YHfYa1GZWRVTG+Hfiz7Zf3MjllM8EFS/ZgSN1WpDqpVTLx5oMdOujjWsnpZ1pmkl2lYnbsRwQQWnaqSFWVW39cGZcsevpr4uIxZh6Ze+VzCoOgpZ+3ex957dBSFsOPrLcItweH/KJWQapqslZyGEUeU92aeHi4noM5vsS979imOOh+2jesI7LsxnKHj1/l7taqzLBpZHuzOw0JFhyEFeiUJ+SRek4nXFo0BPvs499kKNN032IubViOhAIROHrYs2QZwLdmjvNoI47JYaMRxxfT6E0xWbbcJi8xONR70u2euEtWbD6xscIKonqxuT1K3JaUNSugEZXUJC1yafG5DOCqNaTTI3JZfrkcqKrpmTyG3J42ak8VBb1K02OVyLFK4gg7sjgjdFAhcI4M1wjrW4Ri3HWMIt6jjF/Bs1HXCIXXCHpZxhA66wK46wPj9oyg0mol/OZ/53j8mshNkbofjffcF7cq04OHEOe3HPnFlkPGKuIb7lJhTihL1xwujDNVnIL4lyN+YoRICNoC13Hnsx2YXdE5vjr1S9iFfnsGBMvoZMEEytexjKnZtUpEFSDCvKFF+IGrFeIteWb4bpA9wRPqXEUzJuftq0GMJaleHvihfE8irYhAZtQoEa058p9anzZvIvnmb4MxXb2Q3T2QHL2QnD2Q272YrZrGA1czNSYDOrmMyNEGZaomxYeD+9LtlQRjSUkQxcw8v4BTNuoRteoS6n0JJPMD4Oo9drwx9UQewMIuwaYbPGiwD7EiY9qbGwH8mSco9rwO3sbXuUOCl3nNInKX2S0ifrpU/K64eSKCmJkpIoKYmSkigpiZKSKCmJkpIoKYlyy0mUBu4opVJSKiWlUlIqJaVSUiolpVJ2nkop78CUUEkJla+UUKkKSHQd9MnEDgqxH+nQpq7CQMVzoCgW1GEsSDNjFBaisNAhhIUkgmA7sSHNeqIwEYWJKExEYSIKE1GYiMJEFCaiMBGFibYcJqrnmVLEiCJGFDGiiBFFjChiRBGjziNGms2YgkcUPDrg4JEu2KCII62ugrfJgVoF8nUHinZw1baThWV7T4t4xe55j5+kmFHFlYdXp0M5eVS3owahTXU7mhPSVLeD6nZQ3Q6q20F1O6huxybqdph6N1THg+p4HEYdD6XGU12P0m+7qetRAR27h+eKia4C5+9/4wCHQPoeg/TcJBJYJ7BOYJ3AOoF1AusE1gmsHwhYr/ZyCLQTaD9E0J7TfALvhw7ecxOuAPHgrX4M5g/Q9hy68MGLJ4/7cSqGqufFNzWPD9ArxEI4nnA84XjC8YTjCccTjiccv7843sy5IfhO8P1A4LtC4Qm1HyBqV8xzJVjnJ2Ps1NkaG4i073LRJNV8UMkkKplEJ2nUrJakWkhUK6kpu2XAcjVmu1qwXiUUkzkL1pYNa8aKGXSdaiVRrSSqlUS1kqxW9GclDWpAh1bRouWIimolUa0kqpWk5BtL/VKqlESVkvZhe6dKSVQpiSoldahpJdqWipwqJbWulKTaiqlOktEkGk4t1UnatTiQiCgUAkE/e/G3x2DmoWp4+5GumelyjRM1xKMOL1EzIxDK0KQMTcrQpAxNytCkDE3K0KQMzb3N0Kzyaig1k1IzDyM1M6PplJO5hZzMOuxYF2A8M8NFEP7B9WffwOC8TywL1TzaD+RdmDhC34S+CX0T+ib0Teib0Deh771F3yaeDSFwQuCHgcAL2k4ofAsofMsR8cIk64G4mH6C4fsFw8W0EQgnEE4gnEA4gXAC4QTCCYTvPQjX+zUEwQmCHxYEF7pOAPxwAbiY2wR+/+dkBv3nWC6Hx78J1309R5NZVLMwkWiigMQbAGstak8ekhxz/DoQOwE6mwHZyRgJXRO6Plp0vZuA+Y310Z9/t5YLDgAUnhx7uQo9MyGLFPn5sdRK4uvg1f5cuDvWsw/gJZ1uuGQwvIVLwKKl2FBqA3R14T7gm5u3WSgFKIW7/+DjPTwyL8z+NbLzxtxeu9Ew9PTz5tmBBK3jU2eR7azhu2M/eLG08MRum94gA9X6ZANvpB3hkLRBpAORDq9FOuTFn25CpbRDctFeEw9cyFskHpiB2hzvUOLqEeFAhMNhEA6JkhPT0DHTUCffPg+cu6YckvaLof537vzBg9XPBxDtVO1j7S25Trc4pGiHayHnBklVkKkKMlVBrlcFObeEqP5xU2rPgOJrTPW1oPxK+DVzCrAtFdiMEjToOtU/pvrHVP+Y6h9brTKrKslOA9KzivwsB1NU/5jqH1P9Y04pmnmkVPmYKh/vw8ZOlY+p8jFVPu5Q00q0LRU5VT5uW/k4twlTzWOj6TOcVKp5/OoJpvnIQSHocxkD2LwAlzuM/GfvkxdF7oO3H6EfZddrVD/W3J/PV93huJByBBQdougQRYfqRYeUC4liRBQjohgRxYgoRkQxIooRUYyIYkQUI9pyjKiOX0qRIooUUaSIIkUUKaJIEUWKOo8UKbdiihdRvGiz8aJm0Yuuw0jqQEMhmIQVPruMJW3vBE1Vz2uEktS3v2blk00WF1WNlmqg1CC/qQZKc/KaKoxShVGqMErFPqjCKFUY3USlD0Pnhqp+UNWPw6j6oVJ4qgBS+u2Gj9wsQ5NdI3vVs4rAHiAhuHfLSXw2n3aeMXq13pe3AfUrx1ID9xu0tUfppJWjodRSSi09hNRSCQlsJ7+0cmVRrinlmlKuKeWaUq4p5ZpSrinlmlKuKeWabjnXtKmPSnmnlHdKeaeUd0p5p5R3SnmnneedVm7LlINKOaivlINqHP7oOmpVHamAaer13pT8Z10kwJR5XZaLQRDMZCi7qffG+hpBX+5WyWlN1jfP/b5uykd49+TNYZ7AEWVOnzsBjzEx6gAAp4zlh5YQH//wDI90begMmGSRzTGZ+dBAZPd67BjAxERkHiSFbQbpGSXyBTCjuRgeA8dFXA8bTxj6U+9GE8H7kxTMgwbcu1mBKXorvr++1liQJz4ptpicm1GugTP0YrGFm/XDXG7WHN5Z/HmdWWI2LDFbXGQLG3hTiAMqbq/sXNoGM3xpQBEUTgoJwm+n+YeBdyU/VvaNC5yYsa2VOzFK2s8fKSEWegLkk4kaFC7PYvXKp7NVCDpkLfA3xytC+WSa2J8k97I4R5erKPaexEwV7aHCL7VZo3wD+Dr/PgdAp9oBxASiCZW6+cd/WCe67eDkSuRsLaMliGrFQRpb1i6sFW8BX81BbvBVIpvkKSPr5dGfPCbgPVouFmxAeG9a1Omfc+2jrZNLz2OAdOY/+XFkYdLVqfUYx4vo9Mcf0yam3jP+8gDuOHqIPzwsYY1G/O8/8Ft/PKnMSuL2W4gWZ9eeLp8WCjfgd3VSFN+B+6cmCiPWz1Xwzp+UhMQyCoNxFOGZmOZe/KFJvxSa/VcXtDYlAkBzU1bgNJ9h40c+7CIIYwfpRaOM3VGl2RiLVC/WTYl2LQYYSaVo9W7RH73y66pSq1qrXepsdSmdpNGGepbfTSOAatPlzGu1o/L4sLS3mObMZKqsWf9dL72m/Prc8cDKi+F7Fo6134sPxcQdIZ78KNC3c96BF3sFH/DoY/z3/wdzCayC6J4WQQxezKoqJiV1SbrLPl9/3l2XoK0H0FObsiSYYqw9OSMXu9H31JF48GKM+xQXlfA5L0WU5wpu0pjAJJWiNMjDcU3o3adBfyf9amTy/ghfSLlkk0EqtEQbx8mHrjdKlNr5tFN7hU3a+ANUu43N4mTT2XSaSAEJJ3/OO4ObZBwwfwRECBgodm3ZOrFvVJYItTmyfwaY/klcBUqTHcygeNcjzxa3r84u/+5cvv3b+3dfP75fT4/tRwHv12AovwQj+dFcHgUFBT/MCwdD24mZJgotGo6EYgwHqldwsuoiGZCx9Dl7USKScfJB2UszdSqqUgs1EoLJ6sQfPf3+xRP36+9ejbeszMucFVvQru9uG9xK0j8FbK+LSncZcc0adzFdmwXuNBrIjci7Rae7ayEBBDajvnRxHyxN0stT3XLLw8bsjAnh29INRaPpznw3GosHXWd6cMPOqu6zK/qKreO7tyq9Ef6uuu0xeNGkPJVL7+zjt7N/XCpvBNmVj+DFXUX9kfXBnUXeUP92Y3kHfnl/4Zxfvb84uzr/8rlJP8DSnsO6YJtHv6QbyuSD/IuUvZxhcR7d+XTmrVXifjmfxEEwi2wA97Hv5tI+CxuAsGuFHSD73ExmoxgsG90J/8sV/uFkWHOHGOZ3ADmCPymkrCY0zTgz9JGSX0EbM65yx5LBWv9m9QXR0i97b1U2Y2P5l+xlsqUaZ7zRkv2F51dscX+hnYB2AtoJDmEnQM1JIIFebV4evflaX/KrDXkGgJBPC57VkPyW48KwDRab+i9YIiI+lQ447cLNdR8v7N8oT3KWbXxKCulqZ6hwqhFKThGsIZ3Co75FcQxwJAolNkI/NfYMw31jMz6A2HsqfACjIdd2FMgHWPsAUl4lOQLkCJAjQI4AOQLkCGzRERCmnVyBV6cDkpnYnh9ALDK5DOQyHJnLIPJ3lW7D+qq2LkNtd6FX21co8RNKfYRN+gdG22Snu0jvjbVyF/enljfHrbH3P9m9DGDMyRkA"); } importPys(); diff --git a/tests/reboot/greeter_rbt.golden.py b/tests/reboot/greeter_rbt.golden.py index 52eac3f55..90b924cca 100755 --- a/tests/reboot/greeter_rbt.golden.py +++ b/tests/reboot/greeter_rbt.golden.py @@ -21735,14 +21735,17 @@ async def Greet( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='Greet', request=GreeterGreetRequestToProto( __request__ ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -21758,13 +21761,38 @@ async def Greet( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = tests.reboot.greeter_pb2.GreetResponse() - __response__.ParseFromString(__query_response__.response) - yield GreeterGreetResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = tests.reboot.greeter_pb2.GreetResponse() + __response__.ParseFromString(__query_response__.response) + yield GreeterGreetResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -21906,14 +21934,17 @@ async def TryToConstructContext( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='TryToConstructContext', request=GreeterTryToConstructContextRequestToProto( __request__ ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -21929,13 +21960,38 @@ async def TryToConstructContext( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = google.protobuf.empty_pb2.Empty() - __response__.ParseFromString(__query_response__.response) - yield GreeterTryToConstructContextResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = google.protobuf.empty_pb2.Empty() + __response__.ParseFromString(__query_response__.response) + yield GreeterTryToConstructContextResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -22077,14 +22133,17 @@ async def TryToConstructExternalContext( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='TryToConstructExternalContext', request=GreeterTryToConstructExternalContextRequestToProto( __request__ ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -22100,13 +22159,38 @@ async def TryToConstructExternalContext( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = google.protobuf.empty_pb2.Empty() - __response__.ParseFromString(__query_response__.response) - yield GreeterTryToConstructExternalContextResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = google.protobuf.empty_pb2.Empty() + __response__.ParseFromString(__query_response__.response) + yield GreeterTryToConstructExternalContextResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -22254,14 +22338,17 @@ async def TestLongRunningFetch( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='TestLongRunningFetch', request=GreeterTestLongRunningFetchRequestToProto( __request__ ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -22277,13 +22364,38 @@ async def TestLongRunningFetch( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = google.protobuf.empty_pb2.Empty() - __response__.ParseFromString(__query_response__.response) - yield GreeterTestLongRunningFetchResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = google.protobuf.empty_pb2.Empty() + __response__.ParseFromString(__query_response__.response) + yield GreeterTestLongRunningFetchResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -22425,14 +22537,17 @@ async def GetWholeState( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='GetWholeState', request=GreeterGetWholeStateRequestToProto( __request__ ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -22448,13 +22563,38 @@ async def GetWholeState( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = tests.reboot.greeter_pb2.Greeter() - __response__.ParseFromString(__query_response__.response) - yield GreeterGetWholeStateResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = tests.reboot.greeter_pb2.Greeter() + __response__.ParseFromString(__query_response__.response) + yield GreeterGetWholeStateResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -22596,14 +22736,17 @@ async def FailWithException( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='FailWithException', request=GreeterFailWithExceptionRequestToProto( __request__ ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -22619,13 +22762,38 @@ async def FailWithException( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = google.protobuf.empty_pb2.Empty() - __response__.ParseFromString(__query_response__.response) - yield GreeterFailWithExceptionResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = google.protobuf.empty_pb2.Empty() + __response__.ParseFromString(__query_response__.response) + yield GreeterFailWithExceptionResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -22767,14 +22935,17 @@ async def FailWithAborted( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='FailWithAborted', request=GreeterFailWithAbortedRequestToProto( __request__ ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -22790,13 +22961,38 @@ async def FailWithAborted( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = google.protobuf.empty_pb2.Empty() - __response__.ParseFromString(__query_response__.response) - yield GreeterFailWithAbortedResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = google.protobuf.empty_pb2.Empty() + __response__.ParseFromString(__query_response__.response) + yield GreeterFailWithAbortedResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -22938,14 +23134,17 @@ async def ReadRecursiveMessage( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='ReadRecursiveMessage', request=GreeterReadRecursiveMessageRequestToProto( __request__ ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -22961,13 +23160,38 @@ async def ReadRecursiveMessage( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = tests.reboot.greeter_pb2.ReadRecursiveMessageResponse() - __response__.ParseFromString(__query_response__.response) - yield GreeterReadRecursiveMessageResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = tests.reboot.greeter_pb2.ReadRecursiveMessageResponse() + __response__.ParseFromString(__query_response__.response) + yield GreeterReadRecursiveMessageResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server diff --git a/tests/reboot/greeter_rbt_react.golden.js b/tests/reboot/greeter_rbt_react.golden.js index 91174eb0c..4b7924c7a 100755 --- a/tests/reboot/greeter_rbt_react.golden.js +++ b/tests/reboot/greeter_rbt_react.golden.js @@ -1882,6 +1882,7 @@ class GreeterInstance { const queryRequest = new reboot_api.react_pb.QueryRequest({ method, request: serializedRequest, + clientCanAcknowledgeResponses: true, ...(bearerToken !== undefined && { bearerToken } || {}), }); let expecteds = []; @@ -1981,17 +1982,34 @@ class GreeterInstance { // orphans list with a length greater than 0. In this case, we don't // want to skip checking the expecteds list just because we have // already checked the orphans list. - if (expecteds.length > 0 && - queryResponse.idempotencyKeys.includes(expecteds[0].idempotencyKey)) { - await expecteds[0].observed(() => { + // + // A single query response can report the idempotency keys of + // several mutations at once, because the backend aggregates the + // keys of every state it skipped over on its way to the state this + // response reflects. Two mutations may also share an idempotency + // key. So observe _every_ mutation whose key this response + // reports, not just the oldest one. + const observeds = expecteds.filter(expected => queryResponse.idempotencyKeys.includes(expected.idempotencyKey)); + if (observeds.length > 0) { + expecteds = expecteds.filter(expected => !observeds.includes(expected)); + // The one response we have in hand is the response for + // every one of these mutations, so publish it once, on + // the last of them, rather than handing every listener + // and the offline cache the same response N times. This + // is the same shape as the `orphans` loop above, and it + // matters more now that a response can report the keys + // of every state the backend skipped. + for (let i = 0; i < observeds.length - 1; i++) { + observeds[i].observed(() => { }); + } + await observeds[observeds.length - 1].observed(() => { if (response !== undefined) { reader.setResponse(response); } - expecteds.shift(); }); } // If we don't have any orphans to observe and we don't have any expecteds to observe, - // or at least, the first expecteds _is not observed_ by this response, then go ahead and + // or at least, none of the expecteds _is observed_ by this response, then go ahead and // pass on the response because it might contain new data that should get shown to the // user (e.g., in a chat app this could be a new chat message from a different user). else if (response !== undefined && !haveOrphans) { diff --git a/tests/reboot/ping_api_rbt.golden.py b/tests/reboot/ping_api_rbt.golden.py index 679663ba1..817bbc652 100755 --- a/tests/reboot/ping_api_rbt.golden.py +++ b/tests/reboot/ping_api_rbt.golden.py @@ -21331,13 +21331,16 @@ async def Describe( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='Describe', request=PingDescribeRequestToProto( ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -21353,13 +21356,38 @@ async def Describe( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = reboot.ping.ping_api_pb2.PingDescribeResponse() - __response__.ParseFromString(__query_response__.response) - yield PingDescribeResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = reboot.ping.ping_api_pb2.PingDescribeResponse() + __response__.ParseFromString(__query_response__.response) + yield PingDescribeResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -21466,13 +21494,16 @@ async def NumPings( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='NumPings', request=PingNumPingsRequestToProto( ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -21488,13 +21519,38 @@ async def NumPings( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = reboot.ping.ping_api_pb2.PingNumPingsResponse() - __response__.ParseFromString(__query_response__.response) - yield PingNumPingsResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = reboot.ping.ping_api_pb2.PingNumPingsResponse() + __response__.ParseFromString(__query_response__.response) + yield PingNumPingsResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -24116,13 +24172,16 @@ async def NumPongs( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='NumPongs', request=PongNumPongsRequestToProto( ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -24138,13 +24197,38 @@ async def NumPongs( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = reboot.ping.ping_api_pb2.PongNumPongsResponse() - __response__.ParseFromString(__query_response__.response) - yield PongNumPongsResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = reboot.ping.ping_api_pb2.PongNumPongsResponse() + __response__.ParseFromString(__query_response__.response) + yield PongNumPongsResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -26852,13 +26936,16 @@ async def ListCounters( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='ListCounters', request=UserListCountersRequestToProto( ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -26874,13 +26961,38 @@ async def ListCounters( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = reboot.ping.ping_api_pb2.UserListCountersResponse() - __response__.ParseFromString(__query_response__.response) - yield UserListCountersResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = reboot.ping.ping_api_pb2.UserListCountersResponse() + __response__.ParseFromString(__query_response__.response) + yield UserListCountersResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -26987,13 +27099,16 @@ async def Whoami( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='Whoami', request=UserWhoamiRequestToProto( ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -27009,13 +27124,38 @@ async def Whoami( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = reboot.ping.ping_api_pb2.UserWhoamiResponse() - __response__.ParseFromString(__query_response__.response) - yield UserWhoamiResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = reboot.ping.ping_api_pb2.UserWhoamiResponse() + __response__.ParseFromString(__query_response__.response) + yield UserWhoamiResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -30632,13 +30772,16 @@ async def Value( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='Value', request=CounterValueRequestToProto( ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -30654,13 +30797,38 @@ async def Value( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = reboot.ping.ping_api_pb2.CounterValueResponse() - __response__.ParseFromString(__query_response__.response) - yield CounterValueResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = reboot.ping.ping_api_pb2.CounterValueResponse() + __response__.ParseFromString(__query_response__.response) + yield CounterValueResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server @@ -30767,13 +30935,16 @@ async def Description( # type: ignore[misc] __this__._state_ref, ) as __channel__: - __call__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( + __stub__ = IMPORT_rbt_v1alpha1.react_pb2_grpc.ReactStub( __channel__ - ).Query( + ) + + __call__ = __stub__.Query( IMPORT_rbt_v1alpha1.react_pb2.QueryRequest( method='Description', request=CounterDescriptionRequestToProto( ).SerializeToString(), + client_can_acknowledge_responses=True, ), metadata=__metadata__, ) @@ -30789,13 +30960,38 @@ async def Description( # type: ignore[misc] # idempotency key has been recorded; there may # not be a new response. Python callers don't # (currently) care about such an event, so we - # simply ignore it. - if not __query_response__.HasField("response"): - continue - - __response__ = reboot.ping.ping_api_pb2.CounterDescriptionResponse() - __response__.ParseFromString(__query_response__.response) - yield CounterDescriptionResponseFromProto(__response__) + # simply ignore any message without a response. + if __query_response__.HasField("response"): + __response__ = reboot.ping.ping_api_pb2.CounterDescriptionResponse() + __response__.ParseFromString(__query_response__.response) + yield CounterDescriptionResponseFromProto(__response__) + + # Only now that the caller has processed the + # response do we ask the server for a next one, + # so that it reflects the latest state rather + # than a state that has already been + # superseded. An older backend doesn't send an + # ID and doesn't expect an acknowledgement. + if __query_response__.query_response_id != "": + try: + await __stub__.AcknowledgeQueryResponse( + IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest( + query_response_id=__query_response__.query_response_id, + ), + # The same metadata ensures we're + # routed to the same server. + metadata=__metadata__, + ) + except IMPORT_grpc.aio.AioRpcError as error: + if error.code() != IMPORT_grpc.StatusCode.UNIMPLEMENTED: + raise + # We have reached a server that has no + # `AcknowledgeQueryResponse`, which we + # can do mid-stream when a deployment is + # rolled back. Start a fresh read; that + # server's responses carry no ID and + # expect no acknowledgement. + break except IMPORT_grpc.aio.AioRpcError as error: # We expect to get disconnected from the server diff --git a/tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel b/tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel new file mode 100644 index 000000000..d59bf8a96 --- /dev/null +++ b/tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel @@ -0,0 +1,67 @@ +load("@aspect_rules_esbuild//esbuild:defs.bzl", "esbuild") +load("@aspect_rules_ts//ts:defs.bzl", "ts_project") +load("@rules_python//python:defs.bzl", "py_library") +load("//tests/reboot/react:py_web_test_suite_env.bzl", "py_web_test_suite_env") + +ts_project( + name = "index_ts", + srcs = [ + "index.tsx", + ], + tsconfig = "//tests/reboot/react:tsconfig", + deps = [ + "//:node_modules/@reboot-dev/reboot-web", + "//:node_modules/react", + "//:node_modules/react-dom", + "//rbt/v1alpha1:tasks_js_proto", + "//tests/reboot:greeter_js_proto", + "//tests/reboot:greeter_web_ts_reboot", + ], +) + +esbuild( + name = "bundle", + srcs = [ + ":index_ts", + ], + entry_point = "index.js", + format = "esm", + platform = "browser", +) + +py_library( + name = "test_py", + testonly = True, + srcs = ["test.py"], + data = [ + ":bundle", + ], + visibility = ["//tests:__subpackages__"], + deps = [ + "//reboot/aio:external_py", + "//tests/reboot:greeter_servicers_py", + "//tests/reboot/react:web_driver_runner", + ], +) + +py_web_test_suite_env( + name = "test_against_local_envoy_py", + srcs = ["test_against_local_envoy.py"], + browsers = [ + "@io_bazel_rules_webtesting//browsers:chromium-local", + ], + main = "test_against_local_envoy.py", + # This test is not supported on macOS. + py_test_tags = [ + "macos_not_supported", + "requires-linux-x86", + ], + tags = [ + "macos_not_supported", + "requires-linux-x86", + ], + deps = [ + ":test_py", + "//tests/reboot/react:test_against_local_envoy_py", + ], +) diff --git a/tests/reboot/react/test_reactive_reader_flow_control/index.tsx b/tests/reboot/react/test_reactive_reader_flow_control/index.tsx new file mode 100644 index 000000000..8885d4fc6 --- /dev/null +++ b/tests/reboot/react/test_reactive_reader_flow_control/index.tsx @@ -0,0 +1,72 @@ +import { WebContext } from "@reboot-dev/reboot-web"; +import { useEffect, useState } from "react"; +import ReactDOM from "react-dom/client"; +import { Greeter } from "../../greeter_rbt_web"; + +const ID = "greeter-flow-control-test"; + +declare global { + interface Window { + // Releases the acknowledgement of the response currently on + // screen. The test calls this once it has made every state change + // that it wants the backend to have skipped over. + acknowledge: () => void; + } +} + +const App = ({ url }: { url: string }) => { + const [messages, setMessages] = useState([]); + + useEffect(() => { + const abortController = new AbortController(); + + const read = async () => { + const context = new WebContext({ url }); + + // We consume the reactive read ourselves rather than through + // `useGreet` so that we decide when each response is + // acknowledged: `reactively()` asks the backend for a next + // response only once we ask this generator for one, so a + // response we have not asked for yet is a response the backend + // has not been told it may produce. + const [responses] = await Greeter.ref(ID).reactively().greet( + context, + { name: "Jonathan" }, + { + signal: abortController.signal, + } + ); + + for await (const response of responses) { + setMessages((messages) => [...messages, response.message]); + + // `window.acknowledge` is assigned here, synchronously, before + // React paints the message above, so a test that has seen a + // message rendered knows the hold is in place. + await new Promise((resolve) => { + window.acknowledge = resolve; + }); + } + }; + + read(); + + return () => abortController.abort(); + }, [url]); + + if (messages.length === 0) return <>Loading...; + + return ( +
+

{messages[messages.length - 1]}

+ {/* One message per line, oldest first. */} + 
{messages.join("\n")}
+
+ ); +}; + +export const render = (url: string) => { + const root = ReactDOM.createRoot(document.getElementById("root")); + + root.render(); +}; diff --git a/tests/reboot/react/test_reactive_reader_flow_control/test.py b/tests/reboot/react/test_reactive_reader_flow_control/test.py new file mode 100644 index 000000000..2c0aea740 --- /dev/null +++ b/tests/reboot/react/test_reactive_reader_flow_control/test.py @@ -0,0 +1,111 @@ +import asyncio +import os +import time +from reboot.aio.external import ExternalContext +from selenium.webdriver.common.by import By +from tests.reboot.greeter_rbt import Greeter +from tests.reboot.react.web_driver_runner import web_driver + +STATE_ID = 'greeter-flow-control-test' + +# Adjectives to write, in rounds. Every adjective in a round is written +# while the browser holds the acknowledgement of the response it is +# showing, so the backend passes through all of them and may send only +# the last. +ROUNDS = [ + [f'round-{round}-adjective-{index}' + for index in range(10)] + for round in range(3) +] + + +async def test(context: ExternalContext, uri: str): + """Tests that a reactive reader whose consumer is slow to ask for a + next response skips the states it missed and gets the latest one. + + The app in `index.tsx` consumes the reactive read itself and holds + the acknowledgement of each response until this test releases it, + so every state change below is known to have completed while the + backend had no response it was allowed to send. Releasing the + acknowledgement must then produce exactly one response, carrying + the last state written in the round rather than the first one the + backend passed through.""" + await Greeter.idempotently(f"Create '{STATE_ID}'").Create( + context, + STATE_ID, + title='Count', + name='Chocula', + adjective='tasty', + ) + + greeter = Greeter.ref(STATE_ID) + + def message(adjective: str) -> str: + return f'Hi Jonathan, I am Count Chocula the {adjective}' + + def rendered_messages(driver) -> list[str]: + """Returns every message the browser has rendered, in order.""" + try: + rendered = driver.find_element(By.ID, 'rendered' + ).get_attribute('textContent') + except Exception: + # The app renders nothing at all until it has a first + # response to show. + return [] + return [line for line in (rendered or '').split('\n') if line != ''] + + # We poll the browser rather than using `reactively()` because what + # we are waiting for is the browser's rendered DOM, which Reboot + # cannot observe. + def wait_for_message_count(driver, count: int) -> list[str]: + while len(rendered_messages(driver)) < count: + time.sleep(0.1) + return rendered_messages(driver) + + with web_driver( + uri=uri, + bundle_js_path=os.path.join(os.path.dirname(__file__), 'bundle.js'), + ) as (driver, port): + # Selenium calls block, so run each of them in a separate + # thread to keep this event loop free for the Reboot calls + # interleaved between them. + await asyncio.to_thread(driver.get, f'http://127.0.0.1:{port}/') + + # The browser renders the state it started from and then holds + # its acknowledgement of that response. + rendered = await asyncio.to_thread(wait_for_message_count, driver, 1) + assert rendered == [message('tasty')], rendered + + for index, adjectives in enumerate(ROUNDS): + # Each of these writes has completed by the time the next + # begins, so by the end of this loop the backend has passed + # through every one of these states while holding a + # response that the browser has not acknowledged. + for adjective in adjectives: + await greeter.SetAdjective(context, adjective=adjective) + + # Let the browser acknowledge, which is the first moment + # the backend may produce a next response. + await asyncio.to_thread( + driver.execute_script, + 'window.acknowledge()', + ) + + rendered = await asyncio.to_thread( + wait_for_message_count, + driver, + index + 2, + ) + + assert rendered[-1] == message(adjectives[-1]), ( + f"Expected the response after round {index} to carry " + f"'{adjectives[-1]}', the last state written in it, but " + f"got '{rendered[-1]}'" + ) + + # One render for the state the browser started from and one per + # round: every intermediate state was skipped, and none of them + # was ever rendered. + assert rendered == [message('tasty')] + [ + message(adjectives[-1]) for adjectives in ROUNDS + ], rendered diff --git a/tests/reboot/react/test_reactive_reader_flow_control/test_against_local_envoy.py b/tests/reboot/react/test_reactive_reader_flow_control/test_against_local_envoy.py new file mode 100644 index 000000000..2862e082b --- /dev/null +++ b/tests/reboot/react/test_reactive_reader_flow_control/test_against_local_envoy.py @@ -0,0 +1,12 @@ +from reboot.aio.applications import Application +from tests.reboot.greeter_servicers import MyGreeterServicer +from tests.reboot.react.test_against_local_envoy import ( + web_test_against_local_envoy, +) +from tests.reboot.react.test_reactive_reader_flow_control.test import test + +if __name__ == '__main__': + web_test_against_local_envoy( + test=test, + application=Application(servicers=[MyGreeterServicer]), + ) diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py index 488b1cf11..a58489422 100644 --- a/tests/reboot/reactivity_test.py +++ b/tests/reboot/reactivity_test.py @@ -1,17 +1,106 @@ import asyncio +import contextlib import unittest +from rbt.v1alpha1 import react_pb2, react_pb2_grpc from reboot.aio.applications import Application +from reboot.aio.contexts import ReaderContext from reboot.aio.external import ExternalContext from reboot.aio.tests import Reboot +from tests.reboot import greeter_rbt from tests.reboot.greeter_rbt import Greeter from tests.reboot.greeter_servicers import MyGreeterServicer from typing import Optional +from unittest.mock import patch + +# `title` that marks a `Greeter` as one whose `Greet` reads another +# `Greeter`, named by its own `name`, rather than its own state. +PROXY_TITLE = 'proxy' + +# The real `QueryRequest` and `ReactStub`, captured here so that the +# shims below reach them through a name that patching the module does +# not; going back through the module would make a shim call itself. +QUERY_REQUEST = react_pb2.QueryRequest +REACT_STUB = react_pb2_grpc.ReactStub + + +class QueryRequestWithoutAcknowledgements: + """Constructs a `QueryRequest` the way a client from before + acknowledgements existed did, i.e. without + `client_can_acknowledge_responses`. + + The generated gRPC stub reads `QueryRequest.SerializeToString` off + the class when it is constructed, and the servicer registration + reads `FromString`, so both stay reachable here. + """ + + SerializeToString = QUERY_REQUEST.SerializeToString + FromString = QUERY_REQUEST.FromString + + def __new__(cls, **kwargs): + kwargs.pop('client_can_acknowledge_responses', None) + return QUERY_REQUEST(**kwargs) + + +@contextlib.contextmanager +def query_requests_without_acknowledgements(): + """Makes every reactive reader send a `QueryRequest` the way a + client from before acknowledgements existed did. Both the generated + clients and `reboot.aio.contexts` look `QueryRequest` and + `ReactStub` up on their modules at call time, so patching here + covers both. + + Yields the IDs this client was driven to acknowledge, which must + stay empty: a client from before acknowledgements existed had no + `AcknowledgeQueryResponse` to call, so a backend that kept the + responses coming only because this one acknowledged would strand a + real old client.""" + acknowledged: list[str] = [] + + class ReactStub: + + def __init__(self, channel): + self._stub = REACT_STUB(channel) + + def __getattr__(self, name): + return getattr(self._stub, name) + + def AcknowledgeQueryResponse(self, request, **kwargs): + acknowledged.append(request.query_response_id) + return self._stub.AcknowledgeQueryResponse(request, **kwargs) + + with patch.object( + react_pb2, + 'QueryRequest', + QueryRequestWithoutAcknowledgements, + ), patch.object(react_pb2_grpc, 'ReactStub', ReactStub): + yield acknowledged + + +class ProxyingGreeterServicer(MyGreeterServicer): + """A `Greeter` whose `Greet` returns the greeting of the `Greeter` + named by its own `name` when its `title` is `PROXY_TITLE`. Reading + such a `Greeter` reactively therefore transitively reads the other + `Greeter` reactively.""" + + async def Greet( + self, + context: ReaderContext, + request: greeter_rbt.GreetRequest, + ) -> greeter_rbt.GreetResponse: + if self.state.title != PROXY_TITLE: + return await super().Greet(context, request) + + return await Greeter.ref(self.state.name).Greet( + context, + name=request.name, + ) class ReactivityTestCase(unittest.IsolatedAsyncioTestCase): async def asyncSetUp(self) -> None: self._accumulate_task: Optional[asyncio.Task] = None + self._can_accumulate_next_adjective = asyncio.Event() self._accumulated_adjective = asyncio.Event() self._accumulated_adjectives: list[str] = [] @@ -20,7 +109,7 @@ async def asyncSetUp(self) -> None: async def asyncTearDown(self) -> None: if self._accumulate_task is not None: - await self._stop_accumulating_adjectives() + await self._stop_accumulating() await self.rbt.stop() async def start_accumulating_adjectives( @@ -32,10 +121,13 @@ async def _do(): ).GetWholeState(context): self._accumulated_adjectives.append(greeter_state.adjective) self._accumulated_adjective.set() + # Hold up the reactive reader until the test says we + # may consume a next response. + await self._can_accumulate_next_adjective.wait() self._accumulate_task = asyncio.create_task(_do()) - async def _stop_accumulating_adjectives(self): + async def _stop_accumulating(self): assert self._accumulate_task is not None self._accumulate_task.cancel() try: @@ -54,6 +146,8 @@ async def test_reactive_get_all_state(self) -> None: """ Regression test for https://github.com/reboot-dev/mono/issues/3135 """ + self._can_accumulate_next_adjective.set() + await self.rbt.up(Application(servicers=[MyGreeterServicer])) context = self.rbt.create_external_context(name=f"test-{self.id()}") greeter, _ = await Greeter.Create( @@ -83,6 +177,149 @@ async def test_reactive_get_all_state(self) -> None: await self.get_adjectives(2), ) + async def test_skip_to_latest(self) -> None: + """ + Tests that a reactive reader that can't keep up with the rate of + state changes skips straight to the latest state, instead of + working its way through every state that it missed. + """ + await self.rbt.up(Application(servicers=[MyGreeterServicer])) + context = self.rbt.create_external_context(name=f"test-{self.id()}") + greeter, _ = await Greeter.Create( + context, + "my-greeter", + title="Mr.", + name="Robot", + adjective="reactive", + ) + + # Get the first response, then leave the reactive reader + # blocked; it hasn't asked for a next response yet. + await self.start_accumulating_adjectives(greeter, context) + self.assertEqual(["reactive"], await self.get_adjectives(1)) + + # Change the state several times while the reader is blocked. + await greeter.SetAdjective(context, adjective="realistic") + await greeter.SetAdjective(context, adjective="impressive") + await greeter.SetAdjective(context, adjective="marvelous") + await greeter.SetAdjective(context, adjective="fantastic") + + # Now let the reactive reader consume a next response. It must + # be the latest state, not the oldest state it missed. + self._can_accumulate_next_adjective.set() + self.assertEqual( + ["reactive", "fantastic"], + await self.get_adjectives(2), + ) + + async def test_transitive_skip_to_latest(self) -> None: + """ + Tests that a reactive reader that reads through another reactive + reader also doesn't work its way through every state that it + missed while it couldn't keep up. + """ + await self.rbt.up(Application(servicers=[ProxyingGreeterServicer])) + context = self.rbt.create_external_context(name=f"test-{self.id()}") + + greeter, _ = await Greeter.Create( + context, + "my-greeter", + title="Mr.", + name="Robot", + adjective="reactive", + ) + + proxy, _ = await Greeter.Create( + context, + "my-proxy", + title=PROXY_TITLE, + name="my-greeter", + adjective="unused", + ) + + greetings: list[str] = [] + greeted = asyncio.Event() + can_greet_again = asyncio.Event() + + async def accumulate_greetings(): + async for response in proxy.reactively().Greet( + context, + name="Alice", + ): + greetings.append(response.message) + greeted.set() + await can_greet_again.wait() + + self._accumulate_task = asyncio.create_task(accumulate_greetings()) + + async def get_greetings(expected_number: int) -> list[str]: + while len(greetings) < expected_number: + await greeted.wait() + greeted.clear() + return greetings + + # Get the first greeting, then leave the reader blocked. + self.assertEqual( + ["Hi Alice, I am Mr. Robot the reactive"], + await get_greetings(1), + ) + + adjectives = [f"adjective-{index}" for index in range(10)] + for adjective in adjectives: + await greeter.SetAdjective(context, adjective=adjective) + + # Now let the reader consume responses again. It must arrive at + # the latest state without seeing every state it missed; the + # transitive read costs it at most one extra response, since the + # response it already had in hand for the underlying `Greeter` + # was produced before the last of the changes above. + can_greet_again.set() + + latest = f"Hi Alice, I am Mr. Robot the {adjectives[-1]}" + while greetings[-1] != latest: + await greeted.wait() + greeted.clear() + + self.assertLessEqual(len(greetings), 3, greetings) + + async def test_client_without_acknowledgements(self) -> None: + """ + Tests that a client from before acknowledgements existed, which + never acknowledges a response, keeps getting new responses + instead of being stalled waiting for an acknowledgement that + will never come. + """ + self._can_accumulate_next_adjective.set() + + await self.rbt.up(Application(servicers=[MyGreeterServicer])) + context = self.rbt.create_external_context(name=f"test-{self.id()}") + greeter, _ = await Greeter.Create( + context, + "my-greeter", + title="Mr.", + name="Robot", + adjective="reactive", + ) + + with query_requests_without_acknowledgements() as acknowledged: + await self.start_accumulating_adjectives(greeter, context) + self.assertEqual(["reactive"], await self.get_adjectives(1)) + + await greeter.SetAdjective(context, adjective="realistic") + + self.assertEqual( + ["reactive", "realistic"], + await self.get_adjectives(2), + ) + + # Getting both responses is only evidence of what an old + # client sees if this one really behaved like one. Had the + # backend stamped IDs on those responses regardless of what + # the client asked for, this client would have acknowledged + # them and sailed on where a real old client, which has no + # `AcknowledgeQueryResponse` to call, would have stalled. + self.assertEqual([], acknowledged) + if __name__ == '__main__': unittest.main()