From b3cc15b71f2a25979b753ddb0476d3436799ee09 Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Mon, 31 Aug 2026 17:38:52 +0000
Subject: [PATCH 01/13] React: add flow control to reactive readers

Keeps a client of a reactive read on the latest state even when
the state changes faster than the client can consume the
updates. Before this change the backend produced a response per
state change and pushed it at the client regardless of whether
the client had consumed the previous one, so responses queued up
in the gRPC stream or in the browser's websocket buffer: a
client that couldn't keep up worked its way through every state
it had missed, and fell arbitrarily far behind while still
receiving a steady stream of (old) responses.

A client that sets `client_can_acknowledge_responses` on its
`QueryRequest` gets flow control: `React.Query` stamps every
response with a `query_response_id` and produces no further
response until the client acknowledges that ID. Acknowledgements
travel back over the websocket that carries the responses when
there is one -- a `QueryRequest` with
`acknowledge_query_response_id` set, which costs no extra round
trip -- and over the new unary `AcknowledgeQueryResponse` RPC
otherwise. Between an acknowledgement and the next response the
backend catches up to the _latest_ state, so a slow client skips
the states it missed instead of replaying them.

A version skew in either direction keeps working, so a frontend
and a backend can be deployed in either order:

- An empty `query_response_id` means that no acknowledgement is
  expected, and a client acknowledges only a response that
  carries one. An older backend sends no ID, and neither does a
  backend answering a client that didn't ask for flow control.
- A backend applies flow control only for a client that set
  `client_can_acknowledge_responses`, so a client from before
  acknowledgements existed keeps receiving every response as
  soon as it is produced instead of stalling on an
  acknowledgement that it will never send.
- Transitive reactive reads acknowledge only once the response
  they hold has been used, so a reader that reads through
  another reader also gets the latest state rather than the next
  one in line.

TESTED: `//tests/reboot:reactivity_test_py` gains
  `test_skip_to_latest`, `test_transitive_skip_to_latest` and
  `test_client_without_acknowledgements`.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FMgyLgRtZXNAerHpSguK9k
Claude-Session: https://claude.ai/code/session_01TQxdTEi8qsBfxCcuLxrNmQ
---
 rbt/v1alpha1/react.proto                 |  50 +++-
 reboot/aio/contexts.py                   |  62 +++--
 reboot/aio/react.py                      | 245 ++++++++++++++-----
 reboot/templates/reboot.py.j2            |  37 ++-
 reboot/templates/reboot_react.ts.j2      |   1 +
 reboot/web/index.ts                      | 114 ++++++++-
 tests/reboot/echo_rbt.golden.py          |  74 ++++--
 tests/reboot/greeter_rbt.golden.js       |   2 +-
 tests/reboot/greeter_rbt.golden.py       | 296 +++++++++++++++++------
 tests/reboot/greeter_rbt_react.golden.js |   1 +
 tests/reboot/ping_api_rbt.golden.py      | 259 +++++++++++++++-----
 tests/reboot/reactivity_test.py          | 247 ++++++++++++++++++-
 12 files changed, 1139 insertions(+), 249 deletions(-)

diff --git a/rbt/v1alpha1/react.proto b/rbt/v1alpha1/react.proto
index 0b770b655..73e66e5b1 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 that does not set this gets responses at whatever rate the
+  // server produces them, whether or not it can consume them that
+  // fast.
+  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,18 @@ 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 responses at whatever rate the server produces them,
+  // whether or not it can consume them that fast.
+  //
+  // 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 +137,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..b0e678e8b 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,44 @@ 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 we
+                            # can't fall behind a server that produces
+                            # responses faster than we consume them.
+                            # See
+                            # https://github.com/reboot-dev/mono/issues/4754.
+                            # An older backend doesn't send an ID and
+                            # doesn't expect an acknowledgement.
+                            if query_response.query_response_id != '':
+                                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,
+                                )
 
                         raise RuntimeError('React.Query should be infinite')
 
diff --git a/reboot/aio/react.py b/reboot/aio/react.py
index d1039e986..ac138a0a2 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,39 @@ 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)
+
+                    # Look the event up rather than take it: the loop
+                    # that produced the response owns the entry and
+                    # removes it once it is done waiting. An
+                    # acknowledgement we no longer have an entry for
+                    # is one we have already acted on, or one whose
+                    # response we produced before a restart.
+                    acknowledged = acknowledgements.get(
+                        acknowledgement.acknowledge_query_response_id
+                    )
+                    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 +382,131 @@ async def consume_heartbeats():
                 headers=headers,
                 middleware=middleware,
             ):
-                await websocket.send(response.SerializeToString())
+                acknowledged: Optional[asyncio.Event] = None
+
+                if request.client_can_acknowledge_responses:
+                    response.query_response_id = str(uuid.uuid4())
+                    acknowledged = asyncio.Event()
+                    acknowledgements[response.query_response_id] = acknowledged
+
+                try:
+                    await websocket.send(response.SerializeToString())
+
+                    # A client that acknowledges nothing gets
+                    # responses as fast as we produce them; the empty
+                    # ID tells it that we expect no acknowledgement.
+                    if acknowledged is not None:
+                        # Wait for the client to tell us that it is
+                        # ready for a next response, so that it can't
+                        # fall behind us. While we wait here the state
+                        # may change any number of times, and the next
+                        # response we produce reflects the latest of
+                        # those states.
+                        await acknowledged.wait()
+                finally:
+                    if acknowledged is not None:
+                        del acknowledgements[response.query_response_id]
         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)
 
+    def _middleware_for(self, 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.
+            raise SystemAborted(
+                Unavailable(),
+                message=f"Server '{middleware.server_id}' is not "
+                "authoritative for this request; server "
+                f"'{authoritative_server}' is.",
+            )
+
+        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."""
+        try:
+            # Confirm that we are the server that produced the
+            # response.
+            self._middleware_for(Headers.from_grpc_context(grpc_context))
+        except Aborted as aborted:
+            await grpc_context.abort_with_status(
+                rpc_status.to_status(aborted.to_status())
+            )
+
+        # Look the event up rather than take it: the `Query` call that
+        # produced the response owns the entry and removes it once it
+        # is done waiting.
+        acknowledged = self._query_response_acknowledgements.get(
+            request.query_response_id
+        )
+
+        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 +569,52 @@ 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 = self._middleware_for(headers)
 
             async for response in self._query(
                 request=request,
                 headers=headers,
                 middleware=middleware,
             ):
-                yield response
+                acknowledged: Optional[asyncio.Event] = None
+
+                if request.client_can_acknowledge_responses:
+                    response.query_response_id = str(uuid.uuid4())
+                    acknowledged = asyncio.Event()
+                    self._query_response_acknowledgements[
+                        response.query_response_id] = acknowledged
+
+                try:
+                    yield response
+
+                    # A client that acknowledges nothing gets
+                    # responses as fast as we produce them; the empty
+                    # ID tells it that we expect no acknowledgement.
+                    if acknowledged is not None:
+                        # Wait for the client to tell us, via
+                        # `AcknowledgeQueryResponse`, that it is ready
+                        # for a next response, so that it can't fall
+                        # behind us. While we wait here the state may
+                        # change any number of times, and the next
+                        # response we produce reflects 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:
+                    # The `yield` is inside this `try` so that closing
+                    # the generator while it is suspended there still
+                    # takes the entry back out of a dictionary that
+                    # lives as long as the service.
+                    if acknowledged is not None:
+                        del self._query_response_acknowledgements[
+                            response.query_response_id]
         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..0bf4336b3 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,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # 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 b422f3590..152879b95 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 } || {}),
     });
 
diff --git a/reboot/web/index.ts b/reboot/web/index.ts
index 680b135b5..1c4c5ac33 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,61 @@ export function reactively<
   return [responses(), setRequest];
 }
 
+// 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<void> {
+  const url = new URL(
+    `${endpoint}/rbt.v1alpha1.React/AcknowledgeQueryResponse`
+  );
+
+  const backoff = new Backoff();
+
+  while (true) {
+    try {
+      // Pass the options separately rather than pre-building a
+      // `Request`: `guardedFetch` reads `signal` off them to tell a
+      // deliberate cancellation apart from a server it cannot reach.
+      const response = await guardedFetch(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) {
+        throw new Error(
+          `Acknowledging query response '${queryResponseId}' failed ` +
+            `with HTTP status ${response.status}`
+        );
+      }
+      return;
+    } catch (e) {
+      if (signal?.aborted) {
+        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 +486,18 @@ export async function* reactiveReader({
   websockets: boolean;
 }): AsyncGenerator<react_pb.QueryResponse, void, unknown> {
   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();
+
+  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");
 
-    yield* grpcServerStream({
+    const responses = grpcServerStream({
       endpoint: url.toString(),
       method: "POST",
       headers,
@@ -445,6 +505,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 +536,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") {
@@ -755,12 +841,16 @@ export async function* grpcWebsocketServerStream<
   heartbeatRequest,
   responseType,
   signal,
+  acknowledgeRequest,
 }: {
   url: URL;
   request: RequestType;
   heartbeatRequest: RequestType;
   responseType: MessageType<ResponseType>;
   signal: AbortSignal;
+  // Produces the request, if any, to send back once the consumer has
+  // processed a response.
+  acknowledgeRequest?: (response: ResponseType) => RequestType | undefined;
 }): AsyncGenerator<ResponseType, void, unknown> {
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
 
@@ -848,7 +938,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..7c8507be9 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,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -21021,14 +21040,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 +21066,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # 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..65f43f9b4 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", "H4sIAAAAAAAC/81ba3fbxhH9rl+BMG0lOTGFJx/qcY8ZEpJVS6QCQmbSMAfFYymhJgEWWDpUf333ARCLJQACMuX2g0WJO3Pnzuzs7Axw/L3w9s1bwQ09P3i8FDZw8baHvzn5XrgGAYhsCDzBeRbgExDWUQhDN1wKzmaxABFSWq39JYjagjCaCOOJKeijG/M7pBqHm8gFlwIEMYwvIuCEIbx4jACASJrAIKF7/ImghPtn+BQGwicQxX4YXApaW+60pZNWq5VR2LftgTaSOFlE4Up4DMPHJaDIGNFfrcMICh6I3chfwzAS7Fiwsj9ralnrEFnMq5LvKvXj55UTLi3PhrZjx4Doc98V6rf9AIUnsJcpkLPxlx6g3JPfUdjev6exsPwgBhFEEUOUkOoZ1YrPT06wOctzhHd7htsjsLA3S3iGpCiJyIHtL5K9XD/ZUmo4XGPY2Fo7MjaORCwvhFYqRv5IZbBQORK048/VOFQiQykJKlit4XMKRGWIeipH/qBCe1j22k9h7CAIoZ3zjgFDgvSTkSJoJycjfTo0bu7NiYGjyqVDFtX2wPOmIPLtpf8f4F2h03HmnM6D+Vayy88CWpXnW9ElEm0qgTXwPxSzizReF0nMd1pYopeTINHMrTvUv4s0UBckSDkRNxFB7l8wricyrfnWVhE9Cbshdq8pc8pZUsmXGvThEmAyWE7AP87m0GBXZPIPC6uBvUplZVY2XcCiLhKFtvcv4EL/SyqtZNK5NfkjibAUAXeDSsgXYK1AHNuPqZ6a6G1FZ75VMDxos7FuG6niHdVDbCQx4r68xEjzbQ/pO1qCLM5bM2Q7GkYA7a8B/r1BsP8/oWlhPwgyklOVhGS8RptLFm1tt68u2de8B/ukpBJSKnW2twLIOio1rA/KLvBn+aizFtt3iaYewOjZ4LDsv+Ig50QSitQ75TN4LmKYfM/sxhd7uSmMMF3Be4ykFYI0b51jswnNJGoUrUfPQj7NcqZ3ayjMC5CGWVKmAA7S/clHu3BfpbKUn89pzs+3HSlyfBjZ0TOX9nI+7S/y0S8g0h6jH8BjDwELf7dDxyGi/mgR+IIuIcteoJpgSVYM3DDwuKREm4nBZCo7wKLSNBW0SbhRnHPGiRFSOMVFzkV2A3MBB6zYJyLV0glHNe9qtpFv6S7immn5HgeaFQu1zd5sbROJ33jYZAeSX+ctWn8cE3lwGwaPxiYIUDd1BaD7xOzxj0RKjpcArC3or0ASrZizHJHIEzETSU0TIXyYO9ShawBnT+ESTCFTdVpnZFGchdHnxTL8g0vZggMg7R+Aeesvu3qhRVEYzXz49CnRaQLzT0qGr6zNzw/NtrQUgS0szu5aRT0BaP1CyLlTdH+DPTH2UCqVRBuZZguCtCAEvBICWYGWPJpZBrC9MqKpN8UybA68ijfv58HZENmA0caFg8A7HNQ0h9CBRfdpR1vDpz0qmsFLtH6YB+c1DGXBc0iakOB0yBWFCkTwCKJwE1/5YOnFeVZ24RXGUWKXmUSOdkj51CQ6zCpjJ8q2Jl8rqZ0of3qT/I/BcrHX1BCFdIkhhfxVQjRS7I6MxvHKCcjf0T4AfSnjmJNyimo6DD+DIAHo5AEcTtZMROW0UomdXTOL1bt59WyR8XCz2VXiHudhssSGA24cIgz5YNAFtBFYzvE91PSGEAQubRMCttJwqxi+T7coxuU1uxmcXH0ii7j44wND6eBqnXd/5btRGO+lkmIwi7TiSiLK5/Ufdv7KYF0N13s4PWO31HpH+wEGJUugs7QVRaeWBVHYUy/nTz12xsi0Wn+j+HcYexguw4iheb470Ape2eMJEhNK3gSFyWm27uklyZrJ/Likd9MKL6IL1nJfYC1Ktcnfb/6cUldT6jI5GqStNPQRbYJQo48XIBW+NnR9nCxIiQY9c6jGqPLtg54s0ptr25fIwSLck/EJ9bJPIbn55TuaKrsGPdl3h2PPTRhkbisWySogYpWfV9SErZx8Erc+JF5hZmmNKu/U07GyUIIx3eFM0zwmBn+nlYZty0gBOtigEtutKrFKAozPTyTNumZkB7Ht4nH3f8DGTtlMaC9tRs9muLvihllpxgWlzT8t0vEcn+xG2eqBjZjRNiRvV9/Sp1DfwD6+N2hHW9Q6k8rCFaXKDvsrmKQ7kMefRX72qOOYEWAy0SAzJtvQk1Uurwo7fmpZKziJiPQBhz+m46PawbvgL3Gjr29dQB4xveam/5pOdazlgRNGaPr7WrsSZze5PcXL0pHmH/SqT4emWgS4/nhv4Com0qomMtuFZb9Rxet/yhsd2SWt7Fcl45Yeg8LWGq+/4apdda9v/1BLvG7N3tBSUTTnFJSKqpEJUXtTR7redYYueJc+4Pnu4HySDGIdvjWpPT/hxyXdxtr1LiLcq7j2zjnSFC1D9zMmfU87afzVJopAANlmt/K0FPSV5IRolIinzLcApXxfoWREOsVEFy61Q56UJE8ZlbTHRZ3OangcHsTxXSeH3YS7HjrBBXtpzDfqGH9RKsVEXzxLLf1Czzv15RtYTH1UdrcunvVo10u6bXrR/YxWgqz7TvhwloqGAFsol2Hp0JlR7JA9Uk7x26rHZejYy1h4JyS/nZ2fpC+82j/hzySRUYLrwWY12r19ic+y9zI/CikQr22Ga0YFgSRwee3THP3kBQ1++3PKIvsLIQgh+waobT1MdWtoZVjTyxNByP5sW8vQ9oCXvjJDfo7DACCZFPa3UwvPFKZunP7eVDrevW1iNJzTuYwOk4xGcxFtvCiKpwUAhv7zgz41rTvdHIwG5kAfm8avTRiUApSQ6iEm0mmhKwjiw2Q0RcorOhpZzrOFXzD8dkrnmmaRqQVXL3TqXJRl9Cknn2JjB0hLdjT+O7R69HEtfwlpdpI5GncetK4LL418yXx3NH8q8Gu7przUtYJh8YiOlaC/btJVTqKv5FyBlVd2smCIPZ5vJeDf1CU6N7+WTxn6a5eP3NR9vALOo77u3lzZ3HB/NEcKkb+NM8nzgqO7wuDWckROHLmci1JHzw31jX1LnyMczSkWsK43rWN5wz2gOJpTBbivXQYKh+rj9URl6K/tVtEzj6N5VQb+uuXh4KOQ400RdSx9XQ84vJ0MPxbazp581PSnLlQVYUVW5oqqzmX0SUhLXZJ6+Sc1vA+T2wk/psbQjuA7GWEelgWBhySVfp3xl+JKWq+OMAZWZJ6BoQ+QKJ1qC9EVWa2vgm2oklSsML2fjKd6oRFVUhroECtyv3w8L7ahyLU1sAWt333hAwBqT1N6L9Svsl4RRK3fr6+CbXRUMa8wxaT+rg/Nm0+VOdFRlaaK2F6P96lAzRqjH/roTp9OB9fFfvZU6etganCpCHOPD3MNTWyx3+HywUQUbyfja+NhPL4ZX1/p5vBDVdT7XfGlANi+JKoalx+6OfswuUXiB2oAUu02VqU2O1ywZhPj49XtZFYZYknsSo3UiC2JLzy6YUyM2Y354dPg9qHEksRXnkolakfj7Bj68MGYot2vylqkpjRSI7ZklU82c2LovGbl3sk83QYQhIOi1ONQtaGKKr0cg7Loynz4BqNGgVC66ksRCANVVOroV4VBFbUXQ1AOff6iRJKm8TA0B+NR89xQ+9pR4Ag3Tes3BqsKltaRjoNH2HVEbvdHgzHSmDxMr27029G0Mk4dsfsCZWK3L3FRMW/uShzuy9JBUYpZcKTvZ4MD9wdSUxqpUVv9cltVu9fvK830SOMratwu3WEN0idXuYb0Os30iDVJ6pVrVTgnS7LYUJG29aJ4YOoqmhpUuYES6fK7e8c6mYYK2vtuv3dYlvb1cq9gfCGel0wmqK0Xa6vQrl7uVv2Hv1XobZbAit1wDc5P/gsZ7xSIyTkAAA==");
     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", "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");
 }
 importPys();
diff --git a/tests/reboot/greeter_rbt.golden.py b/tests/reboot/greeter_rbt.golden.py
index 52eac3f55..40abb578b 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,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -21906,14 +21925,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 +21951,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -22077,14 +22115,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 +22141,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -22254,14 +22311,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 +22337,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -22425,14 +22501,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 +22527,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -22596,14 +22691,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 +22717,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -22767,14 +22881,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 +22907,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -22938,14 +23071,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 +23097,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # 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 af09b2f6d..e83ee8e2d 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 = [];
diff --git a/tests/reboot/ping_api_rbt.golden.py b/tests/reboot/ping_api_rbt.golden.py
index 679663ba1..5d1aa88ad 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,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -21466,13 +21485,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 +21510,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -24116,13 +24154,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 +24179,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -26852,13 +26909,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 +26934,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -26987,13 +27063,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 +27088,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -30632,13 +30727,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 +30752,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
@@ -30767,13 +30881,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 +30906,29 @@ 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 we can't fall behind a server that
+                                # produces responses faster than we consume
+                                # them. See
+                                # https://github.com/reboot-dev/mono/issues/4754.
+                                # An older backend doesn't send an ID and
+                                # doesn't expect an acknowledgement.
+                                if __query_response__.query_response_id != "":
+                                    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:
                         # We expect to get disconnected from the server
diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py
index 488b1cf11..42c362b71 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,155 @@ 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")
+
+            # Unlike the tests above, this one never sets
+            # `_can_accumulate_next_adjective` a second time, so
+            # nothing here ever tells the backend to carry on. A
+            # backend that waited for an acknowledgement would still be
+            # holding the second response; getting it is what shows
+            # that this backend is not waiting for one.
+            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()

From 5c2e773787a3f91b734450e771a21b435826f780 Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Mon, 31 Aug 2026 17:39:25 +0000
Subject: [PATCH 02/13] React: observe every mutation that a query response
 reports

Stops a mutation from staying pending forever now that the
backend skips states. Before this commit the generated React
client compared each query response only against the oldest of
the idempotency keys it was expecting. That was enough while
every state change produced its own response, but a response now
reports the aggregated idempotency keys of every state the
backend skipped on its way to the state that response reflects,
so a single response can be the only word a client ever gets
about several of its mutations -- and the ones it didn't compare
stayed `pending` forever.

Observe every expected mutation whose idempotency key the
response reports, rather than only the oldest one.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FMgyLgRtZXNAerHpSguK9k
---
 reboot/templates/reboot_react.ts.j2      | 41 ++++++++++++++++++------
 tests/reboot/greeter_rbt_react.golden.js | 33 ++++++++++++++++---
 2 files changed, 60 insertions(+), 14 deletions(-)

diff --git a/reboot/templates/reboot_react.ts.j2 b/reboot/templates/reboot_react.ts.j2
index 152879b95..c3d235b5c 100644
--- a/reboot/templates/reboot_react.ts.j2
+++ b/reboot/templates/reboot_react.ts.j2
@@ -910,21 +910,44 @@ 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
-              )
-            ) {
-              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.
+            // Both of these are looked up by set rather than scanned:
+            // a response reports the keys of every state the backend
+            // skipped, so the further behind a client falls the longer
+            // both of these lists get.
+            const reportedKeys = new Set(queryResponse.idempotencyKeys);
+            const observeds = expecteds.filter(
+              expected => reportedKeys.has(expected.idempotencyKey)
+            );
+            if (observeds.length > 0) {
+              const observedSet = new Set(observeds);
+              expecteds = expecteds.filter(
+                expected => !observedSet.has(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 room this could be a new message from a different user).
             else if (response !== undefined && !haveOrphans) {
diff --git a/tests/reboot/greeter_rbt_react.golden.js b/tests/reboot/greeter_rbt_react.golden.js
index e83ee8e2d..daad00650 100755
--- a/tests/reboot/greeter_rbt_react.golden.js
+++ b/tests/reboot/greeter_rbt_react.golden.js
@@ -1982,17 +1982,40 @@ 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.
+                        // Both of these are looked up by set rather than scanned:
+                        // a response reports the keys of every state the backend
+                        // skipped, so the further behind a client falls the longer
+                        // both of these lists get.
+                        const reportedKeys = new Set(queryResponse.idempotencyKeys);
+                        const observeds = expecteds.filter(expected => reportedKeys.has(expected.idempotencyKey));
+                        if (observeds.length > 0) {
+                            const observedSet = new Set(observeds);
+                            expecteds = expecteds.filter(expected => !observedSet.has(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 room this could be a new message from a different user).
                         else if (response !== undefined && !haveOrphans) {

From 15b992049a5b41e7eb855a8b416068ab4a3f492d Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Mon, 31 Aug 2026 17:39:30 +0000
Subject: [PATCH 03/13] Add a browser test for reactive read flow control

Covers the failure that got the first attempt at reactive read
flow control reverted: an update that arrives while the browser
is too slow to consume it must not be lost, or the page shows old
data forever.

The app under test consumes its reactive read itself rather than
through `useGreet`, which lets it decide when each response is
acknowledged: `reactively()` asks the backend for a next response
only once the app asks its generator for one, so a response the
app has not asked for is a response the backend has not been told
it may produce. An app built on `useGreet` cannot hold one, since
the generated client acknowledges as soon as its own loop comes
back around, which is before React has rendered anything.

Each round the test writes ten states while the app holds an
acknowledgement, so all ten are known to have landed while the
backend had no response it was allowed to send, and only then
releases the acknowledgement. The single response that follows
must carry the last of those states rather than the first one the
backend passed through.

Holding the acknowledgement is what makes the outcome exact,
rather than keeping the browser busy for a fixed time and
asserting that few enough states got through: the app records
every message it renders and the test asserts that whole
sequence, one message per round with nothing in between.

The test runs against a local Envoy both with TLS, where
responses arrive over an HTTP stream and acknowledgements are
requests of their own, and without, where responses and
acknowledgements share one websocket.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FMgyLgRtZXNAerHpSguK9k
Claude-Session: https://claude.ai/code/session_01TQxdTEi8qsBfxCcuLxrNmQ
---
 .../BUILD.bazel                               |  67 +++++++++++
 .../index.tsx                                 |  72 ++++++++++++
 .../test_reactive_reader_flow_control/test.py | 111 ++++++++++++++++++
 .../test_against_local_envoy.py               |  12 ++
 4 files changed, 262 insertions(+)
 create mode 100644 tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel
 create mode 100644 tests/reboot/react/test_reactive_reader_flow_control/index.tsx
 create mode 100644 tests/reboot/react/test_reactive_reader_flow_control/test.py
 create mode 100644 tests/reboot/react/test_reactive_reader_flow_control/test_against_local_envoy.py

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<string[]>([]);
+
+  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<void>((resolve) => {
+          window.acknowledge = resolve;
+        });
+      }
+    };
+
+    read();
+
+    return () => abortController.abort();
+  }, [url]);
+
+  if (messages.length === 0) return <>Loading...</>;
+
+  return (
+    <div className="App">
+      <h1 id="render">{messages[messages.length - 1]}</h1>
+      {/* One message per line, oldest first. */}
+      <pre id="rendered">{messages.join("\n")}</pre>
+    </div>
+  );
+};
+
+export const render = (url: string) => {
+  const root = ReactDOM.createRoot(document.getElementById("root"));
+
+  root.render(<App url={url} />);
+};
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]),
+    )

From d34a305eb93407153745e846bd5002521418b403 Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Tue, 8 Sep 2026 21:19:41 +0000
Subject: [PATCH 04/13] React: document that acknowledgements are
 transport-specific

Stops a client from acknowledging in a way the server will accept and
then ignore. Before this commit the `Query` documentation offered
`AcknowledgeQueryResponse` as the general mechanism and the in-band
`QueryRequest` as something a client reading over a websocket could
also use. The server, though, keeps track of what it is waiting for
per transport: a response sent over a websocket is recorded on that
connection, and a response sent over any other transport in the
servicer. A websocket client that took the documented option of
calling the RPC therefore named an ID the server had no record of,
which it treats as one it has already handled, so the acknowledgement
was accepted and then dropped and the query never produced another
response.

Say instead that the transport a client reads over determines how it
acknowledges and that only that mechanism works, on `Query`, on
`acknowledge_query_response_id` and on `AcknowledgeQueryResponse`,
along with what happens to a client that picks the other one.

No first-party client could reach this: the TypeScript websocket path
already acknowledges in band, and every other client reads over a
streaming transport and calls the RPC.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TQxdTEi8qsBfxCcuLxrNmQ
---
 rbt/v1alpha1/react.proto | 29 +++++++++++++++++++++--------
 1 file changed, 21 insertions(+), 8 deletions(-)

diff --git a/rbt/v1alpha1/react.proto b/rbt/v1alpha1/react.proto
index 73e66e5b1..778690ac3 100644
--- a/rbt/v1alpha1/react.proto
+++ b/rbt/v1alpha1/react.proto
@@ -19,10 +19,12 @@ 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.
+  // ID of the `QueryResponse` that this request acknowledges. This is
+  // how a client whose responses arrive over a websocket acknowledges
+  // them, on that same websocket, and it is the only way that works
+  // for such a client; see `Query`. 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
@@ -124,10 +126,16 @@ service React {
   // gets responses at whatever rate the server produces them,
   // whether or not it can consume them that fast.
   //
-  // 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.
+  // Which mechanism a client acknowledges with is determined by the
+  // transport its responses arrive on, and only that mechanism works:
+  // a client reading over a websocket sends a `QueryRequest` with
+  // `acknowledge_query_response_id` set on that same websocket, and a
+  // client reading over any other transport calls
+  // `AcknowledgeQueryResponse`. The server tracks what it is waiting
+  // for per transport, so an acknowledgement that arrives the other
+  // way names an ID the server has no record of, which it treats as
+  // one it has already handled: the acknowledgement is accepted and
+  // then ignored, and the query stops producing responses.
   //
   // NOTE: the service name and state ID is expected to be part of the
   // gRPC metadata, exactly like any other reboot requests.
@@ -140,6 +148,11 @@ 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.
+  //
+  // For a client whose responses arrive over a websocket this is the
+  // wrong mechanism; such a client acknowledges on the websocket that
+  // carries its responses, by sending a `QueryRequest` with
+  // `acknowledge_query_response_id` set.
   rpc AcknowledgeQueryResponse(AcknowledgeQueryResponseRequest)
       returns (AcknowledgeQueryResponseResponse) {
     option (google.api.http) = {

From f041394602970249aba8d0993c3bdfd00f5f913f Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Tue, 8 Sep 2026 21:32:18 +0000
Subject: [PATCH 05/13] React: rename the acknowledgement RPC to
 `ContinueQuery`

Names the thing a client sends after what it is for rather than after
what it is a reply to. Before this commit the RPC was called
`AcknowledgeQueryResponse`, which said "I received your response"
when what a client means is "I am done with that one, send me the
next" -- and it forced the messages to be
`AcknowledgeQueryResponseRequest` and
`AcknowledgeQueryResponseResponse`, the second of which stutters.

The mechanism is demand rather than receipt: the server suspends the
query after each response and this is what resumes it, so `Query` and
`ContinueQuery` now read as the pair they are. Renamed with it:
`acknowledge_query_response_id` to `continue_query_response_id`, and
`client_can_acknowledge_responses` to `client_continues_query`, which
also stops describing a capability and starts describing the protocol
the client is opting into, which is what the server branches on.
`QueryResponse.query_response_id` keeps its name: it still identifies
which response, and a client names it to continue past it.

The server's own vocabulary follows, so that the code and the
protocol describe the same thing: the pending events are
`_query_continuations`, each one is a `may_continue`, and an in-band
request is a `continuation`.

This is safe to do now and expensive later: the RPC name is on the
wire as `/rbt.v1alpha1.React/ContinueQuery`, and flow control has not
shipped in a release yet. Old clients are unaffected either way,
since one that doesn't set `client_continues_query` never names
either RPC.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TQxdTEi8qsBfxCcuLxrNmQ
---
 rbt/v1alpha1/react.proto                      |  91 ++++++++--------
 reboot/aio/contexts.py                        |   8 +-
 reboot/aio/react.py                           | 101 +++++++++---------
 reboot/templates/reboot.py.j2                 |   8 +-
 reboot/templates/reboot_react.ts.j2           |   2 +-
 reboot/web/index.ts                           |  41 ++++---
 tests/reboot/echo_rbt.golden.py               |  16 +--
 tests/reboot/greeter_rbt.golden.js            |   2 +-
 tests/reboot/greeter_rbt.golden.py            |  64 +++++------
 tests/reboot/greeter_rbt_react.golden.js      |   2 +-
 tests/reboot/ping_api_rbt.golden.py           |  56 +++++-----
 .../index.tsx                                 |  16 +--
 .../test_reactive_reader_flow_control/test.py |  14 +--
 tests/reboot/reactivity_test.py               |  53 +++++----
 14 files changed, 236 insertions(+), 238 deletions(-)

diff --git a/rbt/v1alpha1/react.proto b/rbt/v1alpha1/react.proto
index 778690ac3..6eeaf8052 100644
--- a/rbt/v1alpha1/react.proto
+++ b/rbt/v1alpha1/react.proto
@@ -19,19 +19,20 @@ message QueryRequest {
   // Authorization bearer token.
   optional string bearer_token = 3;
 
-  // ID of the `QueryResponse` that this request acknowledges. This is
-  // how a client whose responses arrive over a websocket acknowledges
-  // them, on that same websocket, and it is the only way that works
-  // for such a client; see `Query`. 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 that does not set this gets responses at whatever rate the
-  // server produces them, whether or not it can consume them that
-  // fast.
-  bool client_can_acknowledge_responses = 5;
+  // ID of the `QueryResponse` this client has consumed, after which
+  // it wants the query to continue. This is how a client whose
+  // responses arrive over a websocket continues its query, on that
+  // same websocket, and it is the only way that works for such a
+  // client; see `Query`. 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 continue_query_response_id = 4;
+
+  // Whether this client asks for each next response once it has
+  // consumed the one before it. A client that does not set this gets
+  // responses at whatever rate the server produces them, whether or
+  // not it can consume them that fast.
+  bool client_continues_query = 5;
 }
 
 message QueryResponse {
@@ -55,20 +56,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.
+  // Unique ID of this response, which a client names to continue the
+  // query after it. Only set when the client set
+  // `client_continues_query` on its `QueryRequest`; an empty ID means
+  // the client is not expected to ask for anything further.
   string query_response_id = 4;
 }
 
 ////////////////////////////////////////////////////////////////////////
 
-message AcknowledgeQueryResponseRequest {
-  // ID of the `QueryResponse` being acknowledged.
+message ContinueQueryRequest {
+  // ID of the `QueryResponse` the client has consumed; the query
+  // continues after it.
   string query_response_id = 1;
 }
 
-message AcknowledgeQueryResponseResponse {}
+message ContinueQueryResponse {}
 
 ////////////////////////////////////////////////////////////////////////
 
@@ -118,24 +121,23 @@ 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. 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 responses at whatever rate the server produces them,
-  // whether or not it can consume them that fast.
+  // stream is opened. A client that sets `client_continues_query`
+  // asks for each next response once it has consumed the one before
+  // it, 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 responses at whatever rate the server
+  // produces them, whether or not it can consume them that fast.
   //
-  // Which mechanism a client acknowledges with is determined by the
-  // transport its responses arrive on, and only that mechanism works:
-  // a client reading over a websocket sends a `QueryRequest` with
-  // `acknowledge_query_response_id` set on that same websocket, and a
-  // client reading over any other transport calls
-  // `AcknowledgeQueryResponse`. The server tracks what it is waiting
-  // for per transport, so an acknowledgement that arrives the other
-  // way names an ID the server has no record of, which it treats as
-  // one it has already handled: the acknowledgement is accepted and
-  // then ignored, and the query stops producing responses.
+  // How a client asks for the next response is determined by the
+  // transport its responses arrive on, and only that way works: a
+  // client reading over a websocket sends a `QueryRequest` with
+  // `continue_query_response_id` set on that same websocket, and a
+  // client reading over any other transport calls `ContinueQuery`.
+  // The server tracks what it is waiting for per transport, so a
+  // request that arrives the other way names an ID the server has no
+  // record of, which it treats as one it has already handled: the
+  // request is accepted and then ignored, and the query stops
+  // producing responses.
   //
   // NOTE: the service name and state ID is expected to be part of the
   // gRPC metadata, exactly like any other reboot requests.
@@ -145,18 +147,17 @@ 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.
+  // Tells the server that a client has consumed a response from
+  // `Query` and wants the query to continue. Must be called on the
+  // same server that produced the response.
   //
   // For a client whose responses arrive over a websocket this is the
-  // wrong mechanism; such a client acknowledges on the websocket that
-  // carries its responses, by sending a `QueryRequest` with
-  // `acknowledge_query_response_id` set.
-  rpc AcknowledgeQueryResponse(AcknowledgeQueryResponseRequest)
-      returns (AcknowledgeQueryResponseResponse) {
+  // wrong mechanism; such a client continues its query on the
+  // websocket that carries its responses, by sending a `QueryRequest`
+  // with `continue_query_response_id` set.
+  rpc ContinueQuery(ContinueQueryRequest) returns (ContinueQueryResponse) {
     option (google.api.http) = {
-      post: "/rbt.v1alpha1.React/AcknowledgeQueryResponse"
+      post: "/rbt.v1alpha1.React/ContinueQuery"
     };
   }
 
diff --git a/reboot/aio/contexts.py b/reboot/aio/contexts.py
index b0e678e8b..a37a8b8f4 100644
--- a/reboot/aio/contexts.py
+++ b/reboot/aio/contexts.py
@@ -480,7 +480,7 @@ async def query():
                         react_pb2.QueryRequest(
                             method=self._method,
                             request=serialized_request,
-                            client_can_acknowledge_responses=True,
+                            client_continues_query=True,
                         ),
                         metadata=metadata,
                     )
@@ -528,10 +528,10 @@ async def loop():
                             # See
                             # https://github.com/reboot-dev/mono/issues/4754.
                             # An older backend doesn't send an ID and
-                            # doesn't expect an acknowledgement.
+                            # doesn't expect to be asked for more.
                             if query_response.query_response_id != '':
-                                await stub.AcknowledgeQueryResponse(
-                                    react_pb2.AcknowledgeQueryResponseRequest(
+                                await stub.ContinueQuery(
+                                    react_pb2.ContinueQueryRequest(
                                         query_response_id=query_response.
                                         query_response_id,
                                     ),
diff --git a/reboot/aio/react.py b/reboot/aio/react.py
index ac138a0a2..1c6b6da40 100644
--- a/reboot/aio/react.py
+++ b/reboot/aio/react.py
@@ -74,8 +74,9 @@ def __init__(
             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] = {}
+        # are set once the client asks for the query to continue past
+        # that response.
+        self._query_continuations: dict[str, asyncio.Event] = {}
 
         self._stop_websockets_serve = asyncio.Event()
 
@@ -343,8 +344,8 @@ async def _websocket_query(
         assert query_task is not None
 
         # Events, keyed by query response ID, that are set once the
-        # client acknowledges the response with that ID.
-        acknowledgements: dict[str, asyncio.Event] = {}
+        # client asks to continue past the response with that ID.
+        continuations: dict[str, asyncio.Event] = {}
 
         async def consume_requests():
             try:
@@ -352,23 +353,23 @@ async def consume_requests():
                     request_bytes = await websocket.recv()
 
                     # Everything the client sends after its initial
-                    # request is either an acknowledgement or a
+                    # request either continues the query or is a
                     # heartbeat; a heartbeat is an empty
-                    # `QueryRequest`, which acknowledges nothing.
-                    acknowledgement = react_pb2.QueryRequest()
-                    acknowledgement.ParseFromString(request_bytes)
+                    # `QueryRequest`, which continues nothing.
+                    continuation = react_pb2.QueryRequest()
+                    continuation.ParseFromString(request_bytes)
 
                     # Look the event up rather than take it: the loop
                     # that produced the response owns the entry and
-                    # removes it once it is done waiting. An
-                    # acknowledgement we no longer have an entry for
-                    # is one we have already acted on, or one whose
+                    # removes it once it is done waiting. A
+                    # continuation we no longer have an entry for is
+                    # one we have already acted on, or one whose
                     # response we produced before a restart.
-                    acknowledged = acknowledgements.get(
-                        acknowledgement.acknowledge_query_response_id
+                    may_continue = continuations.get(
+                        continuation.continue_query_response_id
                     )
-                    if acknowledged is not None:
-                        acknowledged.set()
+                    if may_continue is not None:
+                        may_continue.set()
             except Exception:
                 # WebSocket closed (or errored); cancel the main query
                 # task to unblock `_query()` and trigger cleanup.
@@ -382,30 +383,30 @@ async def consume_requests():
                 headers=headers,
                 middleware=middleware,
             ):
-                acknowledged: Optional[asyncio.Event] = None
+                may_continue: Optional[asyncio.Event] = None
 
-                if request.client_can_acknowledge_responses:
+                if request.client_continues_query:
                     response.query_response_id = str(uuid.uuid4())
-                    acknowledged = asyncio.Event()
-                    acknowledgements[response.query_response_id] = acknowledged
+                    may_continue = asyncio.Event()
+                    continuations[response.query_response_id] = may_continue
 
                 try:
                     await websocket.send(response.SerializeToString())
 
-                    # A client that acknowledges nothing gets
+                    # A client that never asks for more gets
                     # responses as fast as we produce them; the empty
-                    # ID tells it that we expect no acknowledgement.
-                    if acknowledged is not None:
+                    # ID tells it that we expect no such request.
+                    if may_continue is not None:
                         # Wait for the client to tell us that it is
                         # ready for a next response, so that it can't
                         # fall behind us. While we wait here the state
                         # may change any number of times, and the next
                         # response we produce reflects the latest of
                         # those states.
-                        await acknowledged.wait()
+                        await may_continue.wait()
                 finally:
-                    if acknowledged is not None:
-                        del acknowledgements[response.query_response_id]
+                    if may_continue is not None:
+                        del continuations[response.query_response_id]
         finally:
             requests_task.cancel()
             await asyncio.gather(requests_task, return_exceptions=True)
@@ -466,12 +467,12 @@ def _middleware_for(self, headers: Headers) -> Middleware:
 
         return middleware
 
-    async def AcknowledgeQueryResponse(
+    async def ContinueQuery(
         self,
-        request: react_pb2.AcknowledgeQueryResponseRequest,
+        request: react_pb2.ContinueQueryRequest,
         grpc_context: grpc.aio.ServicerContext,
-    ) -> react_pb2.AcknowledgeQueryResponseResponse:
-        """Implements the React.AcknowledgeQueryResponse RPC that lets a
+    ) -> react_pb2.ContinueQueryResponse:
+        """Implements the React.ContinueQuery RPC that lets a
         client tell us it has processed a response from `Query` and is
         ready for a next one."""
         try:
@@ -486,26 +487,24 @@ async def AcknowledgeQueryResponse(
         # Look the event up rather than take it: the `Query` call that
         # produced the response owns the entry and removes it once it
         # is done waiting.
-        acknowledged = self._query_response_acknowledgements.get(
-            request.query_response_id
-        )
+        may_continue = self._query_continuations.get(request.query_response_id)
 
-        if acknowledged is None:
+        if may_continue 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.
+            # 2. The client may have sent the same request twice
+            #    (e.g. retried it), in which case we have already
+            #    produced a next response.
             # Either way there is nothing left to do.
-            return react_pb2.AcknowledgeQueryResponseResponse()
+            return react_pb2.ContinueQueryResponse()
 
-        acknowledged.set()
+        may_continue.set()
 
-        return react_pb2.AcknowledgeQueryResponseResponse()
+        return react_pb2.ContinueQueryResponse()
 
     async def _query(
         self,
@@ -576,23 +575,23 @@ def done_callback(_) -> None:
                 headers=headers,
                 middleware=middleware,
             ):
-                acknowledged: Optional[asyncio.Event] = None
+                may_continue: Optional[asyncio.Event] = None
 
-                if request.client_can_acknowledge_responses:
+                if request.client_continues_query:
                     response.query_response_id = str(uuid.uuid4())
-                    acknowledged = asyncio.Event()
-                    self._query_response_acknowledgements[
-                        response.query_response_id] = acknowledged
+                    may_continue = asyncio.Event()
+                    self._query_continuations[response.query_response_id
+                                             ] = may_continue
 
                 try:
                     yield response
 
-                    # A client that acknowledges nothing gets
+                    # A client that never asks for more gets
                     # responses as fast as we produce them; the empty
-                    # ID tells it that we expect no acknowledgement.
-                    if acknowledged is not None:
+                    # ID tells it that we expect no such request.
+                    if may_continue is not None:
                         # Wait for the client to tell us, via
-                        # `AcknowledgeQueryResponse`, that it is ready
+                        # `ContinueQuery`, that it is ready
                         # for a next response, so that it can't fall
                         # behind us. While we wait here the state may
                         # change any number of times, and the next
@@ -606,14 +605,14 @@ def done_callback(_) -> None:
                         #       multiple responses without waiting for
                         #       an ack for each one, which would reduce
                         #       the user-visible latency of updates.
-                        await acknowledged.wait()
+                        await may_continue.wait()
                 finally:
                     # The `yield` is inside this `try` so that closing
                     # the generator while it is suspended there still
                     # takes the entry back out of a dictionary that
                     # lives as long as the service.
-                    if acknowledged is not None:
-                        del self._query_response_acknowledgements[
+                    if may_continue is not None:
+                        del self._query_continuations[
                             response.query_response_id]
         except asyncio.CancelledError:
             # It's pretty normal for a query to be cancelled; it's not useful to
diff --git a/reboot/templates/reboot.py.j2 b/reboot/templates/reboot.py.j2
index 0bf4336b3..ed5ad612d 100644
--- a/reboot/templates/reboot.py.j2
+++ b/reboot/templates/reboot.py.j2
@@ -5295,7 +5295,7 @@ class {{ client.proto.state_name }}:
                                         __request__
                                         {% endif %}
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -5324,10 +5324,10 @@ class {{ client.proto.state_name }}:
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
diff --git a/reboot/templates/reboot_react.ts.j2 b/reboot/templates/reboot_react.ts.j2
index c3d235b5c..46c966ee3 100644
--- a/reboot/templates/reboot_react.ts.j2
+++ b/reboot/templates/reboot_react.ts.j2
@@ -775,7 +775,7 @@ class {{ client.proto.state_name | to_camel }}Instance {
     const queryRequest = new reboot_api.react_pb.QueryRequest({
       method,
       request: serializedRequest,
-      clientCanAcknowledgeResponses: true,
+      clientContinuesQuery: true,
       ...(bearerToken !== undefined && { bearerToken } || {}),
     });
 
diff --git a/reboot/web/index.ts b/reboot/web/index.ts
index 1c4c5ac33..c8e68e207 100644
--- a/reboot/web/index.ts
+++ b/reboot/web/index.ts
@@ -381,7 +381,7 @@ export function reactively<
         const queryRequest = new react_pb.QueryRequest({
           method,
           request: request.toBinary(),
-          clientCanAcknowledgeResponses: true,
+          clientContinuesQuery: true,
           ...((bearerToken !== undefined && {
             bearerToken: await bearerToken(),
           }) ||
@@ -421,9 +421,9 @@ export function reactively<
 
 // 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
+// since a lost request would leave the `Query` stream waiting
 // forever.
-async function acknowledgeQueryResponse({
+async function continueQuery({
   endpoint,
   headers,
   queryResponseId,
@@ -434,9 +434,7 @@ async function acknowledgeQueryResponse({
   queryResponseId: string;
   signal?: AbortSignal;
 }): Promise<void> {
-  const url = new URL(
-    `${endpoint}/rbt.v1alpha1.React/AcknowledgeQueryResponse`
-  );
+  const url = new URL(`${endpoint}/rbt.v1alpha1.React/ContinueQuery`);
 
   const backoff = new Backoff();
 
@@ -456,7 +454,8 @@ async function acknowledgeQueryResponse({
       // ourselves.
       if (!response.ok) {
         throw new Error(
-          `Acknowledging query response '${queryResponseId}' failed ` +
+          `Continuing the query past response ` +
+            `'${queryResponseId}' failed ` +
             `with HTTP status ${response.status}`
         );
       }
@@ -466,7 +465,7 @@ async function acknowledgeQueryResponse({
         throw e;
       }
       console.warn(
-        `[Reboot] Failed to acknowledge query response ` +
+        `[Reboot] Failed to continue the query past response ` +
           `'${queryResponseId}', retrying after backoff ...`
       );
       await backoff.wait();
@@ -494,8 +493,8 @@ export async function* reactiveReader({
   }
 
   if (url.protocol === "https:" && !websockets) {
-    const acknowledgeHeaders = new Headers(headers);
-    acknowledgeHeaders.set("Content-Type", "application/json");
+    const continueHeaders = new Headers(headers);
+    continueHeaders.set("Content-Type", "application/json");
 
     const responses = grpcServerStream({
       endpoint: url.toString(),
@@ -513,11 +512,11 @@ export async function* reactiveReader({
       // 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.
+      // expect to be asked for more.
       if (response.queryResponseId !== "") {
-        await acknowledgeQueryResponse({
+        await continueQuery({
           endpoint,
-          headers: acknowledgeHeaders,
+          headers: continueHeaders,
           queryResponseId: response.queryResponseId,
           signal,
         });
@@ -536,12 +535,12 @@ export async function* reactiveReader({
       heartbeatRequest: new react_pb.QueryRequest(),
       responseType: react_pb.QueryResponse,
       signal,
-      // Acknowledgements go back over the same websocket, so that a
+      // Continuations go back over the same websocket, so that a
       // reactive read costs no extra round trips.
-      acknowledgeRequest: (response: react_pb.QueryResponse) =>
+      continueRequest: (response: react_pb.QueryResponse) =>
         response.queryResponseId !== ""
           ? new react_pb.QueryRequest({
-              acknowledgeQueryResponseId: response.queryResponseId,
+              continueQueryResponseId: response.queryResponseId,
             })
           : undefined,
     });
@@ -841,7 +840,7 @@ export async function* grpcWebsocketServerStream<
   heartbeatRequest,
   responseType,
   signal,
-  acknowledgeRequest,
+  continueRequest,
 }: {
   url: URL;
   request: RequestType;
@@ -850,7 +849,7 @@ export async function* grpcWebsocketServerStream<
   signal: AbortSignal;
   // Produces the request, if any, to send back once the consumer has
   // processed a response.
-  acknowledgeRequest?: (response: ResponseType) => RequestType | undefined;
+  continueRequest?: (response: ResponseType) => RequestType | undefined;
 }): AsyncGenerator<ResponseType, void, unknown> {
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
 
@@ -942,12 +941,12 @@ export async function* grpcWebsocketServerStream<
 
         yield response;
 
-        const acknowledgement = acknowledgeRequest?.(response);
+        const continuation = continueRequest?.(response);
         if (
-          acknowledgement !== undefined &&
+          continuation !== undefined &&
           websocket.readyState === WebSocket.OPEN
         ) {
-          websocket.send(acknowledgement.toBinary());
+          websocket.send(continuation.toBinary());
         }
       }
 
diff --git a/tests/reboot/echo_rbt.golden.py b/tests/reboot/echo_rbt.golden.py
index 7c8507be9..f7a30941d 100755
--- a/tests/reboot/echo_rbt.golden.py
+++ b/tests/reboot/echo_rbt.golden.py
@@ -20854,7 +20854,7 @@ async def Replay( # type: ignore[misc]
                                     request=EchoReplayRequestToProto(
                                         __request__
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -20883,10 +20883,10 @@ async def Replay( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -21050,7 +21050,7 @@ async def WaitFor( # type: ignore[misc]
                                     request=EchoWaitForRequestToProto(
                                         __request__
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -21079,10 +21079,10 @@ async def WaitFor( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
diff --git a/tests/reboot/greeter_rbt.golden.js b/tests/reboot/greeter_rbt.golden.js
index 65f43f9b4..42c5a9189 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", "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/z97b9vdOG6tC373r2BcH2wlanaSe2ZmLZ/RPXHXS6fmdHfV2K7UPbdWLZqWIJspmtSQlN1On/7vgw2A7wAIiZREUrtXYrskEm/7BdgPHmxY3uPKJ48koC2k40bnxWVafnZZmE3LeK+4Lqx0wxJUlLbqvC64vMD0IZEsKhegwYVH+cPCqn4JF+S7O3f+jS6/syosN0nc+YPlWv/PtXUXeQsQ6B1ssdBvrGgdwJVutvWZUCuifYjoQCSiPBqpJQ/EustGDRKQPb6sXix3DqFczH6zwYQLAWkVaa1wfBIu7ltQAxWF3UqG5tY6J/a9bXkBL1/kLUtXn/GEG7nzzzgbMrjAj0QkmNcO6l0GL9y9OPnDTvaQ0MknN2LOBf7+hxt90R/YK7b1ayGrmLyw3BjOPkbhE9WpdIBAU4qDw8eVmhntSMJ9mBem5mNbZ3lBVCwBocOYPLhM3+6I5d75BP5chLQg3wuIxdCxmJ0eBX8f08+ZRhfKcbNBLdxgKKy5QFiYVEaQkYJix6FdzxO4Ke9o5O+ob2gUzj29qPFrWld2/SOrjtXW6h7IermOyR19/K2l5xPq5+J55K2oP9S/+ubt9eur9x9vPlxJrgQDn1lIAhevV9QZTOzs+0kt/x8XdWg9hP6CWV/IFOXRWyx88gy2SQ3wmWqOG+TiLyYA5IpAayaQOIy6bPbJuW3bk7NJnsfvVeGdH8jcXVMDP3Pyas7S489UnXz/xVpF3hNgdMkD/XwR0ioeiRsUCqEFUE/z6L5As1ZhHHt39LUs1IAXg/t4at2tE14IK996pPNNoRTf+0boa/d07mEW8kJNYk1H4sF9omrvg26/WCF12BHLW1h4U2S4K3ThfHJmV44g5182nvEVlvpz9kaaszEXc73G5vWFu1r53pzNL463uFBq+WX+3PtF8TIpmK20b16zR0ovMSt4dAM6k0eyF0sPCAv7mf8rL2Xlu3M2OTp8xpMVlD1jf0z/es0eLiywHtwgIL6uOWlCxdipPGw7r/kHtcaxu0SdOZ3liL7EwoPsMtr4NfxZKCj8RgKHDqBHY+Oo6T7e6kqs/HZs38C//yH+WTjvTdgVuM6T63sLt5RzX7be5Bfm/iN7uJwe9yV7V8wi9tunbMTZslGp0hdK8yhcyFh7q3Jzr/h+Vlb5uq7Pyv+c1kphej3L/pJd5Sv0YFb6V/nBqprOqh+UH69o2Kzy7/LDBeWZFf6uPFTSgVn5n+VHa2owq31SXShTec/Yz+IiubK+rwoz91h5pMCnpkJQYajh8lgjv4baPB3s11pcUvau5YHbtr16i9Q0wYHsrusiBYHaxDvqQgjEJFkr6VrUwOvfESqGiDdG6VNoLZIru9Nw0bmmhX8m7rerbPVbDVqli6bMi4hVqn1PkvPCTcs8gUqa/VCV7OSKBwmKdCdnPwPjOLivrmMtujz22GL1Vnxy+++FJWm+NKUO5yVci+THbHXAgw3YTgjpgoFHYf9xVuFKV6WnHqtym19ZNx/efDh/SJJVfPH99/e0lvWdPQ8fv+cD992CPH3/GAbh97RfNCL9/n/89a//5+TCchcLWMOtwihhseOcLo2gxSFdqURFd1dImJyjHUH4zPvm+s/uSwwu7YV3UUQDhQL4ap8vMGIeKgjx6TxsnXbMHSX9Krt1O7sD3a66WBrYLllVsJSzFt4iOMsT2LhCh7lZwgoUlnpx4vm+RWjUsV5l0mMd+S6dckvvVSvki0E3OYsh9KQBywIiUiiCXW4f8vbAMJf7XbSnWfEfU5O5SSgOVzE+ucbnjasi8WBhOS+//bfuCCrOoIAVbZYEOyLxiuoWaVqVNGTJricfz+Y2Zcm+FycSF8uvcId1FB+dr/KyqRPyQ6qmZOGsV1QoSUNFyXrlE/CHU9Vjdy906L5+ldQ3uWjIB89XyQAARQn7xzlHpKwvTdL4WvA40nCuCHBl0pqlf0z5GPOVw1QyKLP6R1se3uCqzT9KFbxP+tuY8keMGGroxhq6adG5dn4xlMphzKDNYQtuDsUvBmUUZUI+mkafTEMmm0MZyEknDFVuLNIn+mg1Tefo0U72aScN0ui/ZcjJRNwmKt+hNaA1DNEaOuBciQWV7IlhrazkvAtcYvVqiaUT0uFmFNZFtv3KF0evXd8HrJO2jCc5rrM3gCFwpn7nbGrNQwaZBsnsJlqTElAle++8XMdHdmlb6H9R1/G1IP+cOeU4gLE1m6WhHebKVkCwi0wKW93Asnratl0cg5QCzS9PP9nKtaSgoNIk0rPogqoxy944kYwc7MVIajTikaW9qd6nU8L9RVeLNZyengIFrcQg4SdoBJicUz1s+qw6G0sdyWd95/j0+aSwN2Dzkh3YBvDPJ7X3IFuJpLisyBVs6dHuMKhaWrIfhitJwVnhWTFp1yQPlz+Z2Ew4op6JTHqcG9GgMN6CztthQoL5i+MC/6qSbtyUNlgRd7kAfrztwthYvmxmVV8rE44TspkiLtCjik0GwJ3PJbF8U6nwwPlEO3WDm5fVkTG8mGeUbiDmjzifqK+W728VH/rl+u3NtDvnQ23nI4mWYfRouYF1WqRanUpMrTwR3ULHZ+yazVDMyhecIxc+egmdTqbWLRf67VkszLK8twMXCLjpHTzrmCys86XYcAKGH1CDWCXnMMFPaE3L8sA/kEhcYkC/tqs9qwnJSej81zTEdN4M/SfCFACGzeEN55N5zR55/6aseFWeI1OnVPYgNZvcwKUo3Em9yIo3kTiLgulPs94WjIt3fcaHV7V5yac2531af+K/XJR1ST29yT2WxAyLM5/Uy9QfF75Os1tdf+ehcMe9VIP+Hj5XNOFCLm/pBCx/0hWkWPZb8cwDu/CH/iyPrG4i72YyN5nQ207q8jRrjrxL9RGeSp9JjalgF/LChNxnEtpV/qp9+dPny/+6llc14beuZnLSOyFeEjfjjRrJ9GNW0Jmptj9ZgxSN1g7bVLI4KX30NxCuN+d8Z4VOOiql3MiOC2Mj5cYVhPQ+/3uqcnTbr3H2YQYmQWfmsb+Y96QaZwrqTCqKEndOyqPZhE+TEWPE6YNC2c/i9m9ODVnI6DQtaTUKfZV4SybPplhQPgpcHMrhS+9dko9g2dPVS7DL1A1b7QdL83deVIk3bjo4VBuKpsSDqAtdD8QIvYvCRxa5n/Mu8bGV1FBhybfmyNcqeGV9igkzvUJPLDGMsN58dL/RpdM6IuI0AlUpSSEROx8FcrwjoHmwWKSr12UIt62nHCF2Y5VdXzLCBfY1r06XRIqJrDwks8q/p5qXIrKUsKLkb8DBmiSje7kiXypQ8W+LxyRuVW/f8hdu6ZpfnHGif5JkbjF9z44T2YrJOq9BQvFK/+NV6B5Y83BixliMU4Vm8pNY2mrchZu4mkcKyjPzdDMKH5wPgf+SnXtYgX+6FRkEmCBvGdUubXwsH6PiC4qWTajTKcXy38iL1jlVnm30SxnfKr2clZuzbinjJo5P3DhxwhpHsfif+puczXjBhokW5gF5j9yt7+9BV71g7q8XzKgbCgkjj77h+nyZZJ3T0u5JAAEXsPLYZ17QUAZn68WMuXdbBX1urefvQ8ttKiMN54I4gYUALemf6zhpeOm2IqxbW/vCMg3mhauilZz9VvOvv59Z57/ROOe8Uvjk98nptKFB/DTPM0zYgTjwws9u3X58e+V8/nD1n+9++vD5tqGUO3Eyxw1erBW41HQ0wUXSqSqIGwqIH+rHZ+4InK1xgcY5B/8TLpta8cJdeCRWEnXJ6kdbZwHF0VAWMpk2zt7KB6DP6m95eL7RtpJmCaCb28veYaIKQxUggzzGb70i3z/yuGv0UQF9HA6FzA+akPk3h7eDvubTYmCLRx0hbQVZCm+4CfYoXcDxFXYzAqmqPMUkWaU6JHKH6KMegayjkAoURWGRjc5HVC39rggRnqj8EnQXzuaK4ZG3INOqWf5nI/ZQQBjQ3+zM3wj5NbsdA2+xAzexDorhFUNZNwLgdDgTLe28F6BipZMHxwxPDFYRKh+UnQoM7h0iWDZbo7uNcdkefRv/u5WDqyv0rPxPTemr0AuyjCV2/pHM1I1B3L/pDiEXoKpH9+WOQJJTZ7kOeAb05Bmi/SRM5U1SaWt9uJF21J+RuZchY8w4w3Qyw9TtSfVUbi9Ngn+dPbmD2cwE9y9tzH7RS0GG9+Pewg73FlJccYOUC3z0f4xW85/Fy+UcHZXxLIi/iOXJh7L8vJ22rvnFYl9oa2SFSFtXrEFdeqHkc8kgPjA4S+5jxHf23/lvuWZUDhSnk6IudcP2qDoHlaAeuS2y7+zX7K/3bzRrtO0brUCWUu9ZLK7wmRbJBojgNn84RckYjK3aHijhabdsYFimLbHLQhTvpaA46AzL3Lb4PiJzSI9DQ3UwRMV7OYwYz0NmZQ2jkD4/a9xGs+svKV+p7JiVBoEv1ZVYe/PSrGQtf5qlpmHTddU99RhO+p3MjKq7BA0uab2mavrp0/s3X7vezmq1v9eVmdb3n1iugGABxsWSjpWykEV24/bUVu+nu1d11Ey6ebVlG/neVvpHB/tb9Z2pTVsm37hSzVpu8HKefPnzV3kQn1rB+zdv6Xc3b395/V/Of779L+fvby/fvL1iW0gJJKdLB2CinuT4YuMfrr9uWmrwHZc3IZs5wT2e/bZpy34/y42ZLjsiCHFP1fsFytHR7OkZTOd/mjVsxZ1v2i+4fbK+v6TZ71B0jfkZKRdiHZN04alBWngjZ42rBnsZhY8VB5rpirrVHTMXpjpRgZc5K5nUWeP2EbdO3YqdByE6TISZKa8wfU+tUq8sFg2BSj7nO3Nsm27FKccs4yNVz9Tv/UFdlqYWyOkZ8oKcO7KE5K4ZjeGscO0a5Pg7n5ylG46aEr2lWO3TV8B8wGW4VqGolBzB8snS3p096YpLu17sNSkVlzzwfDOLEPLR8O3U8ES7ZxpSFSu3aeVGiTf3VvD2uXvvesEEyoSdZYMiBSJXaRmjbfNjROr9z3zOd7LVWpMXMWc28SCeDpwjqUdfSQ6UpNqqfXyyqUeqOtxC/42cboGI4ZMC4Tsvx05Hf2L9YWb9WVtS+mjueapJcp4jGi8QcYnuD3B8jk1t5xOjcu2PLp2TYLf3Oomocenb21Qkw3Q2Q0Tyjq28+Tef2H7oLuLsfJ39BJ3RiEqIK0eFWC5ZEJMXAxXDBYKKAGr1m3T58xwRKQBVk8lFo07yZQXMAAarinx1wQ4JLsTgscRR0Iez39JThixltSOyy9LVBMxj1pmYH6xTw1qE5tLiya8rMgdmjKhHOyTg2dykPhy/n/079/mApEDmwXtaoFlbTsEZnUFhZzxKhCJ4oyx3CTdl0YLBy/O4kLpDXud/NBffoCXCGfLi1I9yfFq9Lql4supcdGLut/RUHGnlPHnjwotXbkJVPtIXYUAuKy0CCn1p8m8bjdFz5Yq4LoanPEQl4usmL249tkUC2xuWAk6sicSsDMsXYD998wLGBUvzSfKZBBYflRTI6kr4sMQ8W98zeBkgGzJCEwj11kppCktant1YYJbZskElMsA+14pZ4W/9i0yfKtyhaTkZqrgZz8C1voI0+Z7r0zaztQznKeb5pCFnNEzZSeqLbBMN4AUuMtZjubF2VuVNKKZGI/+2gLnv0Qu8mK7bNDH/Bo4r3TXJm7oZSUs9WWdcT2Gh/Mx5oS6DkkRbbkLeksLLU2vjZvViJt96Nudz7dV2Uzm139MNaul6Ojev+3ThLdisnaXYBCRoHkYRzOF8av8Ps+JMFJ965U22VqqJK6iKp3ghfNdcoVi7w8PFBf/UMtOB02vOXBW5UjmBlZfGOGXiWlD6WYa135524SF49JrCFMvT9LzSb1C3Xfj29zJud2pkleUTIoxTbRoMyRr4p5nFTyKXyDe84LNT60+S+v5knZ41DxTxK401Bss2ayotdgbtrKBgUJ2BrKTrD8GoAMfj1NJpA2MwejFTQT+8h4zg/NfU6JUikJdlFDddhlVGbFb42+zlOrtjVv/IrCjtPT7KlwpsGsVe/5ZGKYAsAIDYAZFCQmRxQ4bx+m8qFjy8NBExcYaqBgMqwktsPRrTHi7WcKyJuco/mPpDwDKyjRf26gSQ+j83j4GQnxQ7lacqNlNzvlgxn5lfWR/ZGR2+ZvaWhaXkgxvDoIrV4x+Mi6ycnOHch/K68g9dLSzbLDCbwbC6H9XtYhruRqtAp9mGUJZxqxlYNCvjSYv14ypOl19d9cbA9AUYKol4IGH7yqdiPBemYbRel4IXQKMrJYPg5/6bMyAIvkllNVw+A1JC8EoZjOxS0gf1Qe9ZE6OTs1QV/FQ5jVZ+BGeqSlKRjlB+6ufYhuj9zdury5v3H36ZNiTyuJSc/D09Pf078eEIF38IgIsVuyGMHaYgCSB2bAeMfcVPZ9xyZI/NVLX78ryogF/wc5LwYh723bLz8QfOI7JRdo+eZuYo8bFbK+xGSpsrrhpjatJdFUdemR6rPPp4QKQdfbcTdutoVbAfp6v4abXGAwiKc/OVWVJkz6tc/bfZnMenkC1nuy3vjEhPLLh3c/p/OnO786RwsKFw3oC/prr2yMgHyOkUhjfoNt5TUL031/Big8JtUAy2/CVM3qc3wpIFAzCNh5b9c+ORZW+1Gdh2VxPrD0JvMK7i+e6HVXK5g/noFl/uofaWrxIwHmvZDQRdDvlNvlfVavQV5bQRRKHI45HGy02YXR0uer2FLCSlHM7vGGWtZ+Pe8OTuRvrtr/zwXjcjXikNR153O8k7kswfNh9wSSE9nFllzay7m8MNfulqmK1H/3OFubLvObeXav4jST4/hD5hjd58qVh8u49LxmL7Nl06FtMGth/od67nf/aSh7e/zgkLDDce7FoJ6LGlI3zJmXJbj694H0e3NLopOLDxsKYvtnK8KrhuizFTGn1ayS5WzPIbncwHsfJ+DwPHSgsPunzQ3Rq0QaQuK6WPIbv8ahrzaFF3tU2XYgGv2FoqskJ6uPKQNXMDmchf714kWTB4GSy6sZrGEvuKtTQ2fBNIt7msDWR5csL3a0XXrmks45MEECyOvJ9LwPyJOJz7N+pvVyRKXk7SrQE2TtWdAdNdgXP11eYnLaH/V9YNy00KSf2e3WgRW0CtcBPvzifWYh1lOZtJ4D7CPzh5imWDznJAv0oP/vE8p2dlXT2bZvkMAvJMy1/wHNLi1UVIGHXISyXAWOhUz7yACh6KhN2krLXsuACrnj5WrkjQQ9OWejE0VtD5c1s59BZG+r1qx6L6fVVlX1lvcrE8evciaQKnQn9047nrv6aadAYjdxYHdKScOft3JVXVKysdp8D6+EK/CjLNiqf8XIDvs0pKpTzRr4uZHViOWDquLiOVU0GDjIG4CPlgaAHsDCpQ9ji5GRL534P8RA8K5XDFUGsjsCNiON8JKW4Ysx3OvNdvCHllQRqMyFsQzhYsDYpovvUdqA9rYPpwrpMllYZ62HP8wGimirW9WbYvN68ol3IzMy5rR0FDpnWT3qeJkl+BFgep21vYaW5t8x1bm3kC384MsNsdwuNzwAfe6Uy/V2xsVr5G7zsg73tf1qwjdb5d2Oj9kG10J1yD4/PT/eBMZN9rN+XlT6HzHpDzjgnVm7q+Hf0KWjEuPVpId2GauyYrHZ/77ifpKv1e0Tq1+ihfQCc/ICdfyH7hoMOXO3yDMRqp6e6WI3mMU0CvuJ65PkiapVMf6ePo9wfl91/gWot5KkV5XlIEa7Yy8+bBHZel74fgfezTRW+I6nLtqDTPVKlqr+E0MuRphAhx4nyyy/lEPcrj9gU7Pc9yhPNLr87lZDphdAxH/zROIkOaRKgIHZ/K0BGZBJ1lWRNx6th+6mga2zFZ+W5P3B39/HDok4MKZeCFGutO+jhOEYOeImQJ2I97l6JxiHq0Q70bE97NOeAjJIT24zxzxirTH19WPIb+fUhEUZI4zyA8nlAWl/5dUEZVYzpsO95dDoLjc/Q9yqWQfl9rklpRJI+i0x+Q019S+TlwDYFD6vqHjn9rq9aO6zjseldpUo53Cjh4upeq9EWDmtUkexCd/yCdv1vVPHT9Hbh+d3z23Hn2pmPx9n9jiTOkiUrqaanmftx1VqpUwnlqKZUOqJNPoTPvpzOn6mI/15RI6cJH5K81VvU8FKvaVUq341tH9yY1Xfp9YyY65YPoege0jl6k0nOWFcU7+h1R9dD0aCe0OzPdbcLII0y30K/El/n3Rkn5Gh5HHz+kTAwgQ6pSQojOY1UXMSdD0wj1KTvDTgx4p3lpj8/59yu/bvq9WTpd/dPo+Qfk+eFaSHT8O7HwpqEdk43vL0P2EaYv7nmm7yx76uaJvTd4FWeVISVFzg6S0vccjC4acyZvNl5HZOa6dP3bZL8/qpttX1mfI3fFHQ/zYtwJLcgT8eG2grM41Xfq/FzrNl65wW2m417RDdC5CSyBLKw1u4XeS2Jrufb9l+/+v7Xre0uPfiPcJ3i93DkAV0AyhlAYLceGKiVXH8OQOVDQbHkqk+352W9CCjZ/1lv8fjY5lVxfT8tPC/pN3YysE+zyZ/YCv7rhdzG457LCfRjImbrUGxixn+Ah+/Wn65sPP7+9qheyYqPmxCsypy2Yz26idUFbKrdKQ+tgUclUw5qlOlbSmHd0CvwIt/+ci+cmmoupy6pzE/IXa40s+PbXkoT3Rrd4S5y5tFuSO7crN15vk3X9eC5eRqvvwOq5jvTa6Ivq0mjzXEnoy7J75qlV/1hPpN6pUU8brVrto0p6nroo7pHSjk3aJPo+8lvD0V904C9KitNrtyHRoY1WDDJlMlk3yE2rx6sHfXppvOwenUjXTkSlSL32J/rkwBu5loa0wSZeptEWe+1w1KmMS+6mVzl+d3CLMjqTTpyJTE167krUyWNbRzgNZtOriEebFrdtBGSSClfpbnqTIxbdzhDcTlVdBuR+5ClGO3ZDSnPqsTtSJFFt7ZbUiVOL3qhXGUWVwZJZ8kH0THv1TDLV6bdDUmtRez+kNaR+uR9Nbs6OvU4pH6fa7Rw6USUufgbhYoSaDMnHlBIlbgbe6FIoGkE3ehvr8z6zJKljcb+5H9kO1fvI+rRpTScR0Id0u/Nc0pZ+70BLFKf9TrTcWvq1Iy3LINh2KaLKGljwJD1Kp4dLkH66j7qK9NqFqLK2tXYjGlPplStR5qLryp2U889JnMnBE7OhK+m3K0kVZBCOpJwFrDM3cinLIdc7J1LJbNbWhVSymRV8Rz2r1xYQSGMCInPHoIxRdPm+0EW0dhGZHvTaN1QSWG0Ea1QVyATJ+CxNV2bkLTZ0CS2zaBUsujfppZSm3JjIBlcH+zT9qsL02gPIdWcjR6BIj2TiD5S21WNMU3cGu0iY71cOIzV71eyk4qbv46JiF1x6qU71m1SvUa/N2PU6PTOi2esNssceR5MeqOBw+pU3R+kvzJJsbPg6epsdeBupQvXa2Wh0qzXeoTevXoEeOhtpi3yYZqMpphPoeZoWdfaAzRM6tCkLndgukhQ0Kl+/8xcYquBmqQ1MddEo64G5dR9iiXVywnLF52c0eTKgc/HvH9yYpJ9RibDXHeE3hPhFS5/ciHk/+PsfbvQlq0k8RhsGmvGBbVW5/peS1/nKnv5K5aotNB+qMzrwTyxDkTuf03EE42fNYlmOiDt/YD5hank2safgFyJiPbovLDlPXsrj2k+8lU9YyjUSxRb5lUpH5OcJqJwiEiQ+fWud8EIfvfuHxHpwn0rFuNbCWy4JPEzdDDTj9iwXj0juNPslDITQsunkMqC+ib4QzIkVLoX7iqhuLCwulqw3rFTud5z0lfiC1jtPvlD9mlYFCGP52++8HjbLpC8xw59aqV+5oH9FBVvLyi6e++VF2nnFtcfp09mXcGXmeVp+rnHeMn+a+lsYjbKJF8piluM4bAwc53wifc52Hr3FwifPbpS/k39U79KXtFFfC82tJqPKPuc3KawimEqSl2wg+Y2VzHuWc6GCTZSnVtkQcjnCCJVGhj8vHRaeyOhqHUDaLpbBqO4xToXWWWlzoagwoJobEeqr3SBhMxWfB9PG3Irp8VSxcBIDwkoWo8FbH5MkEfnCyiMyheRljmxZMRnX0PCmvg5XLzCxnGe9nmyXW+oIUxPuKoVWPeuYIidW9XtMEzikNIGSVFJjv9SnkPSv98bTwXX3hQxcR3jN/Y4SjdUvvpZnDqt8jb5xSBfW1xNyHY9rvO+34XRwEU49odAR3n+z22Rr9XsxtImP5E+hzxzSNTaEaoY85c/x+E7FIPTbrNp7VH22tuNzrntOSlfTCn1aMImCNCT/Qhc8CBec5FJ00B1TOzQYkMFaYhdeW53y7hh99n4y+0lURJ14TaogmvRk6KgH4qhfnISpirh5ZC5LQXVMfrppPIZmfl17Z3mmwGP30rtPiNigLvI8dY1qo8jiht57mN6bCHGiGzcemKEbaAf+XZ1y8Qjd+n4yS9aVxShVpP5p9N1D8t1UhI5PZehEXIjOsp588Yg8dtNwDMv0OvfKpZSUR++Wd5Z5s0k5SokRm7WjnP4QPfNAPfOzJAnlMbvm54GbXweMNkmuzyNktu04pWmdqKPPUap4DL3vkBhvJHGeQXichH+03DfVMPTduNr7VlUG1OPzr/tI9FpTA1UuTokqKLNWoq8dhK9dUvk5cGDKIfL8qMfjb7VDMRRj6873ltPFHq/n3V1WXKUqlFOXahShkuYTfe7AfK4rSyZ7jB7XHaKRtfe1lby6x+Jk/8YSARRcTa4S9Yypcz/uOp1wKuFKOliJDuiyBqOH7aOHpepiP0vT7o7dr2qs6nkoVtXepcrzGx/f8nX3aZxrgm/My6x8EJ3rgJavi1R6zlKSxfh4Vq/qcRiCiXVwdFmTDvEIzzDvKf91/dSlWabGhsfRAw/peDPIkCqNEKLzKMs8eEQHnZuGY2jG1943a1JoH59r3lOm8JpymKX+1j+NfnlAfhmyjqJbTs2uaTSGZXjtfbJpKvEjzB55qIzp9QR5m6dA3+BVdOZDykmZnRyj7zm45C6nrNxscEZltZqZYKtswcWrI3aVCbT11RCKxKGNL0gueSBW/BCu/QVPu+4GfAA8qqhu/I0ZafKwjtPeWisS1W3oleWT5Iw9tPSiR2YQtJx4/ch4MeDIhGOK11HNH9w6pSTUt7kboEWQKNHmsk7fyt5RPBynWdPzNNNJ9FJOeN3ZlRctr72QpmvPMsxX764op2/f6sqMbq/NaHl1RtpRuD6DG6Cqkk7uyWi+K0NyX4buzoyibUouxqiVU7kdo2Spyisw8mswsnz9ryVZm43vvDC4Aah+w0X5k6UXUKOpmJTGGsFqJ1tlLC646F2l8m3roRUJTJueR/+M/nlA/plb36Dcc9EwN/fOJTPdxDn/WE8bPR7fLEnsWbyKdrfphFvfQKvNvWf4Gvpt9NsD8tslkxyU+5ZY6+ZeXGa7mzhzuUcbl0/X520uuPc9JzRGd4/uHt39Zu5eZaKD8vz6dMmbTwIN2ZQ3mQ8aXeDYpgZ1cujSxLCfrMmGM8J9GN77xF6BVO/WS5tQp/rCfPtb+KswCTQ8iW4f3f5A3L7MAAfm9NUZmLdx+ZoEzZs5fK1rG7O7l2ebVrr93adhRveP7h/df6P7rxrigKcBeeLmttOBIq/z9tOC0vWNbHpQJ6suzgr7yeLcFh0yyzyLMwTOEKOYIWRGOayJQW2vW8wHmkTSG00DWl83au9fSoqtdv87yxaNwQC6enT1za5eGOCQfX0p83RrZ19OTN3C23+WZCYfEQtTkmW7yMbccfrp1qxMfUJdPTuTROjt0dsPg5dZssNh8TMlJroFT1OWEnsjvqbck43Lm6vyehc8+j4SXuOiHd04unGJG68b36BcuSqV9ubuXJlpexOXrnFl43Tr5ZThEqe+u1za6NLRpaNL17j01PQG6dDLubq3d+eVVN7bOPNLWcr28bjySkbygg+vZ+beAkRvTCJs7qCV2IkuZ3dHzqmFY9rGKW3lkLpzRt04okx/ZFV04n30nqfidRQep5K8usnVlN1MVfOU/qXiWz5L85UbOZQGZ1J2JJOWWbQL3mD36aXbQq+NqXJxhYcrvDGs8KqmOKgVntxKN1/hKfJdb7LCU7q0kZ2d16QeLB6i31M+69bHK83yfW36Ph64xDlgSOfrpdY6rIP2GkPe4sS9zqw3Onqv94Pjmhs0acMLU8Oe8mm3nRnMsgBv+DrOCzgvDGhekJrqoKYFjRVvPivobHqTSUHvAcc1J5imLS+msT1UPu/WaW43TyTcpiycTHAyGVJy3EazHlbeXENj3yKlrqnpb5Rt19ypDmQCOjl5pfnPeu17JKBGqnvo5JV1A3cnuNQFZI7huyXTKou+Hb2sQg8KgRsH3ODFumLKxzps039QxXSDhGXPD5MHWtpcVAqeNrtDwTp/fgip22AXXNBnaX8XPDe/d/+QZM9Zdy59BIqOp9RZWs/E92mR9K9wmRDqdwlLwC9qoO8/Ul/yROKJTUfCukwSd/4ALp/8uvK9OVTlpVck/IuOGNR8GrhU4KfW7YKOJXxza4V3kP0ntq1L2bdpen8+ndBqsuJs63pN6xOvW27Emu6Bq32hWkdFt6JaTZ0ibX9E6N8xCdgNAn5In2HlTK27NVwWAPPVHWHzDR2kBa0FhjstufTyp5vXNhUZdcYPxIfZa7kO2FxuLbzYfbzz7te07THMUekw0Oa4bGzSGxFYA4pdgZGpjwifB/itCa4Pt9G8ZLNqeYj5cLxfstJrBZ2wuSMtAb6B57+j5hkRdrtGnMClErT3TzA9chUJ15E1X8dJ+GjdvqEF3tDXgD4Av/83TKtcBU9gvUQCmIedBzd20tK5Lf+RmyLcoZItiUBG1GN+YFO5638RH6eNzv6w/tuqfgU/FsRP3K/UCYINTk/YEkZfsnDXrARZT7QVcZfgLekIZjMmdGdqqdpd8N/CqRq2w4ZrU7JiWC3cQ4li4APqcoRbcj5RffRfU2V373xyQ2VBx6Q8EPDhP1w60SpfOaNOjF26nDk7+h5de4UB70Tq+y4kJV/6HjWsWe3N9J2TStEX4naJTcrMimJrgKxtG7SGv/p2uQSDMnjxB+oBM48vXuNlXK7pzB15/zJqef6w6DRf16vfazpIw4spZcrfqrhSCaUyxVq+TaG8CN7UYtbo7TtebGg54XuLIovNlCTG26poSTmS8lu0XVYQ74I+zV+nvWnIANh5x9SprHRVNfAidGU396OpcEnp8uwr3fZAkYulfU/U6QK2kramPE19u+lM6Txsa3HoTse2brnsjNd2LlBSkKyGtl42nbFUJxraDrfyfEProZZTdrtqb4XA27q1Fbpf22bWqKfbKEC1EN5SOVFmqwrkRclr6WicdfjKdtOepkBdjW1mWl2JvJuazYqtqtSUp6mvRR91BYo1tCFqtt1K2LBw05a0WZSbls6HxeHwVg6cOk4eUBYRT0CH+MYENOMXgFil+O6pQBl5EMhDhBs3/paHx6enp1cptBLD7ZnzB7JY+2TB9woiPpMyKKZ4OyeH4eD+Qg798+0B+r8gTGgp85Caf+LRuP6OzF3AvJ4JB4eiF1pcDteHHPF4YaBJTB5dGh3P47RIwhtRAE7S9pyHUYHY7vtWHMKeBJnYxZ7lEOvf2AhUbjzl9wsnkUeqWa/nfjyVXcqp3VMSy74cyig8RMTS0K6sEcu1/LH8T+i84y3ySu8S5+kvrr96cP9iw5cxX87Rv94vlBx1gVzQLqXbDNO05Jn4XcCi2dab4wVe4jjlMSlvsg1uUACjAriquj30hqxIsACdogrEb6blLQYjs2DnAu6CBSRynbA/3RT+dVcA/7HbdieVQp8BTX6Bt+AX2MS3IHxmxRfest6/YYAhfZoDjOwhD+QDMFO5SIYqVgbKvqdW+Oy+3IqrdcHkH8HqvKS88/SqUhi/bdnjHV6uE9jBo60gv67YnbyhFa9XK7pIsuZRGMffFdsM0G48pe9WihS2+ODNH6w5g7CL22xsHApY7Ar8Eey4BZUBkZb6QKLKVhrfPyu8WlQJPQaZO9DL/PX3ixTOLO/YlTDHzHya9V2ygSRrMq0z3X8rfyHp7PzBDQLiO9RH0okjKrxa+UbyrjAamKr4XwXPSNdcVEBi7Zm6APHYObxehHe11ib1O6UGVP0M252ijqZajZDgjyQgkUvnzS8MaOZwc37rbgnx+lqunXr/Syicb9qwaYTvuXjxA9uX4c2L2Q5uJMqwYc4o7Z5ldATWUFoU68n5dtfWZn6TyyvbBq7IDzbBs8+SkK8J5PtyZkuDkgjsfIkxmW5e6BVZSsuLyHIiOzkkOVG2vissaqT65NxHqzlTqviaPn4uBkNSWm2/Pxtj2OyXrZ2g/tj+FLjRyxWb+xcAxmu2Pem3M654wGsovHNLv6P+kAk7JxhQfYLhUZYH9Tt8ITKDv+3PVLPUm6r8Sb7tfgqPnqqfFVuvM72tQiFiBXyergNKEp1oW+Mu3MSV7MI/MP5lbP+d/1YPaE5MoDoz61DZSoZb8qYzme9VFzCxqdWBCjppf8811bkcTWDtLnfHpt2xxdf29UuckEcBPah2x6Ufl1yPk/oqqtx8bx+0rvYeYZCMZdgc2J0lcPm43JboLMi+tdm177PMqpiVgqDW8Wv6jf3Lhxvn3YdPv7y5UKsou/bcsFl6HZJpOWsmV/NPAaymghvmrtWitmDDj0/8J8oG14fXl/l1boNcPA6VFx/ShlUJRz6cFPlw3IDjHpfBi3RJkgkl5uXTZ965fqxovrdUqI9da6j9GdZuHwISLs9Pa9+eTkDw2eenGhFXX6UtNG5D+om0dPWoVwYECD27aR/7KR9qQWyrFy+iYqUkVS/a2QQ+sf5Ax/70RKtx5puD5xOlsqhNDrqQDTFfQOnbm43im7fXr6/ef7z5cGUDVY7NZXL/1we/8T54cn1vcRndrx9JkJw3TDSPHMeZaR9anrIFKOPxffr0/o2V0ufWazqnwSfndy9UeOV5mM3Z7JHJ79ZpQwUPLqA3mS6ESx6/nv2mE9PvZw3lngI1h0eFjDfDijTUsrN/byocAKGXcM2sTwTgLl+qh0sRikcRBKR8EfQfmqVPox9nkZyjmeSqU3nOIxD9Esp1onz7lfU+SLGB/zmz/mz/25/tvxbDatojbj7AFAMg4VbA3vk8eqteOHpLicm9j8/L8wisWmJWlICb4c+CCWpsLF2YreN84awrVTOtSv0snZJX7vzbOS+o4WVm70V5cGYOfzcrwkgW/3cmCrEnAvhiFD6Dyi3I3KdquOCCialYgNy1sFZhGPkv/64pPwNtXO8RBEoe1z5jPCeiFI/2mLZiAStOAZKWgZ4inlovn+pcTA1CAK98KOz+rKt0flEhF/30rVSX9IuJ5tUSb7bkhYq827QcGUxRie/tHJuYFGk/W5KYSi/XIflULmr5iScmKYGLEarE4qXclE8BXV5+OVEG9KVif6SGzYqZGr7ATaryyte8TT+/vfn7hzfOx6sPNx9++PTOeXt19eHKufmvj2+vLyzfi5MvYMuqta+YTG2xOfIVFsBfZNV0WH7ZGDTtt/5kOqhXH19v9eLV2x8+0BCq8OqJxKTSsOJteSnKT9p8FF3tkW5k7RZQRiYN0Q9JwwudhZDzQhFwFotmAlXGWnESfd1uj0M0cvNxqmxbmLQwI9RWdihCtviOidhlo+vTNWFMVECA+f4iO4sSWGG0ILC8qJTAZgfBmKb/CwP/BYjoC87QZrT7enmVMtj6SvSZbwLY9YHi4E21k9eANgVzwm1TIm+JITYa4wYGWD7aodwoi9cruFzAzlSjMlPwxbkQZBqaS55Ig0oeK8pKkNhB9vyJCRTLQ0b2DwGQlUubFsVR6QYHcXhb7gsLO/jcYYss9q603EpRdEnKShPnteqT+yvr53Wc8MWuWI2lp25gcyxbfYkjWHzer+PlvMUK1OnyB/rp2zcySYgX4ZdelOV/025VPsgjeLaKSa25aRclH0i2YcCdsmaXpKIB8kIrIsmLlxiWpi6pFjbVDSNZ26ypCERTZ1kQ8irE0Kq2hEoOU9u9qoRUDIBiXAH7/iIGujAJgSoeJLVkWgxfMnN7qpewIInr+bE83946ri+toUSZH5yeaBbeBf3mYWBBwX0SnJc/nVj/0/ozV++6Z0sh4KIpXKgOsAHVQLihFB4Rv0t+aabqVKUbxqPKtVMWGgqIrY7HSfbFz+9I8DC5sFw/ZuwU2PSPrHuSJOnRIQYPAIoVM+WplHErhlXI+JaBZV4w99cLXgCcKw2sWzEktxA8PrrfSKWYBblb39+zE2hu7NEY4uRko6GemKo+mwNgaoHf3KUwMyh9VF6CwWR76YVXYuGjJpxI9bgow3rdpX9Jgsy0m6Xn0sGuRqUmg+CBOfJ5qNj9Srf1kQRzVHR686UjUcDnC6dxkIeFPCzkYSEPC3lYyMMaNA+rdKKvRzSs8llFZGEhCwtZWMjCQhYWsrCQhYUsrAOwsEoLEiRhIQlrFySskpKNh4PFfiMFCylYSMHqPwWr5IM6YWBVwXNkTCFjChlTyJhCxhQyppAxhYwpZEwhYwoZU8iYQsbUOBlTxQSlSJxC4hQSp5A4hcQpJE4Nmjgly7rdI/6UNLs40qiQRoU0KqRRIY0KaVRIo0Ia1QFoVLJ1CbKpkE21CzaVTNfGQ6oq9g65VcitQm5V/7lVMo/UWZKrYuFbprqSFKEC8pHEhSQuJHEhiQtJXEjiQhIXkriQxIUkLiRxIYkLSVzjJHEpbq5GPhfyuZDPhXwu5HMhn2vQfC7F/IbULqR2IbULqV1I7UJqF1K7kNqF1C6kdiG1C6ldO6V2KWIRZHkhywtZXv1neTVACV3n1NJ7CyRoIUELCVpI0EKCFhK0kKCFBC0kaCFBCwlaSNBCgtboCFovN+HrdK0lmANIz0J6FtKzkJ6F9CykZw2cniWZ3Q5HzhLbJunUbZPHVcK31N/CX0jHQjoW0rGQjoV0LKRjIR0L6Vg7pGM1rESQgIUErBYErAbtGhPlShJfIOEKCVdIuBoC4UoDDnRPt1J7CiRbIdkKyVZItkKyFZKtkGyFZCskWyHZCslWSLZCstWoyVYVpgaSrpB0haQrJF0h6QpJVyMiXVVMA8lXSL5C8hWSr5B8heQrJF8h+QrJV0i+QvIVkq9ak68qcQaSsJCEhSSsoZGwFGDBbslYcs+BpCwkZSEpC0lZSMpCUhaSspCUhaQsJGUhKQtJWUjKGhspi8TJT2Fwf8UpTO9IMn9ALhZysZCLhVws5GIhF2vYXCzJ5IYULKRgIQULKVhIwUIKFlKwkIKFFCykYCEFCylY21CwJOEFMq+QeYXMqwEwrzTQQOeEK7WfQJ4V8qyQZ4U8K+RZIc8KeVbIs0KeFfKskGeFPCvkWY2bZ/U58iAIRaIVEq2QaIVEKyRaIdFqREQrPrsh0wqZVsi0QqYVMq2QaYVMK2RaIdMKmVbItEKmVXumFY8vkGqFVCukWg2OalUGBzrhWsFz0lreLpfU0GvsBPC7l77nxrmL+cGNyTWJnry5yt2IshpBfWR2IbMLmV3I7EJmFzK7kNmFzC5kdiGzC5ldyOxCZtc4mV0/kuTzQ+gTvsOLjC5kdCGjCxldyOhCRteQGV2lWe1wTK6ExFTuAha4521jgyLaiVQupHIhlQupXEjlQioXUrmQyrVDKlfTUgS5XMjlasHlalKv8ZC5SqEFkriQxIUkrv6TuKR4QNeJsmSeAXlUyKNCHhXyqJBHhTwq5FEhjwp5VMijQh4V8qiQRzUyHtU72tbPXvLwlu2uUH+GXCrkUiGXCrlUyKVCLtWguVS1mQ0zYyGdCulUSKdCOhXSqZBOhXQqzIyFmbGQTYWZsbYgU9ViCyRUIaEKCVX9J1QpQYGuSVUqD4HEKiRWIbEKiVVIrEJiFRKrkFiFxCokViGxColVSKwaKbFKRHVIq0JaFdKqkFaFtCqkVY2CViXmNSRVIakKSVVIqkJSFZKqkFSFpCokVSGpCklVSKpqQaoSaoWUKqRUIaVqOJSqCiCwK0JV2TuY0anK/Blj3owyOSArARrzD6BpSElSxpUU2jQdI6Nrg4FEEtgOSWAbKzMyx4yZY0W/8t/II0MeGfLIkEeGPDLkkSGPDHlkyCNDHpkBjyzb7ZHht7AJUM5VX161nyntq4bJq/hqnwVYg0Q1JKohUQ2JakhUQ6LaoIlq6YTWw2sUq01Drhpy1ZCrhlw15KohVw25ashV2yFXzXhNgqw1ZK3t4mLFqp6Nh7+W9gyJa0hcQ+Ja/4lrVU/UNWOt4g+QqoZUNaSqIVUNqWpIVUOqGlLVkKqGVDWkqiFVDalqSFVDqtomVLU3bnBPonAdv/OIv4iRsYaMNWSsIWMNGWvIWBs0Y60yr2FqNaSrIV0N6WpIV0O6GtLVkK6GqdUwtRqS1DC12hbUtEpkgQw1ZKghQ63/DDUFINAJUQ2eq5T/drmkxl3jOYCXvfQ9N84dyg9uTK5J9OTN685FlKIB7PEqTLwKE6/CxKswkReGvDDkhSEvDHlhyAtDXhjywpAXNs6rMK+TMCJXZL6OYu+JiDKQtYWsLWRtIWsLWVvI2ho0a0s6u/Uw6Zi2nUjpQkoXUrqQ0oWULqR0IaULKV07pHRtt0BBphcyvXaRjkyrdOMhgEm7iTQwpIEhDaz/NDCtj+qMDCatZUtKmK6sxp0BpIchPQzpYUgPQ3oY0sOQHob0MKSHIT0M6WFID0N62DjpYVfEXSA7DNlhyA5Ddhiyw5AdNip2mGxy6yE5TNdM5IYhNwy5YcgNQ24YcsOQG4bcsENww3TrE6SGITVsF9Qwnc6Nhxkm6yUSw5AYhsSw/hPDdB6q69ssNX4CmVrI1EKmFjK1kKmFTC1kaiFTC5layNRCphYytZCpNTKm1ut0mXUZLDCpF9K2kLaFtC2kbSFta3y0rcaZroccLuM2I6ELCV1I6EJCFxK6kNCFhC4kdB2C0GW8WEF2F7K7dsHuMlbA8VC9GruMvC/kfSHvq/+8L2Pf1TUJzNSDICMMGWHICENGGDLCkBGGjDBkhCEjDBlhyAhDRhgywkbBCCtEhJ+J++2KLEkEy6KL7Vamr6zPsGQrkzXSqXhK66bFx6BcLt+mY9ikIJgUX7qncWhg3b0UqTblObhTUke5E3wfsEgekm4gvl9oF9d3hEqPepXwGwk2X2HHIv+28k1Jru56SdXFpJxb0sgpyTZGpZve5T1Vjnx5NdgmRS4dJ+cIMEjecar2lI5/1WzqDaNe8HEVJlRhX1KCwwaaUHjbfp///TMvSLpBxquN2DY02+1vks8VexSIBpryniMvMSzvM3u0qTwBHZqVKB5uKJPv8ZsUmFErNKUVjYM+VfynTP+EgrNFMf+zacWW6lCdmqSwZc2yLVN/u0ZN4prQBQOSK4qOB5k9ynXA6NGbyA1idw4CMitaKEM7PiYb75oBXFQXbzVjUsds9Udn9QrkSLHo22wuY43WOSMVkcsfL+rrrK7RMq6SZOUn7b90NzcbLInDaxo02SsZKbC8pvW19fwhe0uyyK4j+lyxXN+3f/Z+JQuhJDFbnMkldcqwoNvSOuSW7SncClnf8r1MuqSQ7+MtT89+Yx1Izf/3Mwt2KFcRefLCdey/UNFRj8NwJrq6cBXlnC68JWtAYt2Kht8CVAWrZEFe96mVkIWtKuB9ECdUsCmDy7UC8iztGnki0UteC7QKBg3W2Ko+pqNhU/08r3V4cmufNuhfybsV9K/i3Pi01IVzO7wbyudNhRsqzMFNFlV8dFavYJhuqNJ/dEPohvbqhgr6V3VDwhmMxBEVltsqV1Rcvjc6o9LDM1k1A3VI1VFAl4Quab8uqaiBFafEwuFxeKQsXle4ozzybzKowpOzWunD9ELlzqMLQhe0VxeUq1/ufzha71wR8BpPxH+5KO/CqPF6uZeSYNc7BthLNn3RCCnXX26HrZufutQg43J0PPtb8awO9yy98rdyp0KqiH7oLhRnC5nO1WXtOMDNqQPs8I3wFo5zscEEop+aNoEwy7OYrIHiwBkwLEMm0hjamloX+y1OmsneLrxirLjMH/LvY4Xm1Pf+L0EI7xNxALXSPOnBUvjPtm2Ut4m8OxSews/BHpTeh/y39SkAotvM+vTL9dsb2fYvP8mnLGbhzRMoC3gcQCzTlrg7JasqEOQLoJ72wvLugzAiXx69eP71RMpO53vUsTi5D8ckFsRlEyGb9OmcTdc6wWqdTK1zzyb2VFIM26jOCCBLj/gLzliYTIFsHj+Ea/oJpAE5c5xFuL7zibMO4MDnPISNcOdMUuiTG3kufZLvKj+F1G+7wYvF1keJ5/qsBlgbLaknT2LeXNhV5j06i2UNdSP6UgInTiXf3jywBoJDp03KH2YJSHiikoBtYnuB9fGFVhJUyY+8HK/EtmcsSkE5YwXdhbTv4hOqNyEM0VpyeO0VNIbb/Znl8ZWNvYFreGW9zRIufBeJRQUnU3JSJvBA6PQFx3u8cu6LcGkROpxUFW3ZQJ1fTiBzQ+pc6MLFoyMztULV8z9MMj1jYwLZIPjJAiphltWFrcpcyw+BtOI9kqlQSC87P/FIaDx1YXFUOwZCX3aQwh69W5TNjvIWGHlLBz1xN57YhDJb0MWp9WWDoN5YF6cbqOLXicRAP/0vy3ukXvyJwBHFC2v+QObfuKkG3BFQvxt7fKjpJMGPMlrPcEZwPqdha5AArVtSMuf7uNb91cfXaaoBNjfZm44ljf8ym6mPa/GbmcxaJh3UlxmNUX0am9/M0L9K6d/ZScMsP43cp0ylS2vFATwBkchLMj2T7JRfYURmxoQstLTQPL2jkZ+3KgwlHRx5c7UHrtniQTRO91zqd5TPqo+TqUdju6GXjqNc4tsNaV7bZkNaFobQtqKywRG397CGfAdLQ02WD5awBH4YJBNJ/zDOiuFkiTk2mvW4U4BzNz+L15UZFpwSDKCppYBgyJYuVFa0EG+x8ezM3rJfs7/ev9H6DUdu1xcbJfcpT3MFBWxaPUxUB6cLpdhF29O3rypepsD1gkwqLQE5hhWXpV6pXA0FZbVX3ldCy8raeAhQRqE2qYqzxot+pTC1mq9YFJPKK+szJwNnx3LSOIOdRGZDzBLCpRn4mP6exQJFszi4D+lmePDg3T8kiorg2DQNaebryEteYE2Tonyx9R3UNncDdroNvnmxkgjOC0FUKdiHaZrKFAuGmFJREzQUgmPazDmNYXlMGsNRaxaoTSv57yDpU0RonaKPNFZ31z5LIvhdei5OUZO7Th6mLAPhE4kiSEHIhgFEBgtcFojxOK80YPJT2q9OlOfU+dDzXA/VTIO3U+shfAbUfMqOlt8W9eiWLQShLelxK+likFckqN/5yKRHy1friK4xWe00MBWnH2IRsBZTjULsqii81mwA+gOL57KotJnBFLa5jWUWYWLRBVfUYM0lpyVLpFJd42kt0yAPYW2OkXK/67OJetaupM0qDpVJ8izNXJD6tQp+rx1Srgk/srgjXEfyfJ7SJJ7CQWS2KQF38gpyHS2db4gJNcskcpdw6DAJGxO7KftYVrmG/Qq2h7gz/13VlmLDsm9k6y2R3U2hYka530pbvlW7bNpUzge3YWO5psFyoUyVSQPZEMxKA2WU17Bk/3+aFcdMkk5O9j5dYEcvzp07/xYul4qRFt/aP/Dfkowpzw+eT1gGLJ0KsOKVAYwyq2KOUDOMtqQ+WyexbFqalpNZlnMMiRDlrCEVk7H6cEiJTjJO1njn4qShbJbS0VEktWRwbZ7Ukm0Jq7kWFUmlTdA+O2lqXybwtKn2/wuq1twCbX94IWkmycayRMQHaS/PmNTOpkbvpEktJcHoTcizrRiVUwlvjd6Z2NckootB71/kJrxOIjpNNCX9yhkAAKTToQ8caqpB+OyTxT3JUsvFM7DQ5qIMasvC6KIHmrbRGG7hsJpLnVKWS8cBGD/VqIvGtr2yXvvUz7O5VbgusU3C0xZB2huDQqg98u0EWkzAVgDeI1vhUydj8PrCi6mfCsgckjwYmF3FEdtz6MN5w6DlG0/wIqwdYGtERDFBQiMMvn/ECjcoKc/XBhs8dP3hE1aIyPQEYQNwYgxKKnCRrG/kha2hGYsnInNI/LH4dxjYiCU6NygOoq67lJGTZfJLt9H4tBlz+RqUdk4DPOAJ+S8T+m7E8lKtafixhi3MgC36E7G1ZlCaiAb5XikLB9OtTJivoOA8EV6zJrCFa9UA7L+7MQO/8iSZp5OLE1P3k9mRJltjaauiISmarGz7oxvxbFTCZ0l60ZwEq/jfC9sILrvgas6rYguMbOUDKHamzTlcIBhn4ZyKDm6veCCbmMuCuReWCpxdRBE9icjU5a5DutMl0aQwy7BGfTh1VUtI7nxHHjxq2W5aLjxiUBjtzGJNu5O1MqbFxQkvIGB10E/XjyYdpb16tK1rYvLsQ5Ks4ovvv7+nyr++s+fh4/dc3b6jQfv3j2EQfu/FMZ0Qv/+3/+v/+DfboMRLGon5kNcgdXKLkMQwPCxactlRcjdYmDhl8aLIZQjXB+TzJOxJbWuflQ9oAMaSp5qZKE+pnK2TLvMmidWOMErjJYd+CaUqf6NVVfpfreMzk9GZGtcxMX+UT4Qx7Mxk0C+hGk7rpdp+Rn0z3CpDFhsUmITcoKFMbn228dtbLJEalkrl/Nqy5BYNObUFmlq8qYMuZkpLFZ46K/dimnL4k7AogmFipAti39tTnp3LY6zbO1JNzlUuY72i40IWUwsSuxZWaEHCPWGaafRE6+dWLtxkwshC/wRIlr8fstt5XrS5SNV5uWjkxsJnVgYQiRw+/DSU50lMGuZfP7yHiJRlRmk2qdOUtcsIKtB2acjJsybF/J9NyXI573jpenAdEwudXSvrTZoy5Ow39sfvjSlwWSvZPTF8VG37tGG5b+LyKqvehnUHBP5eoEmzXUoafz7RpI0Xibj0MnxlXRGWZc5L1uK6BaGQ6eIhm5Ij8jxlWKugNVRystpm+Wr5sKRKmScLYsERz6ABy5XzNBjSD5e3TEs22ogqHwso7fqLjJ6l7LVGnow/2xxxFnIit2maJEVPY931zHe61ulz11ZTNP0nISumJ2Hk3XtAflmugznfUEp3qwT5ja796CKHp48DM6uUlKo+uAYgrnGPuRYXJUFUdBYH7jfiwBbMWUYYlF0DBQ9DNWWdZLFAuv/egoJ8E73chFkSWYEMHxUFXToC/aWkK5q7K4r68erHIIXbJDikiiNVHKniI6SK62axHlLHd+YRkaLdZ4q2Tkv3QdnW19+Kwq0ruitKt7b5x0jxRjq2nI6tUxQjejYSqpFQjYRqJFQjoRoJ1UioRkI1EqqRUI2EaiRUI6F6sIRqaUy4HcFaF14i4RoJ10i4RsL1QAnX4nLs9DImm0opeWGe9y381T+mtXaDBJnXyLxG5jUyr5F5jczro2Rey4MeZGIjE3vnTGyp6vWTmd3cVGRqb83UpjYPWNw8Hd4UvqNaKx33zsi6FXT6iEndlWYOhdxda/Z+SN7HqDeDFrapIJH8jeRvJH+Pnvwtn+3GQwI395RIBh8OGVyutfsnhava0SE5XF7Fbkjiiu4gWRzJ4vIdJLnCIGkcSeNIGkfSOJLGkTSOpHEkjSNpHEnjSBpH0jiSxo+JNF5xXV2Qx+XhJpLIkUSOJHIkkSOJ/BAkcsUGC5LJkUyOZHIkkyOZHMnkSCavBUNIKkdS+Z5J5RUVHAK5XNdkJJl3RzJP4WYl27wiiDbsYeoyf6JB/NU6COjj70gyfzgusrlkAHrMMZe2dmfU8mNVjg5FC//9sf5R7FP/5MAS0IlhYlzEylq9IPlK+/kpiNmlAZ9+uX57cyD1aVAN5KgjRx056mPkqKsnyR5S04fscpH13mvWu9oO9kJ211XfjuOuLrkzarum8cfIaC+0se6ZlBR25MErePBq7TKiv8sniFn9oymy55E9j+x5ZM8jex7Z88ieR/Y8sueRPY/seWTPI3t+ZOx5SUS5JWleHZsiVx658siVR648cuX3xJXX7MYgRR4p8kiRR4o8UuSRIn+cFHlZxIPMeGTG754ZL9G8nhLim1qKPPjtefAAa0CU7ER8dJ0lDC+w3yWj3oLX/CNJPj+EPrmW430jZruXet5fmnulmbvitx+fHgxKmCpBIc0caeZIMx8hzVw2Ow059bmp50PSd59J3zKt3AfbW15vK5q3rMiu+N3S5mKqcqRopxoiUxBMTY7kaiRXI7kaydVIrkZyNZKrkVyN5GokVyO5GsnV4yZXl2LB7VjVsnAS6dRIp0Y6NdKpB0qnLk1s99zNMUcrXF7/+NTSHQ4kUiORGonUSKRGIjUSqY+SSF2ObpBBjQzqnTOoSyrXT+q0uonImd6aMw0g2zOMKse1YLe9OMwtyLHvqEeCvb63mV89JqJ0rff9JUtLmrorwvRx6sTghKoTGJKnkTyN5OkRkqdVM9aQCdSbeEEkUfeZRK3Szn0QqdV1tyJTq4rtilCtbDaSqpFUnWqJSkmQWI3EaiRWI7EaidVIrEZiNRKrkViNxGokViOxGonV4yZW1+LB7cjVqrASCdZIsEaCNRKsB0qwHly+auUGCHKskWONHGvkWCPHGjnWR8mxrgc6yLNGnvXOedY1tesn11rfTORbb823Bv/hgPfIfSFV1Npwd8CxFRI7Sta16Hv/OddZQ3fNuD4mbRiYQNXCQq41cq2Raz1irnV5nhoD07rZ/yHPegg867Jm7pNlXa25E451udCuGdaVJiO/GvnV1Q2YsooguxrZ1ciuRnY1squRXY3samRXI7sa2dXIrkZ2NbKrj4NdLaLBdtzqckiJzGpkViOzGpnVyKzeL7O6suGBvGrkVSOvGnnVyKtGXvVR86rTEAdZ1ciq3hurWihdvznVskYio7oDRrXwjwU+tRjjFvxZIA1dwWZcTD3gzzx+OipKtWwA+surlrd2V+Tqo1WOIYq2QWzItUauNXKtR8i11kxgQyZcb+gOkXXdZ9a1Rkf3Qb3WVt+Kf60puSsStq7xyMRGJnaqKBo9QTo20rGRjo10bKRjIx0b6dhIx0Y6NtKxkY6NdGykY4+bji0LCbfjZGuCSyRmIzEbidlIzB4oMbs0zd1zb8fcrm4Don90bV1rkbONnG3kbCNnGznbyNk+Ss62NA5C4jYSt3dO3JZpXj/Z240tRQr31hRucFLUM4rBddJoaCZlaub9BC5nStLzX84BFq94UepM1lGQyfAzcb9dkSWNIoM5sZ2r/N2TBvyWQe6N2G2OE/PnNSBfCYXmTxc/qpDC8j5Ts49jy3mfRss0JK3ggs4z7SVUyrt5Ie99+R0YScfxAi+hXrLeLdq8eg/+WP/IqOb6a4XQX8Y8LHxtv8//rgzRhbTZdmU0qE6VP1C8VUQjZsUG1sctnj+QxdonbcaNrnCaeBmwsIFVUfZHTl7MvoIfC+LnfBIJt1BhC9eiF/Vh1NvQtbL3KhGYbYHI30xoTBzLX4AxnMEP+dcFEc5qIm7cWGFyXrnPwcCFDF3YWMLyfo9JvPnRAJiJTGUs9pwutiY1l0TFdpcuZHv18rES/JJIv3XN1zBX6wC05q1+UXJ6y3o/uYUiM8CTI7vxerXih6ueOfEmI5LrVvanH30C9A+YpB8sBmwGixJE/AL76etY0ERoZxn6rCmRfus9QlMgJgNIjJbwh1NTwp7QdL4QFiP/A635WgxmJi8mDbs0zdqOXDnU6pyKSGcCWjUtaNkGOvwceQnZmxIz44QaowvpiL4PfC8gn9kTQPyA8PCL6YNXJF77yVcj/8pP79S7kR95gL1bKeU/f8T5FADraNbw0C/Xb2/UtmzYrQMbO1eTMVv7K+uW0dxZF0Mx1V5wPCl89BKGFPFxiG6lh59SfwEUP87GoSXRDkg26KAmh8ZSTpPyRCQO/SfCYmwGBPFKOOVVPvexFk5ZFUYckHZujlXnPLm+R9ccdJXikOWSzJO4P66vMChy3gjIImJGNhNykVcAp0f4UQjG4aw2y3b9Z/dFsSJZB15h2GabvcxqXoVekMxEL+38I9nu/aTNOVWmAh0eTM1mhpvIDWKXgQrbnPGSPqw8ZbTx0WX2+zBnlStN4DsVnZ8/PjK5digkxRoCzsfqj1j8t5WuECSLgOI+jbKYhTdPoKypBQU2lNhKmaqKgkec8YjzOF2AzOP38HDvGL3OaM/kFnVpH4dwy/W1OnVbLEp5KnCzU7al1g39WG35XGn+L1qRvkAVvVI0ns09tNXMpHQPFs8h8oe3PwBc21M8pvO/24tMeka4qOVGh4JT9z2DH2o2TkbeSf8wPbe0g2OyerQgP6FQCekVsUZlSTFtGutpk6hVDxQia8cpnKfZBOcf1KY449qmqtkiSLwmyeXin4TtdB8fBlDs/WGhgHJLdoQIHKewd79Ed9NBbblOd6M7L4nc6CUluSjLU/LuJRpt/0J/kIUgyBg0I4Jz13RIllDoX2hsSwW2UDaFNsHfJGLYUtMVWoyoBaIW40YtJBY9HPACPWPnnnG0kIpEQPtAVqTVtgJYJCV2hLPI2opwi7zxmesxwlxqDsboLak/QNimX7CNxGiM0ZtMiWbZX2ocp6ZDs9on6pelqjSTfjo8eEgfeCJKtCuUiK47nNwPzkqhUwscobCOPm78SDEQh4WSlI3aEap09NqAYVSvwqj2+t+s2wg7Iew0bthJP7UhAoWuc9RglF7994FLNbWgFUSlL7wjtKqhBwhcIXCFwJUGuNLbD2JY+8WwjMNchLN2BWcluQicKrSlEE8rXOPlJnwNKXii9TwR6+tjxLgkw3BohEvapJ3hW0etB30VYpOAEKJBiGbsEI3aM/f18sItrX/EOINahvtBGXT1t8QY1EV3hjBoWn/U+AJG8P2I4NX6aXitYJ8DYqN1MYbDuwuHX+DSmnkqgnSQWTQskU1nMVBlQXPsMXGluD7FxrWm7SVGPlr96LtQTQWGsTPGzscUO8s9+LBiaGOvcCSxtFym+4+pVe3oMLaWV7GTGFvRG4y1MdbuVawt19ORxdyN62yMvfcWe6crFmUQXhFWm2CLyuqnMLi/WgcBffwdSeYPRxiDS0bhwKG3tEW7iriPWgl2zxuOfeqM2HUKgrEUK2v1gmQjkm07NWlQAQzdMXQfeeiudvzDOZbQF/cyXjBArSV7wQB01bcL/dUldxXxa9qOpH154+v2jGz6nuEDaq02ptLXpTyrfzRAartRLIFgws7ABBgvnwrAibgEnCWIACAEiWS6Cxr5vUNHDx3wYegVdpA2aT/gwbHpQV+F2CQgjO0xtj+q2L7kmXu/Hb+Z9R9L5F2S4QFC70r9XcbepaJ3E3yXW4/b7BhG9yuMLunn8LfXzdbFGAnvLxLmN3nWQ2EumzbXI5Lk80PoE3bL6RFef1ns/oGvwSw3ZVfXYR6nvPsmNJVAMLbF2Hbk109KPG7fY1pDKx/vNY8Sme3lukdpve2ufZQU2dX1j7LWYqyKseqBY1WZXg4+Rm1Yx2JsurMrF0niPMPIOzEMPahZURQtQpN3rud/ppPk21/nhA378YWjtSE4bEgqac6OwtIjln0fhacTDIaoGKKOO0RVeeG+h6kbWPxoQ1WV7PYRrqrrbhWyqortKGxVthpDVwxdDxy6qnRz8OGrwXoXQ9hdhbBLOvgOLOnoUkIMP1W5mkg6CGcu78IoIYvjDWTFAPQjjM0as+Mg9uik3j/BqYWC4SuGr8cRvpZ971CC10ZbH33oWpbbPgPXas2dhK3lQjsOWistxpAVQ9aehKxlzRxNwKpc22K4uvtw1eWDXwhWhThaBC3pkmUX0cp+Y860tsMGm3krdhRlDl9gPRp6ybBigIgB4jAMRuH4+h7pNZsp2COJIjoIwi6ceL1a+SzcO1cs8mn8QFX8/EtpJVkIuZKJtaQrvQQU8ItOouxETSqizcCBr18VjSuss5anZ+kAnHGdfhb/pO2nqr2mAryjdk+D2sXap5P9ki4d6VNnv1XDyIntOGDHjvP7mfXkudYtX8N9oV7uq50WcM7+OclG/Xyedo1/cXsqbbE6BDDvy9wNWGhFuwMqkvZF35PTk61WwdutR78oe2hu89MNyjB3BfDfV/nHKsuYqU1GtiA+Glyl4h73AajUqmwJd1TLQ5xDG8VqboEuR7nxyn0OzgvOUfmikTvRz+NN7xg8ODHEDRDAMQJweqU0wtYrpm6clI0pwg5VbLj4SbYmmWVBXovw+40b3JMoXMcqgYx9a78yAIdFW2qN2RHocrRS330OYGrQ7sJN3BaZf7kvZ81vXYpQoHbFAAzSsggh55al3BE3IpGThN9I0HpoQNYtC1mvvUXbsU3Wdy2LKGwVKEuKk8ioMW5CHE2fmovpyJ+pfRUCmghojpvxIl+SDCcNPk6BOAXiFLjpFDhawFLuzvaBW6pqbkUEkxfaERFM0WK8oEHe+HSmya9l0Dyc6r3Zs9xMjR6GucHowfQWOZNni37esMkwgkaPgs826xn1zEYPFvyvYcHcy+J9Gv2i+8n9jzFqm9rjLP1jqtlzZUXPIhXgVl3AzdI/1I+CIc7gh/oRYYKzedNuZ9H+ZsV/6FoKApjxX+rHwPpm8EPTEWp3M/ihfqRgcTMtV7C6sJmlfwzvSpNG2BJZm7vadVikQ+8wCCSmLqMijRZw9HUSRuSKzNdRTBeqP3Os5fi2IqTDcNgNCUWTdrQtceR6sA9khg2psirI1BzbvCb7nuuAs7r7q10VyiYRcFsdatIPBIQREB43IKybGIYEC/ff+YwWhNOp0D6gOH39rQA5XdEdwXLa1iM4pwLn+BSJEE+vIB6dLm8A9LDXZuL38KAEw1ADAYVdAQoxCIAOnJBAyvOneioVTYuo8oouJRFckI3CYbEFeYt2BC0ctxL0VIQN4sHAHgP7cQf2Gqfc92Ovm5n+aONqjQT3EVZrq28VVWtK7iio1rUdTwRinHzgOFmjnoNPf2S2Gsbgd1fBb0THXxr7ygTTIuqh65U4idbz5DJY4CY7m3Uah+SwQbFB83YUIaOu7HEvbEFWyUMLzvvOdGYTfcD4HOPzccfnppPFcDbh++J4RgsImKrMPtAB87a0ggpMq+kINzDuFW7MyxvPfABuy/cLbjDVauMteiblGfs5vO35LYIRRCt2hVbMU2E4brBw1Bv3jULLx2DuU52ynGu6CH6fDlviv5w7xX9RB14+g0CjkiwPpPSEttES6PlBc3JafLygC+vEeyTZH/kKL/sKfiyIn7gmSUKpel9l2s36fS16cqEyEYN35VYAI1GzKMddrXwIGGg/lYd/5G8mbvwtlr8AYzmDH/Kvi4eUeNmmRtKEXYAueEXNYeK3aEzpxvqj20JWVDOsh/BZFrMU2mj/nSXa0j/z8e2V8/nD1X++++nDZ53Ui7pdlnopDN+y67Q/30h++h0OmNmfPr1/09du1rpxordmc9GeaBxAcYgUtp+NnLzA4mg2B2qVQa4Xud1I6l3Ee+WwMpstmbfivGTRcjVRugi47cLjcp/EpDdjP+WuggpmRv8v/5KO+Yz+vynv66SsXSsSOWm2vE39w0Q63syHlZSWFSipF7IuM1+7q4pPpCNcHyEYuma7fn/z9ury5v2HX6a6AXX9Z/clZj3aupnN7bn86fPlf10rGyKWDp/oosd//QBnEONrOtLx0iPxeXl8fyQBibx5GqiKd+gCFRC/G7qa/VpdYpQWd0JmVDjlZ6qJXAzgq0oBoglVfUib9uXL12nlq0tYL7Pv1J0pY68Ox2bhp+ad+gqLLnADj66PW6yw5IPYnBFnq/TUuxrMek1GA1rR24sT+RqrNkTU/GufKd5N00jM0gFUPSfaBQ+KPxVPQp/oU/BLtR0w56YmM/5aWFcXZ+qGY3sNI+akpWlWobXR0C1Ztcf5y6Mhf4bhZvlgNAZw+cDEmfMxNBja1gWDNdUaq1Evi46pX9ey+nSQSw62FCIaMisAsSzXyUyIrzxe5xPVBQVZR87TIprvC0if1CUwfuf6MTlpqWL7Ua10bNsrVXFaq05K5RXbhXzZZzSP7cLbG7Vuu0lC6T7LdVLNLX/QyunWxgjYGhsYd7spTRcPSNc8hXNwbkK+XnR334RW87+Yd/BrozetOKzM81w05zmXQhZMYqI5agxyk1E+b8I3uPLMNnIwRslo0tGYGUxgJVVoHPXN+CGs7D3c0rU5pYf9PvA1aZsYqmgvnwi/dk7k6Z+gdr+tDSyNlokfG7OWLrx5AmVNYZ76usk++W61I5c5EnKQkHMwa5Z54+HwYo7Igezw/rGu14SbsFCKetcR06RYJLJJFI1n/tgk52c9WSsyT/rAPClquTG7BKQ+gx/TtslAuwsFlWwSxYrY2K8ZMUeM2CP7DUal3BSTgLRxRLYJSkvz0rgYMixbVWpRLUK3m+jlJsxoNGKq7GXMLW3pgGJwRft3FZP3X7DjkIp6rDE2xtj44LGxzmv2/p7zXRrySGNSnbw7ilF1VWAaBYwuDx1d6vTTMI/CzuNDw9UZxot7jRe1c8i44sckenESNjGJgxY5xUs6Cp1FIpWDswMINSstHmzIWevHfkLPPgt8XFJqHnsMSTEk7VlIKveuIw5NzQ38KEJUufx3EqrKq8KQFUPWfoWscj3tZ+jauLrDEPaAIaxirhl5KJsmaVLGtJVhaRPqUF39KQzur9ZBQB9/R5L5Qz9DWklDhxTJSpu/swC271LdPTsx9qkDYAknaNwDx67irlJ47VXuSmliJIyR8OEjYbVTHg6PeZieYqyxtVqjugqp1TUgYVnR+LqJICO5ZwG4WquNCcp1Kc/qHx2MkWy2psVofb/RumbSGlmQDmri0646Ee+rs4TOQmguGYM2Z1FJ8vkh9Ak7kNzPw8PFFg7pEHG53Ts7TNxbAQ5bCvWxxRgYY+DDH96VeMNR7f6aGuxYD8lK5NvVYVlJ0bibi8HkwY+3SvSyL7u3DasrjP/2e0BVNjeM7KAqSZxn6KMTQyfBSoqdbhEovHM9/zNdzr39dU6YivUy2qu1ckARn6Ttu4r6+i3M4UtDPsYYAWIEePAIUOUhRxUFbmK8I40EVXLuKBpUFY8RIUaEh44IVbrZl6jQYPWFkeFeI0PlfDGu6HBJu+nAiswhaUep1dQ630FgcXkXRglZ9DpGFG0cYISYtXzX8WEfxTh0ScjGFyNDjAx7ExmW/eIo48Jmsx15VFiWcccxYblwjAgxIuxLRFjWzL7Fg8rVFkaDB4kGK7PEWGNBl3ezEAmKjrcIIK7o2qf5Su8eBIOyhg4oIpQ3f1dhYe+lOgqZKEcao0SMEg8eJWoc5qhCxQ2teKTxokbaHQWNmhowcsTI8dCRo0Y9+xI+mq3KMIbcawypmz7GFUjCXaxUXURXnXS9OJOuYfN+gv7zi5zZRbtWfkVwxRgMVOa84c7imfwu37oOSbRlUm5yPH8gi7VfMbB6+ZXUDc8PJGha2Czo4pIdXk7/yNdT2VfwY0H8xK0vd3RLnWvR6k1GNn3nnF95665WPqx/aZOpgU3Ti+Xd+Fs8Zd2bwY/6hdd51a3vpi43YYN1Il+KXeavv19IlkqsL+o72zXLsJvIDWKXmadYicmXwoplm/ThNK2WXUmf9TVbOt1Ae6+T9d1Xs2u8d6+CEsPaQEqFt+z3+d+ahT18rLpBvKwstIzyB4q3mA7Qh9lv1d3kdCDpIySI1xFxHtyYDcm/aFvOC3Ygf7fQx/Ld5NUJQMg4m3uEdvbx2uC69g/qiuf0xbvEefqL668e3L/YbLCd1d1fbTCy94vh3OHcRhjHegtrRxpQla4ZXNdLkeNdv33RMhNcqRjAWJutU75OJADlp/9leY+riLqwRxphXFh0BTf/xmHPgHg0EoisVRh7fCQsN7pfw3PWsxtb7nxOJ7UgoaJ7kZR8TyMBGs9a91cfX1tCI5mR2Jt2PKAfpipdH4TiNzPpbb8d1FcAMwzqw7uPOwHa8KbiPoFtg76F2HHSYN54WmIB0BsaCd3QP2CnHH7/byoHMMpzw2ftIHw+n1h/KiJ6EDJUDFgxtMVXpurgrA4xMc2sFCAblHQcN5qrua/8MVrNfxavK92UU8LnnG4CRCn4J6n6jrgRiZwk/EYCTd1skSDaL/OzjtwPyu3ebAovWGvTWkhur+Vm2UUfp29fVezlzYqsIJNKi8NrWnFZJJXKi1+eSBYUl4tFCsnB5rYXLMPokcX4gHeKfWPWfPukoc9ygzuvy+KBuLDJbd9cXv+nc/3672/ffPrp7VRhrrmLsb045K07n/Bxy7/jtnl2NpFAw9RRnJeaSl1+sl7BroHUqcGakloB61N154CtNxv3Iett0N2w3rhXULDIWcX45S9kLr3YbfmjRf2YVXXJaDdUgKCFccN7yq1rklwu/kloJ59IXyGjYhuPCDnqs2h2H9q7addbxvdudOclkRu9pPtVyvIglWZs87bb91z3mHwl+mf/Qn+QhdjrMmhGRJ5gCeAuodC/iKy1yqbQJvgHwbNKOjcCWEsiuuGgW2gCCLb1H2yTqMY+MDdpta2gN0mJHSFwsraOA4jLXJQRGldzREZvSf0GAnr7A/Qk6muM62UKMsv+UiN8Nf2Y1T5RvyxVk5n0UwQOEThE4BCBQwQOOwQO9XAF4of9wg9pUOXki7dZKfBvc8NjHgoNAVlUNPeIQMaBCAzBlnHijSr1GwH0qPctiEKiYSAK2R0Kqbe2fQCSTS1od/+otvCuriDV9wARS0QsB4JY6jUZwUsELxG8RPASwUsELwV4aQyDII7Zs/uPc8E5VUxTIdRWaNnLTUijK+o/1/NEhFn9BTcljT0qaHMAwurpSDeN4ijwObV59DW/GcJMB4eZ1EqzH5BJV39LiElddGcAk6b1A4KXEMDZPYCj1pRts7EhHoJ4COIhiIcgHmKChxjFToiG9A0NeaGdB8lywaUyZmCIRKKdRdeV1HXDgEQqjT5aaKTnwhsYRFIdzdFBJXKzQcgEIRMDyEKuPPuHTlTt6BBCkVexEyhF0RuEVBBSUUAqco1BaAWhFYRWEFpBaGVf0Epj7IUQS88hljR9vxJrqYi4TdhOVeCnMLi/WgcBffwdSeYPvYVaJG09JoRlAKLa/dmh2KeGzZdvnLwcK2v1guQwJ9BkghoDZqO2v+GcPeuL/iAc1B0cpNbLvaBAuurbgT/qkrvCfDRtH8fhrLq946mpPSJEav0yPjJVl+Cs/hEeYUJcCXElxJUQV+oSVzKKOBFO6hmcBGLwqdiciMvNWYLgAESSyLM7QOJz5NEZfyDgEW/s8aJH/RRW/3k50lEcH7ZTMg/k4SDwYoJ8lJTmAMhLpf4uoZdS0bvBXsqtR54NoigqFKWkKcivQRwEcRDEQRAH2RsOooqdEAjpOxDyzCRXR0K4RFtE1z+S5PND6JPrhM5FfYVASo08Iuij18LpPeRRHr0RQB0yM0CIAyEOKcQgU5Z9QBvyeltBGrIiO4IypK1FCAMhjAzCkGkIQhcIXSB0gdAFQhe7gy4aYh+ELPoFWdyThPp3Ki8nBoHB/FkUYIsg+J3r+TCZvf11TpiV9hWlqDX0iJCK3gup92hFfQRHgFioTAJRC0QtpOiBSmH2gVyo626FXqiK7QjBULYaUQxEMTIUQ6UliGQgkoFIBiIZiGTsDskwiI0QzegXmrGkInOeqcwckgqNakRNkB0EzJd3YZSQRd8xDdHMI0Q0eiqgweAZ6fiNCM0oGwNiGYhlaPGEsrrsE8mo1twJjlEutGMUo9JixDAQw6hhGGUdQQQDEQxEMBDBQARj9wiGMhZC/KKv+IXLRVZAL4QQW4TGn2mTlz6dxnoKWqTtOyK0oq8i6T1MkQ3cCPCJit4jMIHAhBQeqOjJPhCJWpWtoIhKaR1hENU2IviA4EMGPlSUA1EHRB0QdUDUAVGH3aEO6pgG4YZ+wQ3PQlJU+qnQWsSyb9zgnkThOlbNrf1AGSrNPCKwoecC2v1VHKl7aHEBB/cBrPmtS4lXtAOkZTEx8ZctixDSa1lK0Zm2HhqQdctC1mtv0XZsk/VdyyIK85d+BWnQGLpwdzR9ai5mN1Bc1a2MAJGTzxHDuXMIHR06OnR0iFcfFq+We9F9wNaqmluh1/JCOwKxFS0ex5VYRXyJX4SleTjVUrNn+dRi9DBMIEYPppegmjxbRbEMmgwDaPQoOHaznlH3bfRgwUkbFsxdMd5gtr8dC7knML68LEPD0j+mykdF5bNIBYFUV3Cz9A/1o2BkM/ihfkSY12yuWrRL0briP3QtBcHN+C/1Y2BZM/ih6Qi1qRn8UD9SRCoLf+vK5OY0S//AS+Rw/wn3n3D/CfefOtx/aoS5cRuqX9tQi1RgzpJJjCpDRYYtNj2ukzAiV2S+jmIaC/9M4ti9723CdGljj2iHahDC2gd8yzqurAruGYhtXpN9z3WHiaU6dAfZD5ALcQS7AjrrHNLeQO+VCzHYzjBYnc7uA4nV198Kj9UV3REqq239WLBZ1ilE+PaH8Om0agOcj702E78RSUIkCZEkRJIQSeoQSTIMRxFP6heeFIPYqDyE3Jx0iTOTh6Yt8IorahRDwZZkbT0iaGkIour9qWvpII4A2dHYBp7GRmRFimxodGYfwIq2+la4iqbkjmAVXdvx9DYiJRlSolEUPMmN+AfiH4h/IP6xO/zDLGZC+KNf8EdEpSZFP2TibBFR0zU/9ZjreXIZLAbFsmls+BHBIoMT4u4JEguySh5anIbbDfTSLKgR4DCmljkcts0BlQmxns6wHlO93AfwY96WViiQaTUdQULGvRoH64a5BeTc7A9JMtUvY/4Nk+CM/UTuDWJPiD0h9oTYU4fY0xaBKQJR/QKi5qkIHTdYOGpWTqOo8zGg9mfdfo48PqOD8txaczdgZg8ey3KDF9HSmDbVunWuhcrf0m4WillF5AkiD9d6ZqVZSzrxW4sQbNq1bt+FoR2R5fnklpa4sJLoBb4olZDakm39PXymhUVT65mOs0sLpQNK2xI+56XTT9LnC0XAhAgvUTXJB0u04DNxv12RJYmobtLGQ/MKb97CEfu0hVTOMIdTJwGFCRVyoe/0IWX/wyeq/CyCsmJ3SZIXHqaxhsesBeVhlnbeOl/CEjCB5kxy6c99OtVYpfrPM0nQJXz5+B8B1+QFHrXZc2nap7rpuKuV782Z29VlClJNhJf56+8XX+vFM69VLfU1HRr3zidfNouT5VhF+nyad1P3MP2cRLQ79lvxRxqBZ+ETQADxdbK++2oESoDeNY1ZtsBL/8ibVl/7qSERk7RQG627FOCpfM5nVsLnIPoq+614hpnizCJBvKZe6sGNWef+RUs9h69mbL2seLeYVWVW7HHVdwtpMU8FmiT0rAV8y0rcBURbMn69CncBybPfRwS7D11uuwdOA/eRtEwk15gFceHNEyiLLpVogQeB9bki7Au6P6x2yIx9OEj+mBTylfUh8F+sW746vY3ZIvc2yUVOP4ofwjWNHm5v07UeXWpOLVdS1m2aR/w2eyleuc8BfcHe7a5ESZ+n1qb7F8ezgVE0uX1sUpTra7URUSyqo82GUuvGsaEA3skopV89FyNuPux686Gob8YbDCDRGfyYts31NzlptJeC/zB1twrDEfDDOQcC0xPPJHry5iJOPW/MDFhsT0MyvYgsi4/bTvaxYixsxdLbGEBkdYspcVbZHZFXObEFmoc7QrgjhDtCuCM08h2hFIHuaitI47EHvN0zqK0clgcqXdC0SfBGksvFPwnt5BMZAWxZ7M4xpekbhxR3jxm56Si1BI7c6M5LIjd6cbbO3iZRVfsX+oMszNK5ccf+BKsFdwmF/sWJCRWDevONNsE/TALConoeF7QqkfJwEFa0FgR8EfDtKO9jXYH3ku5RVm27LI/1ErtK7ihp6zjA4MyRGiHCNXdpeI+NxLshqLzHLJJ19TXGljMFmWV/qcHOmn7Map/oLmSRqMlM+imC183gtT7yQgwbMWzEsBHDRgy7dxh2s+NGKHs/UDYNr518gTwroUUtMNFCvDkykFvRsyPCu8cnWwTzxgl9qzT1uFBwvcdCQBxtCAHxYwPE9T5hH9h4UwtaweT6wjtCzBt6gOA5gucDAc/1mow4+thxdOOIDiF1hNQRUkdIHSH13kHqG/lwRNf3g64XIminirQrBNYKmH25CbP0QWJNMgrIXdKvowLcxyXX3l/sJR/wY0ON1UY3rlvAEPw8OvBTrdr7gT519bcEPtVFdwZ7alqP95UhrFiAFdWasu2FZUeN0hktAxGjQ4wOMTrE6BCj6yFGZ+zBEaHbF0L3Qjvm5Mm5hfwYQCeRVmcwTiV78ehgukr/jhauG4+cBwbbVQf+mOE7uTEijIcw3mhgPLmK7x/OU7WjQ1hPXsVO4D1FbxDmQ5hPAfPJNQbhvpZwX+MyEmE/hP0Q9kPYD2G/nsN+Rp4c4b8DwX/p7WJKHLAivjY4ERXvT2Fwf7UOAvr4O5LMH8YAA0q6dUzo37ikuvtjvbFP3QVf6fETO7GyVi9IDnOOXCbTI8MT1VY9nBPkfVE1hCqPDapUW89eEEpd9e2ASXXJXeGRmraP44h13Svh2ec9opdq/TI++FyX4Kz+ER5ENsA8jRbPCHUi1IlQJ0KdCHX2D+o0duCIcO4J4YQh9qlInIjLxFmCUADXlMiqO+CLr0fGh2fy2o8X0By8XPtPY5QO+FHDjSWjQ9oiYoHjwQJLqn0AMLBSf5doYKno3cCB5dYjLRGBPRWwV9IUpCO2heZUy0DE5hCbQ2wOsTnE5vqOzek8OIJzhwLneBhYR+e4tFrAOD+S5PND6JNrmOhHAMuV+nNEcNxY5Nh7GK480McFv8mMC2E3hN0GDLvJVHofcJu83lYwm6zIjuA1aWsRVkNYLYPVZBqCcNrGcFrDMg5hNITREEZDGA1htN7BaAaeG+Gz/cBn9yShTpvKgs+3sEgpCqcFyvLO9XyYod7+OifM9EaAmNX6dESo2Zjk2XvkrD7Yx4WeqQwNETRE0AaMoKnUeh8omrruVkiaqtiO0DRlqxFRQ0QtQ9RUWoKo2saomsEyD5E1RNYQWUNkDZG13iFrht4b0bX9oGtLKg7nmcrDIalAqOrWhNQBKnN5F0YJWYwIYxM9OkKEbfiyHAy+lg71caJrZRNDbA2xtRFga2Wl3ieyVq25E1ytXGjHqFqlxYipIaZWw9TKOoKI2taImnJZh3ga4mmIpyGehnhab/E0re9GNG3faJrLxVHA0oSAWqAvn0WENwIILe3KEWFnI5Be70GzbIyPCy2rWBPCZAiTDRgmq2jzPvCxWpWtgLFKaR0hYtU2IhSGUFgGhVWUAzGwjTEw9fIMwS8EvxD8QvALwa/egV96p42o135QrzSkomqaCqQFTvLGDe5JFK5j1dplcGBXpUdHhHmNR5a7v7cydSgtbqvkLpY1v3Up8Yp2gLQsJib+smURQnotSym639ZDA7JuWch67S3ajm2yvmtZRGHG0y82DRoD4ZWmT83F7AYRrnqg4wKG5TPPcO7yRZ+IPhF9Im6b4LZJ87aJ3NfvY/dEVXOrTRR5oR3tpShaPI6rpovYGr9gWvNwqqVmz/IJ0OhhmOaMHhR6bfRsFcEzaDIMoNGjMP2Y9YxOMkYPFqYSw4L5hIE3g+9v40zuCYwvBc8AwfQP9c6QqHwWqeCf6jpzlv6h2W2iRjaDH9PGzbO5KrSQApbFf+haCoKb8V/qx8CyZvBDt2u3vpvBD/UjRbC28HfTTiCtOv0DL2dv3gZtROxwNxR3Q3E3FHdDcTe0d7uhRr4bN0X3sym6SIXhLJk0qNZW5NNiX+06CSNyRebrKPaeyM8kjt37Mdz3JO3XEe2Xjk2u+9ghYGOkrAouX4ttXpN9z9WMSbA6ygfZnZLL+7j2qHQ2P6Sdqt7rIe4IHNmOgM6y9rEvoK+/1e6AruiO9gi0rR/LTgHrFOLN+8ObdVq1AerMXpuJ34hrNuOahitrRDcR3UR0E9FNRDd7h25u4MER49wPxhmDSOhYC5k46XpyJgc2WgBjV1TTR4h3yrp1RHDnyKTa+/Qo0vE+LrRRY3GYNgXRvgGjfRrN3gfYp62+FdanKbkjqE/Xdkyzguhdht5pFAVTrmyMyZkt/xCSQ0gOITmE5BCS6x0kZ+7AEZHbDyIXUYlIATmZqFogN3TlQd3gep5cBouxkhEb+3hESN2Y5b17ctiCrJKHFufSd4MGNsv0uKBBU3sfDinxgHqH8OORwY+m1rMPLNK8La2ASdNqOkIpjXs1DnIic15ITdwfuGmqX8Y0RSbBGfuJFMVmOHSLNTZio4iNIjaK2Chio73DRrf05giU7gconaficWhg6qiJjI1izMcAMBUelZZJkrX0PJVIHeaTJmeezVPpHzkIUZ/C6hgBC+Szi2SI++2KLElEtYbYzjU0+aIycDDtehBL5pE3jcx93zq9ozpxmoffFjhYGplGpFJC/ELjVCr7uRWv793IohZs3a6oOqUFsmB/Hfh0GK1nclYr4DltAuhCFPqWH4arKZUxHTBv/mCB5EHAL1B5Xl21GeXKYZnIvFwNOUjTkM1060yxwrTvCfVFJxV/Xkhkpnbf5aXK3ABXSFOqm61utami7MoQFFpt8+F2YJDPJ8pSmLvNispFqVjSci0BBZ+xlZokFjMeEPoxiahJ2O8DL/Fc3/sXMRoS1trMTyb+y7mkXSeSF3X2ci5N62o77mrle3M2vJBwSnzKJpGpldV3ovCic58ubazUIsvpJAhMfB7tuuPIK6/753JjNl6UXuavv198rRfPelUt9TV1B+6dT7582Qgq04O+FROQPpypx1vxRwrCZQAKi/Guk/XdVyPwdA9uWTKnd7OqV2wdyV2STHNpGeUPFG8xHaAPs9+KZ2Ag6SMkiNd0kn1wYzYk/6Jt0XkG/m4xheKsOE7VpYeQMZuOQP+EdrbY8mIl7mRbq4U2b76LyX4fZqey1ASwvs63JQcuo93vAAXuI2mZxroxB/vCmydQFp3taIEmW0rbKEZV6HvbmzykJsiMeDjbj4NVvm53EMsKNN1k7TI5nv3DoorvY4+wXF+7jcBiWR1t9pWaN44NPXAHRnmw6wnMcfNv15t/RX0z3uADic7gx7RtguwJbjLhJhNuMuEm07g3mRxHbKqzPnW216QIgwe+nySBYrM1e+MoyRskRn9WkMO4trVYZsl0Vm+TiJYkl4t/EtrJJzJ8DKzYm8NCYcWW7AQRG4fgdo9NuOkgtQQo3OjOSyI3enG2zgAr0U77F/qDLMxSwnI/+QSrFXcJhf7FiQkVmHrHhzbB3wQq2UJrFRp5VKidRLDDAe/QQDo1EIQUD5D/uK43e0l7LKu2ZbrjepFdZTmWNHYccGPmwIwwx5qbMrxeUOJVELbcYzrluvoao5eZgsyyv9Q4Zk0/ZrVPdPfkSdRkJv0U4VGERxEeRXgU4dEOMwdrMZHxoaTVaATBUkX6YkJtIlslzkpIRQsIrsBuHReMqujYYRFVRaN2Aq6OTrIII/UKRmqny816elToq95bIRCLFoSY7P4xWb1V7gOebWpBO6RWX3pHoG1DFxC/Rfx2IPitXpMRykUoF6FchHIRykUol0O5xgjM+FBdTWiDAK8c4C2kG3WqYK9iOFuhgy83YZYvRsR2Y0B9Jd06NOYradKOEN9RybSPAmka7CMDLdXG1tf76bZQAkTeDoG8qVVrP7ibrv62qJu67M4wN03z8ZI4xLQKmJZaUwxviUOICCEihIgQIkKIaBuIyChkGyNApFh/Izykgode6Hg7eSrgPAesdCw7wxEqUcjYMKJKcX3CiipN2wNmNBpZ91lApoN/xFiS3CiHhSkZKQdiS4fGluSqtn+MSdWOLrEmeR07wZwU3UHsCbEnBfYk1xjEoBCDQgwKMSjEoPaEQTWGgGPHoiTrdsSkDDGpNLxQglOVwW0DXFDt+ykM7q/WQUAff0eS+cMIsClJrw4MSUlatBskalQC3f1Ru9injoKvRDmFP257eXoHIm8Q53FBWmpbHs6Bzj5oGYJkBwDJ1Mq7F2xMV31LSExddFdImKbx4zjuWPcKeA5xj7iZWr+MDyHWJTirf4SHAhFtQ7QN0TZE2zpE24zC3BGCbIrlPmJrCmwNBO/TAXMiPmLOEoYMEDXJSHaHu3yO4M7t0SFpvFu9gtJ4k/aBpQ1dpn0USNNgHzPUVTK23rO2zJUAgaiDA1El1ToAElWpv1MoqlT2brCocvORjYWokgpVKmkKsrAQF0JcCHEhxIX2hQupQrbRA0P5+huRIVNk6JmNWR0a4mPZAkf4kSSfH0KfXCd0+hs+JlTqzmGxoFJTdoIBjUR2fRKAanCPCuuRGVHfMR4DYSO2s39sR6ZK+8B05PW2w3JkZXaE4Uibi9gNYjcZdiPTEMRsELNBzAYxG8RsdobZNIRY48NqautoxGjkGM09SehUQkfKiWGoYKYuDl2LsP6d6/kwb779dU6YQxg+LFPr0mGhmVpzdgLPjEiOfROEbpCPCqpRGVbf4RpDwSNks3/IRqVS+4Bt1HW3g25U5XYE3yibjRAOQjgZhKPSEoRxEMZBGAdhHIRxdgbjGIRi44NypGtshHPkcM6SDpbzTEeLxgBiuKgC1oawAzjg8i6MErIYD6gjOtQPSEc0ZqeAzuAl2C8hqAf4KKGcsjkNBcjRihxhnMPBOGV12ieIU625GwinXGrHAE6lyQjfIHxTg2/KOoLgDYI3CN4geIPgzc7BG2XYNV7oprCqRuCmCbhx+WAVYBsxfC1C/jTYGD5ak9Z2WJgmbcVO8JnhC6snwy4Z0qOCYiq20ncMRi9dBF/2D75UFGgfqEutynZwS6W4jnCWaiMRYEGAJQNYKsqByAoiK4isILKCyMrOkBV1wDQ+SKW4SEYsRY6lPIsxojqWDleLcPyNG9yTKFzHqgl8aBBKpUOHRVIqjdkJoDIaCe7+FqXUn7W4O4k7Ldb81qXEK9oB0rKYmPjLlkUIObcspej9Ww8NyLplIeu1t2g7tsn6rmURhQlXv+Q1aAyNNBxNn5qL6cA3qf3OUYGP8llmOPfJoSdET4iecBNPiAj9/hF6uZfdB1CvqrkdXi8vtSPYXtHkcdx0WITU+P2GmodTNTV7ls89Rg/DDGP0YHrvtsmzVeDOoMkwgEaPguc36xn170YPFry4YcHcV+PFlPvbo5F7AuM7KTMAMP1jqnxUVD6LVChLdYk3S/9QPwpGNoMf6keEec3mqlW9FKAs/kPXUhDcjP9SPwaWNYMfmo5Qm5rBD/UjRXC28LeuTG5Os/QPvBsUd9xwxw133HDHrbsdt0ZEfXwbb5IQGPff5Ptvi3SonCUbK6p5ldFrsZlznYQRuSLzdRTTwPtnEsfu/QhufJB267Bbc9Im7WSDbmQy3Qc4zYZIWRXcvBLbvCb7nsvTWd391a4O8iYgYBt9aJL1UW2N6Gx9SBsk/dZBhKP3D0frNHsfoLS+/nbQtK7sjgBqbfPHAlOzTiHYuT+wU6dVG0Ce7LWZ+I2gGoJqCKohqIagWnegmmEUPD5oTbmoR4BNDrDFMGBUBcSIOemiaiaPrlsgM1fUDscHtsl6dVisTdainUBt4xJoD8XRMNRHBXRp7KzvyQjMNQBxpv3jTBrF2gfMpK2+HcqkKbojkEnXeExkgLhRhhtpFAWTGiAahGgQokGIBu0MDTIL1MYHBqkW3ogFybGgiI6XFAqSDWQL4IBGGdRHr+fJZbAYKQersYuHxYgam7cTwGjEct89R2ZBVslDi1OhO5H/JrI9KrjK1P6Hw9Hqg/4hPrZ/fMxUk/cBlpm3pR1yZlpPRzCacbfGwdtingRZW/tD30z1y5jBxSQ4Yz+RvYV4HeJ1iNchXtcdXrdFnDw+8M4oREAkT47kzdPBc9xg4ag5Xo2DnI9BHuoDTFge+HoCiWpuL5MA7ERxTIdOtxcnEk3h9nYuTU1mu/6z+xJz4xc12nAnjhc4azr4/vlEunxUOCZW5IoqtEebxDyetGQ/DFfn8gmDFZ4Vk6aVlTxc/mRis9EW9Uxk4niOaKN2Kg/4j9USZQDnD1Qxr0n05M2piN4HdD4gn9kTr+nc6d755Ivpg1ckXvvJ13JtFfyB40b1pqfDSKcH+oQUS8kfcVJwQv9QGbkoqqJhV8q6enp6+pFEMBVZbmCdeuw1PpqnFlcbGtmnDajAa7cs+r2FyT0Uq6ULC5aSVvjoJQlZTK1bLpjbs1iYRRmfC+iigM/QtAzqYBZ2tXUVn/KZWLSxz260yGp3/ZDO9mKG94KARKLWW+v8+cGbP1SKcH3q/ujigE7bYCOwLFnB8msxsa2P9A9aThSu7x8s9jJ5IlGlADZaUBltcGTF69WKutWF9d13FvmV/jmnVj/3oSCYnB9I5e1bLsNbagXgZYnPmk5d9j0tjDWLTnnEWoTP4PuI+2gfr3OR+I6Ct5gKq58yA5zBjxPFDPkqNRIrXpG5t/TmYtaKc3No2izIXRorq9wsOS5siglfsVWkDhHOvSA3aZNHbyI3iF22AjArujNkumn7if2WbjHtCjX+Y7WaHcSd5VpLqwTRYZHa9ES5aYE6uHMdHLRSwX+B+0haZDttzPa78OYJlEPDBFqYprStNLyqwc3bbqjWHWz4FT3ulpt6DlrRIa1oNzt4xrt33e/cFVVy0rKupp25cl0n2268FYuRY8Kb7ayVmlXHRbffOdvTrpmoBmxJnQBWmbX3pPWumnxHbYPdtEPupG23iybdQSvqkdEu2f/f3rc1N44j6b7rVzBcD5Jm1ewzveecB28oZj116fFOXTpsV9SZ43HQtETb7JJFBUnZrent/76ZAEiBJECCF8m6ZEe0S5ZJEEgkEvl9mUzgjI3xRwWxqq/6WqAfvyVkwW0C8G5HgLVn1smdG3onFgoDDFFYwMNZTHjLLxxZy/nMAwz94vVDb81EoFEJgzxhidhzBOCZQ3YLaUlE3it8nAUOR4xb9QSg+oMbInxXdUFCt7dZ0/cmb4eTnrHmT0TfGLI+yXViPf48xZpIw7pN4brdK0RTMlthoo+nlfF8yfSaOyWa8H0F4VAIRsrkg9STKgLCgIgoPEpBSiieWEJMZB6aabaEpNAHkTlpoUBmtdh/o1hJ3oCAiSq3P4OhaSjcm9VSp9RtPZ+D6+HO/H95NRQqFXqq6fFsNdg/Ifa2FzdvFLhuGrPeQry6cay6SZy6VYy6TnxaHzrM+Pi4W/8SBnFQ1PV8vDZkSFZejqXLpFL7Nxc9rR3MzfG+vW6Dmh0ENHXBTFbsL/HDGrB4l158Nv3VgwE9e12SebtL/cojPiYGODvuDong41Ghveec3GSeWhBPbnjnx6EbrpzGVUkVS9D+DD+8qVmZ0hBjojD8e2zwz07kgQ7oz9+Cx89M6a+ai0SzCDZNKe8d+auYcOKAaT12sR4PjpVWTMamyWnlIxtz1IrWdCiwTr1eRR/3l7BOF34la11Y3pV3KFcjkd7dk94KlTTivtPJH6ef1BC2MPfjwjcjDcOlUIGx8tujJtb3leLuhHeuzTkPbT3UI4K5LsG8p7Iknpl4Zv17UFmiWeW91+CbeXJtlm+uXjX79ZaPNl14x3lngG7O2okdZ/iPBhyixGgcHyOtGfwxkdNaEXTIUx+ljhFFdugUWfOlU700iMjOcVvlppo4bVqwHS/Yg6O3y1fQppnuqqc3Jr3LG+6A/67oOVHhRIW/IhVerp3EihMrfsCsuBGwJIK8LkG+/2Ilrpy4clOuvAIV1KHNE3uVIc5rrSbi0LfBocfrKXHyfLpmuhrRnqurIK1jJewy1W1oQ9crBHpcZL1SAJ1S9aSzRP93onRVSkXlP7ZEnOuN5tHT5k0V/QDJYb2WbJ4aLnt2C2JY32wXFTxKu70HrDBxsN1xsHpNqGRgqZoGVdOgahpqdrcSixC3W5/b3W+hErNLzK5htY1Sf75l9Y0ay4iqcWyF0V2BGJz16QJirhihq5iq1tRYDqoTRdYVrZtr6njp3YIgNkbzki4T3duZEpoqGdG/r0D/qo0r0cAtF8CB08FqrdkuLazrQ0f0sLr57mlizTCILj5aulitEUQbE21MtHEHtHEptiH6uB19vL/CJRqZaORGNLIGD3RKJxstK6KVX4NWTqyqll/OzV0Tbg7m9GMwf7hYzudw6QcvnjwSJdeCXlbI86hYZeX4uySTSWGJQ2aliWZgzZ3Yf/LEy5yR9kn+PDZ+a7+Z/lboJ9HP26Gf9caXanbswJI5POZar3AbJ6zLHt2cp9a32gk9XdLp/S1tUVxWVHtiA0S2XneMCk8UZ2lc/IrOHyTqm6hvQ+q7EokR412b8d5vmRLRTUS3KdFdghra8tvGi4ho7W3Q2ijfGcyHE/IJce5xRpDMVkxUe0qQMxxHUlNaNfQj5psTAWyOcD4G7SL1qJp+qphcThxlDBFl/DZUyUPnSzNasmXCNPfsrhjTTLNd1AMu6zUl8h4v/5nRBErg3X8+8dXK2lb7t8TjteTx9k6oROQRkWdc0rbMoW15DlyNdUTFbF+HzOPTVmTz+Fw1IFx+9uJvj8HMu4zd2KPUvubkYEaQx0QK5gbeIRlIuknUYkMl0ykR5YZuhaBUGUMiJmsq9MERkiqt2DQRqX5mYwJS1VwXuZrKbhLjeESMo0oDiGmkfEnKl2yUL1mCHYhgrUuw7qswiVglYtUwQ1Lpj7dMjTRYNpQTuQUa9cGLnRecCCfCmUCfS56ZBszUB9efoav1/reJxzSN2KnmzGlBmMfEnioG3yGDSnpKLGpLZStTJmJTt8Km6gwkMaoNlPvgWFWddmyaWdU/tzG7qmuyC4ZV211iWY+IZdVpATGtxLQS09qIaa3AGMS21mVb91mgxLgS42rIuGr99Zasq+HyIeZ1C8zrPcyFg/sSmEoxG6AshRlqwWyd3QVh7E2J12rPvwpRHiP7mg59A9wraSgxrw0UTa9IxLpulXXNmkXiXGur9cEyrlnN2Bbfmn9qa7Y122CXXGuuq8S0HiHTmtUB4lmJZyWetRXPqsQTxLI2ZVn3T5zEsRLHWpNjzfnnHTGspUuH+NWt8qsunwuJXRWz04C5SjbwDigrHUKvhf3r0ZnJzVvjMTOIeP30DqnE/ZyQVxavQnzVzNkb63wu1l8kHG50pqceuB3zB4YXcN0C+EIQM7IGvu3Zo1wTCzSt0EoUuQ+edY9Ix5q78PtwhN599Bgs4Rtc/n3HmQbLu5kH/iuY2WgCvZo6Tj/X4LMb+i5cFaEBcZ8Df2q585XFvRnwiFjraGXuZ/4kjng30WLwkfSjfAfdEG4AeUY5RGJdPbJORd7sHrqxvhA3LIaSnvGJYPkAj/yygsbBBga5Nvz51J9gnj0jeFBHU4uGjdwFMFbxDbOaIBKQRa6RfqLdfQv9RNiF7ENQfo2R2iFWscZyw7XlhSEMXOi6Ey0Xixkj+QZDJZwEtR1c61z/eIgg2opRua5NWedRPdL55qYcNNyf9JNB97m+JpAN+g5qu4TJuoM1PHn0pssZbLj34EvBVf3f8+Th0HYcXJeO80ffevZd65b7VtdgpW7spIEB+3WYSnowSYbF/3B70lOhyjZjmLhz5nzCMFAVTMdw0uvV9dZ7tbDUdQ2Cv8Z6vSk+Sae0Y702j3qlLNWBMdw587RparvwuBbcc76t3Sedq0jYWqSBgsI2YNpyqC9auC/zgWSUuiJHMlNmwpOYUkrD4+LgzTRh5xRBrNHcEjU6UIxNcscqsz84P92/xymYaQAj37nzBy8MlpFK0Id6aEdu0MeU3VQYeoeUxFHp0t6fRZsQrA1PoOWbB5NMqxaE/jVvAnmJFrcLlWnRgkw9txIFzmOLBpZLf9pGjvHyrsXtku6VR4QqOuHGnlMyjvImWpo6vSmj42ZyZJV6C6VDvsmwkmElw3qI/Jfa4m2aBtM9tXGGp7rBDg5K0vR0f0+VlzNB+FnymgsTLay+ji+UygvR8lZeJPS18rp8jklFF1FIlZehRaweBdi9yosk62bQILdh6wspNber1Fz16jWi4dKkneTDSBOIYk2OQxXbkndbxskH9WW4QMb4Q/1nsTTGE5XDq0wgkn/R9QwnZcz/UV+Cq2KMPzSdhvUwxh/V2UnSZ11bfCmMkw8jOnGMThwzPXGslKijtOG6acP7K05KG6a0YdNTxjSor+X5YkZrh04W20ZAcZpMhcPSEyPQk9zsNIgJXcZB6F14k2UYAXD/xLNojiPKqBz6McUaNQLoMOJ4hNp1APQ4myVt83jAYWTz1u0HrkrO4u4nOz/PpnRlUzWsUjOKCeWoxTKDR5GhHVf9g+Pry7Rx06x9+bMbc/dlzXbA4Jf2ep95fP7SDbHGnbPGZRpjyB2zW8biX2IxicU0ZjENnH/iMutymfsuVGI0idE0ZTRLveOWvGaNdUTs5jbYzQgnBCQtZiR5oQ9URzlVDcgorJG4SS7q2GrQquR5TPSpevwdsqeksETJdqJyFSpFxWm3Qr+W2EuqUNtMyw+OFC3RkU1zoqWPbkyJlrTaRdXask5T6dojYjpLFIHq10oXUP1aql9rQnZyCrcagRCDW5fB3XOZEoFLBK5hJdsyP75lOVvzRUQ1bbdA3uIUKblb1Tw1YMLA7MIaX07is/n0iDNWK8VwTPSrgTA65GKPXAP3PrVv6i3ix4Zv+XeudnXUirJYc4ySqRGkjNYdUPuDI2hNtW/TbK15PxpTt6aP6CCz1Xg0+5vlylYi5bh2z/ya6o5RviubpTH7SbmulOtqnOtaEx4Qa1qXNT0kAROFShSqaQ6ssd9dJx82sWYZSrXhCqPs2G0QrJNkchx3PnX0ubKVk8jHPJnBmrScS292/81zv194917ooW3P/Ab2el18wLtPD1AZFMpQlkLdl8eS8pDia5hkL/afvPTDGr2nf8IfU2+2tnS6A3DkMdhskJei56clK63svgEO0nbcxWKGxyRB17Gkk8W/jd3oOzhvOMwx/hia84so1cxGx4QJLqTvRiamegSyth6DFxXDI/MEf2Nl6Muv+eX9hfPty8XfP3z88q1KnudSn1vQq5rhw5i+e+timlixy/769fzdLg+1MJSKNWI+xWVLSxaTZmWl0lM3KEu0HvcEgq6/EPXSrF6M51rxMisDN0BXxR2a4nPyXlSCTYS/akuXa47ewFkcs5/qDQomaAz/q/8Ish/D/4b7lLDZH4IQXCTJMsOkFBTpHCHQ3cxjipRVUtiCwS93HLHWqm7O+ezc4vms+Az8bBJJYTNMaezNo4Ds3+2elDnzo/g693zudt50El0jndi5uBweIdeinnVlkfWpP4mxHfCioLGqMEQzBcwrGJ0lKjp4pGeJknnIRnjknWS3w6V7ao3qRcHk6Ti+MxA1nWamraryeLEUfPlBeqI3bH/wA/vBxTi02sX/03XV0Xg2oI7yLG9/qs+8thW+TyMGW28Hqu4xuJCf8oul3ecSkehPI+UdN3TWY+uzHg9VRUWPZFtnfJikvBuM8ceo8lLD4vfpWHdirewPL82K4CWx+CYFQr34bPqrBwN6Ppaqs9KIXxHEZ7vRJZY/nindnLvrJgJs4fO64Z0fh264chqXtVToqv0ZfnjT6jqXfEN7xsCve48N/hlQJUyO/oQrePysluddV4c1OkqsALECe1rQt7g+dxvGk13ryK7VLBxbHC/xC6LTqUpWkgwFxTM4rU2hJ/vIUeh9OqIqiKo4cE1NqlEWjWht4iI1NuP0UzWFUbA748I31Y0oTdFY+S0xJJ3WtfRAvukeM85AjwboWvJRj4870Qz+FWkUbY+6ZFSOcs4JhLwuCGmh2dWaS5QLUS77SbmUb0HEvhyb4atHxJRrD3EyxMmYI10jr5DoGaJnjkdpRR/LrSyRNkTaVJE28VqDnDyBo9GuRrh+dRWkb2wKL5XegmjDDykE+qrskLI/3XJDpEO7xDd1qARVk0wkCpEotERn1ybWf4eImXYWoi7foBfJ8bEN+wSTKnd1QvaE7I9FZVNcr7dmtVA9weG6cHjlxGyrF0WIxLwxNKyYk9Y4JuceEJ7pChPnmtoZbFzo1+YwMunWvmDlBkphOumEnQk705KdXdfZJfYIQ5tZjjZYWi0iwtT7AlBKvQDC1oStj011lRhbbeUIa28Tayf7vhZ05yapCUCCSf0YzB8ulvM5XPrBiyePhItaYG6FPF8Taiu70ynCJgXa8ZceohmYPVZCWyQMRW1OhepEvSrUhyA6QXRa/LNrg01lt1872A3TUxPs64VNWfqi08V53cs0+krXhdgAYgOORGMTEkBv/WpnzxetxLj4FWWvd0oh4AKYwfw5IZ9A5x5nEIkDxcS2h3vc6zqSEgSqoe8Otk/6s0FwfwyzvXvTVTUdhJYJLR8Ers1Y1N0OOddYy63QZ0YkFGLeG89ctVMSmCQweSwqq0aTGWtGoeSt4sAXJvsiEORz0uTgNi/+9hjMvMsYvCKK+LU41E8W5Gse7pftR6eH/JGu7CgqrT3pukklFEoolJbk7LrMqu80pjWxBDUPtVOIgDDsDp/1pd+lCbsSdj10VU2Op1NYLcKqmzxIzoudF5S4E6HI8Ug5eQoawI0Prj/7Bn7a+98mHpM1QY7m8LQgzFeEqIq+dAlTSW92Gao2mvyyySXISpCVlubsusrS7zRsNbUK9aCrThQEX3cXE1Ts3gRhCcIeg7qK3uksGEHZDULZexC6g+4WbNRC7KDOhaloAU3O7oIw9qYETNoDWiHKHYCzaU82AWZJY3YXytaYeP3EEowlGEvLcnZdbt/3AsSW24NmEDYrBgKwu48IlDs2wVeCr4evrDnwmrVdBF23Al1dLnQJuIppaABC3rnzBy8MlpFqyg71RdHcoF8RYBZ60iXAPKq53VyNFFii7tSN3YaVUfgmwbrcqgWuGS2aQHTV4nYxly1auPMA1IZOHHz35q1EgXPZooHl0p+2kWO8vGtxuz/1nhiEnqxanPXLMnGcknGUN9GJJdJbGmI8iPHYT25C7RrsdhEv2qBog6INqgkFp17tVEVOdDoxLAYHt3MzWX0dn7TKC9EUVF6UFF2uuk5e1gZdRClVXoZLtHoUsBArL5KWm0GDfFHtYzG/UjRK5CmRp4evrKJv6l2ndvW+xDqPkw8mh9azR41DFeOlvoEb7HHyofoWNN1j/FF9qRDbeKJy4FX/yZZ8LP9iMhLUyjH/p/pytO9j/GEwYLDyY/xRfalk68fSZ5NncMM/Tj5QVcYuufVpsiIdRiJEYOZyi7QB/XoZB6F34U2WYeQ/e584S3EcBLty6K9Is2v60yXZfoSzvUlGg4lP+wisnhPZ/An2A59kZ3H3k52fgFoIs7GWVGkB0aFEh+4nHVpmyHedFN11E1KPqiqbCSKsUsKK2749pEcM/AciSYgkORaVFT0ss3oNCBN2+1j8SxC6Swgd4UyBWoupchJTPFb7xA0QFmbPbxJgHdtrVip5viJGV3enS4hOCrTjb101VYGKKSb4TfCbFujs2sDw7/RLWDXMQz1sXSIQeh1rd/FH9X5OiJkQ85ForOhgiSmjt7M2CH9DkLsS/aompAF2gf0/isPlJD6bT484sFwphlcEsAZ96xLNHrlGbC5yNPUW8WNnx2B3ohV1Zp3QLqHd/cSlpsZ9twPPu2E+6gFgU8lToFl0mk3yPoaZa3oNBKAJQB+j+oremtrF2qFoZj/G7CeFobvE4ZNkxhx3PnX0QenKmeVj/s/JDFY4f3yPT9w9ShPWz2Ayi0Yg1Si/15+D4qAjy95wZDt6ovvOB3bnaS+3znJ/H0Cjw5LnZ5YQ9qJn/NJl0RQgVohsdpDH+bTo4EjOjdHbseytTrmRjAC+ee73C+/eCz2wg6fSZH4DxLBcLAJ8qw8kgDDkVrYYw1vm70t3zAPrNhnuLa6D+WyFFnce+aBuLtMq9GZRw+7gC5gQ/IitA67oyZ48PA4UlAV8RsmvIQsVofUM0NwlGoi3g2L70H2pifRZzPe/lebsFp41RVWFQUBbgAIm7rwf45Eqliu1ECZCwT4GyxiwyTMgITeCQQJMETJYqzm4d/K7gCjuU9XL0DAVJR6/cN5t6E1+F4AHSK9XFttn2uv6sGAvlrCUn7z3YRhodoX+Jz+KcErFFpK2nEA+EBn/5vY/rL66CQSoq2AJJgIbYniLiZmpBQjMumDj+0u/zHqJgc3Z+53pdpy8fVQDGw1bCONW6DOqkjdN++/K6gxKYqFCo+aCUeRXgfV2raQjduVAwS959ifsRFmxkv4KtvRSfGsj/uUfYTNQK0DawjY0IHnYFlQgb3UvYYVlLFNxEG+sqy/vvgwe43gRnf744wM8cXlnT4KnH7m2/DD1nn98CubBjzBQ8Ah+/Peffvq/w1PLnU5Tw4YGIDFu3Ki4i8UMWQTcPG3FM2E7AGV94WN1Zy/uKsJlv4oSfcA9UGqEkxETsF0x0iiPXiLnYuPSXfhaWRHVZt46S5rhB0DBCrm3Va+gvbHO79ljGXs09ado6qKFN/HvV0iKsA3E4u9hgyl8clfwCHAMLA+M5HKRziwb1A8AlRnFkLlP9VB0HXDk/Qi2xwmY/6nFOBkwpqCWVsD7xHzeXos3ChMNHScfspdISpZTsBLd2rZebUynKvWp4g1Gg3lIXKIShrzgLknEKRvBWvoABWYZr3m3aTXHSeSG8K4lJZ7x+aBDKQ3EZCQwTdEXVCJM+Ci9yWrC8skPaUDlOfUfXf4IZR+khu3z9WdVd5r2wegRzH2OlwuAE0pzMipMXoEOTCMJtHI6Xzn1lbfNEtqsHnfQHeOnSbAy9uOZ17BKEIaEGt7qTn/1QBWfm9zf6aKsXHjlAT1ajRX72NZXabNe7MDq3ZtNkSwIJ80SUuA2IaBuRxbyWyd34D+fMFAQYWhfuud2AY51cnlCQ0QjazmfeQilvX7ordkGXPxhIBO3syBYIEkm8gaQnkVQsGIZBGC5YrQoE8AmD26IyCT/aCTZGErI0FlvpMu+Jj1hTZ6IviDFMDvJPXg9VplaTkZt3doc37BHKRZ3zSWc6KDKljltGdde91HqXk8XDK4ywSoqLNPrHP8lC4JFoqoeUDdUnTdqI7WpV9By0mzrYmT5xqvDgfk7KuPWxf53FcY277xZjyu7qTHQ+lA5s86Vle1Yck/VRanFVV9ZEcw1mPo6Advu53R3dVM76cUhZR9eqqoVizWJwcor3CjQyjRuzH6qg6KobGP8of5zqmbj9NOoJI/Am9W3rybmK2+6ahnV3dT6thq/Q9peS9P1FkqMaKBYC1Xzrc1JyY+9yXavn8PhyDo5nz+7M0zQDB+WT948ZgDVtt7BVxihWcCoTv85P7H+mbnzxLJ+sM6sftKfPueWRY4Y0vTQitUXNVmgF3bG6ej/RdNkX4xEtIeun65BeVj9v5yUKuferLfG+mqy/HodG+hS41ximCuN8jDj72r8nbyFBQVmjjaHYll3+2y+GiFPg/60an1qUomGeec24x1LCZGnilDWuwBDZv58MltOPTkijFsMWyq3eOstS65BbVe0AcjphTVzBxPznYVsFkHkc+ywXrJTb7pk7I+tGBuXi/VvMHK5+6NhT3td2W4+6hknLg1LscFa5i2j9XKCm9qLEMRaiiH5VKYdsDkwdRgwHQyVTaC5t/TJYMkTcrhY8yBE3prnpM+SW1yDfOU9xW+Hdp7pz6T2JZNdmVFZa85SxvB87mOWv/8vz3DWkrGm6zyerQbNxyAB8KSebgNU/3O4mHwStyugvRzYLGldSqLKGTVlZnVWULqu8R2K/ZLNqK6iExQGLb3blkvE6w2bLNNsFnbaQNlD8gXcyx6UFXHuYfIfc5LN2uhi66Z7ioIPgekcCBljRWEbf/zvwdAkE7nArKzNwoM3R5PhrTsVpxer1Z//FRXAYRttsoKSh6R/0SWTisQHfreWIuIXfYZrBv1MlT3hL3zibx71NamtPBQy7vOF3FdfJBdSzpMW5Ys7zbSTXZhiVnJm18tmJ+R1rFc0hHj38i71stIn2g5PM5St4jCfNjIouFzp/dmx5fwvzhCjA/YLvptV1IHEbvK+lVrK0r279gSIaeXVymVboL60VNqjiv1nWEgYaZ+z3DJfWZWrzBNqMBGZfWgQoMcIYWbvY/nIsIO6kVF2rvWnkfUYvJxWAIq/BS/KJFL5ml/eXzjfvlz8/cPHL9+yCc9pmvW51NO2qQnqkcNwvnvrE2uYpf369fzdLo2yciTqtG7zSVWFx2SpaPyYVFjFhmTh1QvfgUxLUsGrhJZP0lRenjOVslEySHuWLlcYS5T5mP0smhwQ6Rj+L/4BpDWG/0cVJkmpCBmnvRNFGBbECa1lHWbWYlWv1uBkW93qFaYiK1KUc/VqPb96f3F2df7ls9kECKQHnanbw+runH38dvaPS20yI26HrEvgQKWfB/dh8C/YAq/Cpcc3OZ7vrFs6PdVCODUnjBpVIVA4Efv72vLr51i2eX26ZdbLRitltMt1aFMmgxR0M6mMr1Oco02uT8t8n7Y5P5taCzUTBmkBbDh78ABNOC1EzUJ8Y339f5b/tAhhB8Koyqk1efQm33kgcu757HUcVfTlxY0sd4IvK81jEP0q1+oDjAwT8B4ufnmbnq7Jgqx1uN45fJnooeB9JTJe/stYnZDQ8mESyWzyMC0B11lyXTf5f6URqq5z69rn1zUoB1ORVGeYWOeomUNtHIO9K517ObdO7ZdTbXCMv6d6BWLmL6nen7z/bYH2Y/5g3QfLMH5ULlL+6nhlHsHIeoBO938XWq+SxNB2BLP+R/9EkStnni9nnDNnnjenDz+k81VV3Ec9dY2STZrNIvgz4XQHJtGkJkvPYEE1Tn4zSoAzSIIzToQzCQF3kxDXOilud9R511XZSI2r7Uc2slqSx1Yu+NYJbPUnIfLAU9LOgnDs5MkAd7OPCV2ms1I1prozVLkQDiTbtkbeVq95Jlaa2TTWZweVV5LKBJCbxVgrizvJxZxKDhM2SzRoP+CtDaenTQrKbiPFkaQZQNrcwd2vcJWPHPfelPxnJQVfQNGxLtLUXWBJVKvsnh6gWiw6c7diN9m/RlIpmCdYcGgGeXUJVqt1MsEXtkSlVCYLtOJ4/Q/P8CzXhgYvvJn37HLrmTSG5bPCUPoDF2tk93o80JEcAiaux86c4QDAVicTjRVDZl4czJO8k3B4WvlirYO64tyDeZzgDoN1eDSRrfslKNeaY0hq4H1gX68v4085xUyfQojr5dEHfx5jONlVN2VB+IU3n+J+M1YX28Pvilp8zbt1M1Jk1z55wTIe/58RKhDfxKKS/Mo31lvGV4BxfPH6z7xiytRiBYlgDmfBA5bScsM5d0x4WRU/zLXBimo9uhFsiN7cSmXKNJ5nrfIyL+Fyjg3Zebs88+YDFMfQGo+t/1U0TtCNB5hr0Q+1fbo/eYu9YDWJ2VLq/84//NFXdm2VFoXBql8nyjZP/vr1yvr23jq7eG9dXp1//Gh9Ozu/Ov/8My+oF4Oy43KIPdv6R7BkVZuSBb6ArRO9C03DScErO+3RLVsAyWSs+8Y6v+43WBzMsNc0O2V5v9PAAkF7uCrdcMWsD3omTL+w41GAkklnFMvwzL1nrHY2mSxD+6RXnSuaWLdsDRfMN5Yt6efgBVqGXjMrES+R6LJumaLfsiFyPU5ymTFzmY1AauLRfUZzAgMCOx/60M2p5f028Rbr2jQPXhxxFZmq3yj9/OXq/SkvePPC1JD5fdDouiEhcqE67AJ4zrOXNcfB8uExnRo2Me4MC8WtNIr/BPY9gg9SI09BiNuH54bpcso9NREG9vZxJd7IBU8l84prPGHzh2s0eoHOBC/819V6TGtZcMvCZd1Lo92O48/BCjoDLDAn2StWb875NVrXB1sXpxuLv66rLErXDYZWPvLgxnH4AzzMn3vTm/Wj3SUMOPT/BfewhyMXa8zw4c3OuoXIPks/3xTC9vnu5p6sGafRQKTtBHVgkBHgqJcrxHdaI0CyvvnXKJgnXpO8u6DA4Lf1cMU16xwmvNPGkGg0kBuRHB2WVQE3iL+wGnB99mVfvoozSP3H4AWLlCdXy+lB6zau2WU3cmIt+7sqsyrJdIlEaoTytSjeR9V7TmJ+RbsPQQBegMNq0t8t79nocX9/cmNb1PO8Cv4rkhNYsosjWi5QgW3ms6cp/zabWDFNQ53HKPqKIwUBXVdw5utxy/lko1p3KfJabgrVx9qJRvdmRFZQmZQlkUqk4AAMlEAWhpKcVDx5nZakeLRu8oaF1ctScjeyfHmybz7KgH4Kqw/LQlSj3F/PUPBp+dibGrZAERBO0o2ZzE51KiGq4ibqkGNL2DkLiphF6E6wv9HCVawqjn0Z8r8/+T1xdnJp5n8M+rk/+eCtDU8UpffgIby1EzEkRGISHjhR1QXEcx7gJrYz3gXPWHAQ9k0vgSockSEHgBTQ5ST0F4pCiQt2rcOrGPoTloxVfBhgGG821kvpCv71PuJF9tuvl1dfPr2/yCHQotfLJjz0ouVMJPanIEHMqtIHrL3sWdPDKpTdWBM2oA1KjbB+sFgAzXobLFbV2tGhhphrSSeaotEWbvkzyqJxBeSrNFEMbmNRkkgB6gMNBsr2ixtG3jt/EpcXRZc7dc3fEO7flNc+5w6c/O6KMygpl657Da4scNbn3WKej9zDEumD3LNjEU3clMb8kBPmFzIMDPZc8wi2tfMrezvq/W3R/St13nL7em5HV7ySKkqA75mfp/LU6nlpLT20ut5ZMjNp3e1E8GwZjEH30xd3BMtnJXY1ObXqtKJEZQMfTj7vN1dQ/9TKvMb2wDvlLO5+Sl5pG0mTwjjwklsyERa5GljVDTwBSSIWd8sxk/ZbMR977ZTtthfMBcz5Hy/k701btzCgp0WA5xcgxrg9RKf4bgXrhAV3pfe17mLn+c/ubPHo/tmZgxr+GrGFkxWH2v/47s+n44p2VPtCzrZUNSEMi94HMnrrda1TUk12dT3tsvd+NYqob4Az0ZkXMcdrArvwt5KGguC7v+4A/7Uk/2SxcJIq8OlN8pclty7jx3G5y8nyDdbnXNh4i7amTmHDk++y44A7vw5Tz5IqDSX+abLT4tzW67h0p3n/8aV0RQONuh6vE8KdEFd57SEoWmg2FEVDtYek+ZotF16+HoON3OheBZdxiEEpzU3CHxiLf81uHKouywKVNNagiU1eo+hu1jYy+9d8a9yqCtySi3lqGPnc4xhZpUyQjcPV6b5QCXG6YxwLZaCY+TTKs5bGoCIgUg7RlTGWsk1CA9AKuq+/ZO0mjAyr38ihwhcvDVveJnoePWIO1K0cq8R4LwtsaxqbBGHoTeLZah16ZUFIIWaM94r4MQs18iC8pi0sapaO2y7jElQzWnYMZ14LdKkIXAADRfO5/CIWgMzf/TbpO0u1K+riemyRF4vmB9hfBUEjTdMn0Pe1dG8Vnbu17ryJy8PyfqRoi5/ZxX28W4yT30p7CD+/Cx709uwzPhVG502WCgLojfUEz/RhNq3Ix4/u3AuW0WxlqwIiFXOkXqqC7GBLqiyBxWCJ6xdOP5tB1R+ZsmYseq1QBFWVs0/ud2QMsNJ0otUsEH4rZUMIqYhMS5CZdGjbuiUpgo+H04TBy5xV1ePhfKHQ8Ccc1DKcs/C6oplM9oH1HRPA3JAd4QxNBMtw4mETMxAIMwp+rKu99uQ/POIRdqhvS5YdFS7nLJ0muAcf/ykIVywVIwgjb8QfhLhZ0dJ9GDzB8HyWjZqoME+mwcnnby6EYtexS9YT/6TwSRUzpkwNVDS1L/u5UADGQSOTzX2p4woH1MHJF+wOey0qM6tiaiP8e9En+29uxHKKB4Lq14ygsVptSLVy6sUDLWba1bGG1dOyzjStRNvqxI0YLqjgVI20MKvqtj44U+741dTXZcQiLP3S9woGVUcha/8u9t6zuyCEDUd/GW4RDu9PuYRMw3S15CyEMKq8J/v0cDERfWaTfcm7X3HM8bB9VE94x4X5DAWv3t+rXY112cDyaHcGFjoyDDnIK1HIL+mCVLyueBToyde5x16o8abJXsS8GhEdKGTisHXRJohzwQ7t3UYQh91SI4Yjrs+HcLpis01YbH6i8ajXJXudsNZseH2DA0T1ZHVjkro1OW1ISjcgo0tI6NrkcwPSWWFUq0nmpuRyPVJZ0TVzErktedyMNB5qi7rVJodrkcIVZHB3RPCmSOACAbwZzrEW16jlGEu4RR2nmH+jpgMOsQvusJQzbMAVdsUR1ucHTbnBRPTL+cz/7jGZlTB7IxT/uy94T64VByfOYS/umTOLjEfMNcS33IRCnLA3Thh9uCYL+SVR7sYchQiwEbTlzmMvJruwe2Jz/JWqF/HqHBaMydeQCYKpdQ9DuXOTijRIimFFmeILUSPWS+Ta8s0wfYA7wqeUeErGzU+bFkNYqzL8XfGCWF4Fm9CgTShQY/ozpT513kz+xdMMf6ZiO7thOjtgOTthOLthN1sxmxWsZm5GCmxmFZO5EcJMS5QNC++n1yUbyoiGMpKBa3gZv2DGLXTDK9TlFFryCcbHYfR6bfiDKoidQYRdI2zWeBFgX8KkJzUW9iNZUu5xDbidvW2PEifljlP6JKVPUvpkvfRJef1QEiUlUVISJSVRUhIlJVFSEiUlUVISJSVRbjmJ0sAdpVRKSqWkVEpKpaRUSkqlpFTKzlMp5R2YEiopofKVEipVAYmugz6Z2EEh9iMd2tRVGKh4DhTFgjqMBWlmjMJCFBY6hLCQRBBsJzakWU8UJqIwEYWJKExEYSIKE1GYiMJEFCaiMNGWw0T1PFOKGFHEiCJGFDGiiBFFjChi1HnESLMZU/CIgkcHHDzSBRsUcaTVVfA2OVCrQL7uQNEOrtp2srBs72kRr9g97/GTFDOquPLw6nQoJ4/qdtQgtKluR3NCmup2UN0OqttBdTuobgfV7dhE3Q5T74bqeFAdj8Oo46HUeKrrUfptN3U9KqBj9/BcMdFV4Pz9bxzgEEjfY5Cem0QC6wTWCawTWCewTmCdwDqB9QMB69VeDoF2Au2HCNpzmk/g/dDBe27CFSAevNWPwfwB2p5DFz548eRxP07FUPW8+Kbm8QF6hVgIxxOOJxxPOJ5wPOF4wvGE4/cXx5s5NwTfCb4fCHxXKDyh9gNE7Yp5rgTr/GSMnTpbYwOR9l0umqSaDyqZRCWT6CSNmtWSVAuJaiU1ZbcMWK7GbFcL1quEYjJnwdqyYc1YMYOuU60kqpVEtZKoVpLViv6spEEN6NAqWrQcUVGtJKqVRLWSlHxjqV9KlZKoUtI+bO9UKYkqJVGlpA41rUTbUpFTpaTWlZJUWzHVSTKaRMOppTpJuxYHEhGFQiDoZy/+9hjMPFQNbz/SNTNdrnGihnjU4SVqZgRCGZqUoUkZmpShSRmalKFJGZqUobm3GZpVXg2lZlJq5mGkZmY0nXIyt5CTWYcd6wKMZ2a4CMI/uP7sGxic94lloZpH+4G8CxNH6JvQN6FvQt+Evgl9E/om9L236NvEsyEETgj8MBB4QdsJhW8BhW85Il6YZD0QF9NPMHy/YLiYNgLhBMIJhBMIJxBOIJxAOIHwvQfher+GIDhB8MOC4ELXCYAfLgAXc5vA7/+czKD/HMvl8Pg34bqv52gyi2oWJhJNFJB4A2CtRe3JQ5Jjjl8HYidAZzMgOxkjoWtC10eLrncTML+xPvrz79ZywQGAwpNjL1ehZyZkkSI/P5ZaSXwdvNqfC3fHevYBvKTTDZcMhrdwCVi0FBtKbYCuLtwHfHPzNgulAKVw9x98vIdH5oXZv0Z23pjbazcahp5+3jw7kKB1fOossp01fHfsBy+WFp7YbdMbZKBan2zgjbQjHJI2iHQg0uG1SIe8+NNNqJR2SC7aa+KBC3mLxAMzUJvjHUpcPSIciHA4DMIhUXJiGjpmGurk2+eBc9eUQ9J+MdT/zp0/eLD6+QCinap9rL0l1+kWhxTtcC3k3CCpCjJVQaYqyPWqIOeWENU/bkrtGVB8jam+FpRfCb9mTgG2pQKbUYIGXaf6x1T/mOofU/1jq1VmVSXZaUB6VpGf5WCK6h9T/WOqf8wpRTOPlCofU+XjfdjYqfIxVT6myscdalqJtqUip8rHbSsf5zZhqnlsNH2Gk0o1j189wTQfOSgEfS5jAJsX4HKHkf/sffKiyH3w9iP0o+x6jerHmvvz+ao7HBdSjoCiQxQdouhQveiQciFRjIhiRBQjohgRxYgoRkQxIooRUYyIYkRbjhHV8UspUkSRIooUUaSIIkUUKaJIUeeRIuVWTPEiihdtNl7ULHrRdRhJHWgoBJOwwmeXsaTtnaCp6nmNUJL69tesfLLJ4qKq0VINlBrkN9VAaU5eU4VRqjBKFUap2AdVGKUKo5uo9GHo3FDVD6r6cRhVP1QKTxVASr/d8JGbZWiya2SvelYR2AMkBPduOYnP5tPOM0av1vvyNqB+5Vhq4H6DtvYonbRyNJRaSqmlh5BaKiGB7eSXVq4syjWlXFPKNaVcU8o1pVxTyjWlXFPKNaVc0y3nmjb1USnvlPJOKe+U8k4p75TyTinvtPO808ptmXJQKQf1lXJQjcMfXUetqiMVME293puS/6yLBJgyr8tyMQiCmQxlN/XeWF8j6MvdKjmtyfrmud/XTfkI7568OcwTOKLM6XMn4DEmRh0A4JSx/NAS4uMfnuGRrg2dAZMssjkmMx8aiOxejx0DmJiIzIOksM0gPaNEvgBmNBfDY+C4iOth4wlDf+rdaCJ4f5KCedCAezcrMEVvxffX1xoL8sQnxRaTczPKNXCGXiy2cLN+mMvNmsM7iz+vM0vMhiVmi4tsYQNvCnFAxe2VnUvbYIYvDSiCwkkhQfjtNP8w8K7kx8q+cYETM7a1cidGSfv5IyXEQk+AfDJRg8LlWaxe+XS2CkGHrAX+5nhFKJ9ME/uT5F4W5+hyFcXek5ipoj1U+KU2a5RvAF/n3+cA6FQ7gJhANKFSN//4D+tEtx2cXImcrWW0BFGtOEhjy9qFteIt4Ks5yA2+SmSTPGVkvTz6k8cEvEfLxYINCO9Nizr9c659tHVy6XkMkM78Jz+OLEy6OrUe43gRnf74Y9rE1HvGXx7AHUcP8YeHJazRiP/9B37rjyeVWUncfgvR4uza0+XTQuEG/K5OiuI7cP/URGHE+rkK3vmTkpBYRmEwjiI8E9Pciz806ZdCs//qgtamRABobsoKnOYzbPzIh10EYewgvWiUsTuqNBtjkerFuinRrsUAI6kUrd4t+qNXfl1ValVrtUudrS6lkzTaUM/yu2kEUG26nHmtdlQeH5b2FtOcmUyVNeu/66XXlF+fOx5YeTF8z8Kx9nvxoZi4I8STHwX6ds478GKv4AMefYz//v9gLoFVEN3TIojBi1lVxaSkLkl32efrz7vrErT1AHpqU5YEU4y1J2fkYjf6njoSD16McZ/iohI+56WI8lzBTRoTmKRSlAZ5OK4Jvfs06O+kX41M3h/hCymXbDJIhZZo4zj50PVGiVI7n3Zqr7BJG3+AarexWZxsOptOEykg4eTPeWdwk4wD5o+ACAEDxa4tWyf2jcoSoTZH9s8A0z+Jq0BpsoMZFO965Nni9tXZ5d+dy7d/e//u68f36+mx/Sjg/RoM5ZdgJD+ay6OgoOCHeeFgaDsx00ShRcORUIzhQPUKTlZdJAMylj5nL0pEMk4+KHtppk5FVWqhRkIwWZ34o6ffv3jifv3dq/GWlXmZs2IL2vXdbYNbSfqngO11UekuI65Z4y6ma7PAnUYDuRF5t+h0dy0kgMBm1Jcu7oOlSXp5qltuediYnTEhfFu6oWg03ZnvRmPxoOtMD27YWdV9dkVfsXV891alN8LfVbc9Bi+alKdy6Z19/Hb2j0vljSC78hG8uKuoP7I+uLPIG+rfbizvwC/vL5zzq/cXZ1fnXz436QdY2nNYF2zz6Jd0Q5l8kH+RspczLM6jO5/OvLVK3C/nkzgIZpEN4D723VzaZ2EDEHatsANkn5vJbBSDZaM74X+5wj+cDGvuEMP8DiBH8CeFlNWEphlnhj5S8itoY8ZV7lgyWOvfrL4gWvpl763KZmws/5K9TLZU44w3WrK/8PyKLe4vtBPQTkA7wSHsBKg5CSTQq83Lozdf60t+tSHPABDyacGzGpLfclwYtsFiU/8FS0TEp9IBp124ue7jhf0b5UnOso1PSSFd7QwVTjVCySmCNaRTeNS3KI4BjkShxEbop8aeYbhvbMYHEHtPhQ9gNOTajgL5AGsfQMqrJEeAHAFyBMgRIEeAHIEtOgLCtJMr8Op0QDIT2/MDiEUml4FchiNzGUT+rtJtWF/V1mWo7S70avsKJX5CqY+wSf/AaJvsdBfpvbFW7uL+1PLmuDX2/gf2vaCCLLQZAA==");
+    reboot_native.importPy("tests.reboot.greeter_rbt", "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");
 }
 importPys();
diff --git a/tests/reboot/greeter_rbt.golden.py b/tests/reboot/greeter_rbt.golden.py
index 40abb578b..15e2e8f89 100755
--- a/tests/reboot/greeter_rbt.golden.py
+++ b/tests/reboot/greeter_rbt.golden.py
@@ -21745,7 +21745,7 @@ async def Greet( # type: ignore[misc]
                                     request=GreeterGreetRequestToProto(
                                         __request__
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -21774,10 +21774,10 @@ async def Greet( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -21935,7 +21935,7 @@ async def TryToConstructContext( # type: ignore[misc]
                                     request=GreeterTryToConstructContextRequestToProto(
                                         __request__
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -21964,10 +21964,10 @@ async def TryToConstructContext( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -22125,7 +22125,7 @@ async def TryToConstructExternalContext( # type: ignore[misc]
                                     request=GreeterTryToConstructExternalContextRequestToProto(
                                         __request__
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -22154,10 +22154,10 @@ async def TryToConstructExternalContext( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -22321,7 +22321,7 @@ async def TestLongRunningFetch( # type: ignore[misc]
                                     request=GreeterTestLongRunningFetchRequestToProto(
                                         __request__
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -22350,10 +22350,10 @@ async def TestLongRunningFetch( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -22511,7 +22511,7 @@ async def GetWholeState( # type: ignore[misc]
                                     request=GreeterGetWholeStateRequestToProto(
                                         __request__
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -22540,10 +22540,10 @@ async def GetWholeState( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -22701,7 +22701,7 @@ async def FailWithException( # type: ignore[misc]
                                     request=GreeterFailWithExceptionRequestToProto(
                                         __request__
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -22730,10 +22730,10 @@ async def FailWithException( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -22891,7 +22891,7 @@ async def FailWithAborted( # type: ignore[misc]
                                     request=GreeterFailWithAbortedRequestToProto(
                                         __request__
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -22920,10 +22920,10 @@ async def FailWithAborted( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -23081,7 +23081,7 @@ async def ReadRecursiveMessage( # type: ignore[misc]
                                     request=GreeterReadRecursiveMessageRequestToProto(
                                         __request__
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -23110,10 +23110,10 @@ async def ReadRecursiveMessage( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
diff --git a/tests/reboot/greeter_rbt_react.golden.js b/tests/reboot/greeter_rbt_react.golden.js
index daad00650..3c5104132 100755
--- a/tests/reboot/greeter_rbt_react.golden.js
+++ b/tests/reboot/greeter_rbt_react.golden.js
@@ -1882,7 +1882,7 @@ class GreeterInstance {
         const queryRequest = new reboot_api.react_pb.QueryRequest({
             method,
             request: serializedRequest,
-            clientCanAcknowledgeResponses: true,
+            clientContinuesQuery: true,
             ...(bearerToken !== undefined && { bearerToken } || {}),
         });
         let expecteds = [];
diff --git a/tests/reboot/ping_api_rbt.golden.py b/tests/reboot/ping_api_rbt.golden.py
index 5d1aa88ad..1f5909016 100755
--- a/tests/reboot/ping_api_rbt.golden.py
+++ b/tests/reboot/ping_api_rbt.golden.py
@@ -21340,7 +21340,7 @@ async def Describe( # type: ignore[misc]
                                     method='Describe',
                                     request=PingDescribeRequestToProto(
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -21369,10 +21369,10 @@ async def Describe( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -21494,7 +21494,7 @@ async def NumPings( # type: ignore[misc]
                                     method='NumPings',
                                     request=PingNumPingsRequestToProto(
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -21523,10 +21523,10 @@ async def NumPings( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -24163,7 +24163,7 @@ async def NumPongs( # type: ignore[misc]
                                     method='NumPongs',
                                     request=PongNumPongsRequestToProto(
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -24192,10 +24192,10 @@ async def NumPongs( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -26918,7 +26918,7 @@ async def ListCounters( # type: ignore[misc]
                                     method='ListCounters',
                                     request=UserListCountersRequestToProto(
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -26947,10 +26947,10 @@ async def ListCounters( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -27072,7 +27072,7 @@ async def Whoami( # type: ignore[misc]
                                     method='Whoami',
                                     request=UserWhoamiRequestToProto(
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -27101,10 +27101,10 @@ async def Whoami( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -30736,7 +30736,7 @@ async def Value( # type: ignore[misc]
                                     method='Value',
                                     request=CounterValueRequestToProto(
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -30765,10 +30765,10 @@ async def Value( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
@@ -30890,7 +30890,7 @@ async def Description( # type: ignore[misc]
                                     method='Description',
                                     request=CounterDescriptionRequestToProto(
                                     ).SerializeToString(),
-                                    client_can_acknowledge_responses=True,
+                                    client_continues_query=True,
                                 ),
                                 metadata=__metadata__,
                             )
@@ -30919,10 +30919,10 @@ async def Description( # type: ignore[misc]
                                 # them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
                                 # An older backend doesn't send an ID and
-                                # doesn't expect an acknowledgement.
+                                # doesn't expect to be asked for more.
                                 if __query_response__.query_response_id != "":
-                                    await __stub__.AcknowledgeQueryResponse(
-                                        IMPORT_rbt_v1alpha1.react_pb2.AcknowledgeQueryResponseRequest(
+                                    await __stub__.ContinueQuery(
+                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
                                             query_response_id=__query_response__.query_response_id,
                                         ),
                                         # The same metadata ensures we're routed
diff --git a/tests/reboot/react/test_reactive_reader_flow_control/index.tsx b/tests/reboot/react/test_reactive_reader_flow_control/index.tsx
index 8885d4fc6..248ee4b51 100644
--- a/tests/reboot/react/test_reactive_reader_flow_control/index.tsx
+++ b/tests/reboot/react/test_reactive_reader_flow_control/index.tsx
@@ -7,10 +7,10 @@ const ID = "greeter-flow-control-test";
 
 declare global {
   interface Window {
-    // Releases the acknowledgement of the response currently on
+    // Lets the query continue past 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;
+    continueQuery: () => void;
   }
 }
 
@@ -24,8 +24,8 @@ const App = ({ url }: { url: string }) => {
       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
+      // `useGreet` so that we decide when each response lets the
+      // query continue: `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.
@@ -40,11 +40,11 @@ const App = ({ url }: { url: string }) => {
       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.
+        // `window.continueQuery` 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<void>((resolve) => {
-          window.acknowledge = resolve;
+          window.continueQuery = resolve;
         });
       }
     };
diff --git a/tests/reboot/react/test_reactive_reader_flow_control/test.py b/tests/reboot/react/test_reactive_reader_flow_control/test.py
index 2c0aea740..ff098abab 100644
--- a/tests/reboot/react/test_reactive_reader_flow_control/test.py
+++ b/tests/reboot/react/test_reactive_reader_flow_control/test.py
@@ -9,7 +9,7 @@
 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
+# while the browser holds back the response it is
 # showing, so the backend passes through all of them and may send only
 # the last.
 ROUNDS = [
@@ -24,10 +24,10 @@ async def test(context: ExternalContext, uri: str):
     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,
+    each response back 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
+    hold 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(
@@ -72,7 +72,7 @@ def wait_for_message_count(driver, count: int) -> list[str]:
         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.
+        # back rather than continuing past it.
         rendered = await asyncio.to_thread(wait_for_message_count, driver, 1)
         assert rendered == [message('tasty')], rendered
 
@@ -80,15 +80,15 @@ def wait_for_message_count(driver, count: int) -> list[str]:
             # 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.
+            # response the browser has not continued past.
             for adjective in adjectives:
                 await greeter.SetAdjective(context, adjective=adjective)
 
-            # Let the browser acknowledge, which is the first moment
+            # Let the browser continue, which is the first moment
             # the backend may produce a next response.
             await asyncio.to_thread(
                 driver.execute_script,
-                'window.acknowledge()',
+                'window.continueQuery()',
             )
 
             rendered = await asyncio.to_thread(
diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py
index 42c362b71..a196ed5eb 100644
--- a/tests/reboot/reactivity_test.py
+++ b/tests/reboot/reactivity_test.py
@@ -23,10 +23,10 @@
 REACT_STUB = react_pb2_grpc.ReactStub
 
 
-class QueryRequestWithoutAcknowledgements:
+class QueryRequestWithoutContinuations:
     """Constructs a `QueryRequest` the way a client from before
-    acknowledgements existed did, i.e. without
-    `client_can_acknowledge_responses`.
+    `ContinueQuery` existed did, i.e. without
+    `client_continues_query`.
 
     The generated gRPC stub reads `QueryRequest.SerializeToString` off
     the class when it is constructed, and the servicer registration
@@ -37,24 +37,23 @@ class QueryRequestWithoutAcknowledgements:
     FromString = QUERY_REQUEST.FromString
 
     def __new__(cls, **kwargs):
-        kwargs.pop('client_can_acknowledge_responses', None)
+        kwargs.pop('client_continues_query', None)
         return QUERY_REQUEST(**kwargs)
 
 
 @contextlib.contextmanager
-def query_requests_without_acknowledgements():
+def query_requests_without_continuations():
     """Makes every reactive reader send a `QueryRequest` the way a
-    client from before acknowledgements existed did. Both the generated
+    client from before `ContinueQuery` 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] = []
+    Yields the IDs this client was driven to continue past, which must
+    stay empty: a client from before `ContinueQuery` existed had no
+    such RPC to call, so a backend that kept the responses coming only
+    because this one called it would strand a real old client."""
+    continued: list[str] = []
 
     class ReactStub:
 
@@ -64,16 +63,16 @@ def __init__(self, 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)
+        def ContinueQuery(self, request, **kwargs):
+            continued.append(request.query_response_id)
+            return self._stub.ContinueQuery(request, **kwargs)
 
     with patch.object(
         react_pb2,
         'QueryRequest',
-        QueryRequestWithoutAcknowledgements,
+        QueryRequestWithoutContinuations,
     ), patch.object(react_pb2_grpc, 'ReactStub', ReactStub):
-        yield acknowledged
+        yield continued
 
 
 class ProxyingGreeterServicer(MyGreeterServicer):
@@ -282,11 +281,11 @@ async def get_greetings(expected_number: int) -> list[str]:
 
         self.assertLessEqual(len(greetings), 3, greetings)
 
-    async def test_client_without_acknowledgements(self) -> None:
+    async def test_client_that_never_continues(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
+        Tests that a client from before `ContinueQuery` existed, which
+        never asks for the query to continue, keeps getting new
+        responses instead of being stalled waiting for a request that
         will never come.
         """
         self._can_accumulate_next_adjective.set()
@@ -301,7 +300,7 @@ async def test_client_without_acknowledgements(self) -> None:
             adjective="reactive",
         )
 
-        with query_requests_without_acknowledgements() as acknowledged:
+        with query_requests_without_continuations() as continued:
             await self.start_accumulating_adjectives(greeter, context)
             self.assertEqual(["reactive"], await self.get_adjectives(1))
 
@@ -310,7 +309,7 @@ async def test_client_without_acknowledgements(self) -> None:
             # Unlike the tests above, this one never sets
             # `_can_accumulate_next_adjective` a second time, so
             # nothing here ever tells the backend to carry on. A
-            # backend that waited for an acknowledgement would still be
+            # backend that waited to be asked would still be
             # holding the second response; getting it is what shows
             # that this backend is not waiting for one.
             self.assertEqual(
@@ -321,10 +320,10 @@ async def test_client_without_acknowledgements(self) -> None:
             # 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)
+            # the client asked for, this client would have continued
+            # past them and sailed on where a real old client, which
+            # has no `ContinueQuery` to call, would have stalled.
+            self.assertEqual([], continued)
 
 
 if __name__ == '__main__':

From 257e33dab3c6ceff7ec6e0023aecd64f566bd540 Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Thu, 10 Sep 2026 13:48:22 +0000
Subject: [PATCH 06/13] React: send reactive read responses under a window

Gives a reactive read that keeps up with its backend the same
updates it would have got without flow control, and says so when
one cannot keep up. The flow control added earlier in this series
produced one response and then waited to hear that the client had
processed it before producing another, so every update cost a
full round trip: a client that could easily keep up saw updates
at the rate the round trip allowed rather than the rate they
happened, and a burst of changes collapsed into a single response
even when the client had room for all of them. A client that
could not keep up skipped the states it missed silently, leaving
a developer to work that out from a screen that updates in jumps.

`React.Query` now sends up to `QUERY_RESPONSE_WINDOW` responses
before it must hear from its client. Every response carries the
ID of its query and its sequence number within that query, and a
client names the sequence number of the last response it has
fully processed; the backend returns one response's worth of room
for each response between what that client last named and this
one, so a client that processed several while a single
`ContinueQuery` was in flight names only the newest and is
credited for all of them.

While the window has room the backend sends every state change as
it happens. With no room left it holds the response it has ready
and keeps asking for states, merging each one into the response
it holds: the state it carries becomes the newer one, and the
idempotency keys of both are kept, so a mutation the browser is
waiting to observe isn't lost along with the response that
reported it. When room arrives that one response goes out
carrying the latest state, with `skipped_updates` counting the
updates it stood in for and `stall_milliseconds` saying how long
it waited. A client is therefore at most a window behind however
slow it is, and a client that keeps up loses nothing.

Past `REPORTABLE_STALL_MILLISECONDS` -- 100ms, about where a
person stops experiencing an update as immediate and starts
perceiving lag -- both ends say so. The backend logs, at info
level:

  A client of a reactive query to `Greet` skipped 20 updates
  because it fell 207ms behind

and the browser prints the same about itself to its console.

Asking for states while there is no room to send them is what
makes that count possible, and it costs the backend a run of the
reader method per update it then merges away. It also means the
hops of a transitive reactive read don't each hold a window's
worth: a hop with no room merges rather than letting responses
queue up behind it, so a reader reading through another reader
ends up one window behind rather than one per hop.

The window is a constant, at 10, rather than something we
estimate per client; a `TODO` records that. One would behave
exactly like the round-trip-per-response protocol this replaces.

`QueryRequest.continue_query_response_id` and
`QueryResponse.query_response_id` are replaced by
`QueryRequest.continue_query_sequence_number` and
`QueryResponse.query_id` plus `QueryResponse.sequence_number`.
Neither of the old fields was ever released, so their numbers are
reused rather than reserved. `continue_query_sequence_number` is
`optional` because a heartbeat is an otherwise empty
`QueryRequest` and sequence number zero is a real response.
`client_continues_query` still decides whether any of this
applies, so a client from before continuations existed still gets
responses as fast as the backend produces them.

Both transports share `_windowed_query()`, so the websocket and
streaming paths can't drift apart.

TESTED: `//tests/reboot:reactivity_test_py` and
  `//tests/reboot/react/test_reactive_reader_flow_control:test_against_local_envoy_py`
  now assert what a window guarantees -- at most a window's worth
  of responses on the way to the latest state -- rather than one
  response per continuation, and the browser test renders exactly
  11 of the 31 states written on both the websocket and the fetch
  transport. `reactivity_test_py` also gains
  `test_reports_a_stalled_client`, and the browser test asserts
  the console message through Chrome's own log.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TQxdTEi8qsBfxCcuLxrNmQ
---
 rbt/v1alpha1/react.proto                      | 127 +++++--
 reboot/aio/contexts.py                        |  84 +++-
 reboot/aio/react.py                           | 358 +++++++++++++-----
 reboot/templates/reboot.py.j2                 |  31 +-
 reboot/web/index.ts                           | 106 ++++--
 tests/reboot/echo_rbt.golden.py               |  62 +--
 tests/reboot/greeter_rbt.golden.js            |   2 +-
 tests/reboot/greeter_rbt.golden.py            | 248 ++++++------
 tests/reboot/ping_api_rbt.golden.py           | 217 ++++++-----
 .../BUILD.bazel                               |   1 +
 .../index.tsx                                 |  42 +-
 .../test_reactive_reader_flow_control/test.py | 120 +++---
 tests/reboot/reactivity_test.py               | 132 +++++--
 13 files changed, 994 insertions(+), 536 deletions(-)

diff --git a/rbt/v1alpha1/react.proto b/rbt/v1alpha1/react.proto
index 6eeaf8052..28f9d4f44 100644
--- a/rbt/v1alpha1/react.proto
+++ b/rbt/v1alpha1/react.proto
@@ -19,20 +19,24 @@ message QueryRequest {
   // Authorization bearer token.
   optional string bearer_token = 3;
 
-  // ID of the `QueryResponse` this client has consumed, after which
-  // it wants the query to continue. This is how a client whose
-  // responses arrive over a websocket continues its query, on that
-  // same websocket, and it is the only way that works for such a
-  // client; see `Query`. 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 continue_query_response_id = 4;
-
-  // Whether this client asks for each next response once it has
-  // consumed the one before it. A client that does not set this gets
-  // responses at whatever rate the server produces them, whether or
-  // not it can consume them that fast.
-  bool client_continues_query = 5;
+  // Whether this client tells us which responses it has processed,
+  // so that we can stay at most a bounded number of responses ahead
+  // of it. A client that does not set this gets responses at whatever
+  // rate we produce them, whether or not it can consume them that
+  // fast.
+  bool client_continues_query = 4;
+
+  // Sequence number of the last `QueryResponse` this client has fully
+  // processed, which returns to the server the right to send that
+  // many more; see `Query`. This is how a client whose responses
+  // arrive over a websocket continues its query, on that same
+  // websocket, and it is the only way that works for such a client.
+  // 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. A heartbeat is an otherwise empty
+  // `QueryRequest`, which is why presence matters here: sequence
+  // number zero is a real response.
+  optional uint64 continue_query_sequence_number = 5;
 }
 
 message QueryResponse {
@@ -56,19 +60,41 @@ message QueryResponse {
   // TODO(benh): send these as bytes?
   repeated string idempotency_keys = 2;
 
-  // Unique ID of this response, which a client names to continue the
-  // query after it. Only set when the client set
+  // Unique ID of the query this response belongs to, which a client
+  // names when it continues that query. The same for every response
+  // of one `Query`. Only set when the client set
   // `client_continues_query` on its `QueryRequest`; an empty ID means
-  // the client is not expected to ask for anything further.
-  string query_response_id = 4;
+  // the client is not expected to continue anything.
+  string query_id = 4;
+
+  // Position of this response within its query, counting from zero.
+  // A client names the last one it has fully processed to continue
+  // the query; see `Query`.
+  uint64 sequence_number = 5;
+
+  // How long this response waited for the client to make room for it,
+  // and how many updates were merged into it while it waited. Both
+  // are zero for a client that kept up. A client that finds them set
+  // is one whose user saw a stale screen for that long, and which
+  // missed that many updates on the way to the state this response
+  // carries; see `Query`.
+  uint32 stall_milliseconds = 6;
+  uint32 skipped_updates = 7;
 }
 
 ////////////////////////////////////////////////////////////////////////
 
 message ContinueQueryRequest {
-  // ID of the `QueryResponse` the client has consumed; the query
-  // continues after it.
-  string query_response_id = 1;
+  // ID of the query being continued, from `QueryResponse.query_id`.
+  string query_id = 1;
+
+  // Sequence number of the last `QueryResponse` the client has fully
+  // processed. The server returns to itself the right to send one
+  // more response for each response between the last number this
+  // client named and this one, so a client that processed several
+  // while a previous `ContinueQuery` was in flight names only the
+  // newest and is credited for all of them.
+  uint64 sequence_number = 2;
 }
 
 message ContinueQueryResponse {}
@@ -121,23 +147,42 @@ 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. A client that sets `client_continues_query`
-  // asks for each next response once it has consumed the one before
-  // it, 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 responses at whatever rate the server
-  // produces them, whether or not it can consume them that fast.
+  // stream is opened.
   //
-  // How a client asks for the next response is determined by the
-  // transport its responses arrive on, and only that way works: a
-  // client reading over a websocket sends a `QueryRequest` with
-  // `continue_query_response_id` set on that same websocket, and a
-  // client reading over any other transport calls `ContinueQuery`.
-  // The server tracks what it is waiting for per transport, so a
-  // request that arrives the other way names an ID the server has no
-  // record of, which it treats as one it has already handled: the
-  // request is accepted and then ignored, and the query stops
-  // producing responses.
+  // A client that sets `client_continues_query` is sent responses
+  // under a window: the server may run up to a fixed number of
+  // responses ahead of what that client has continued past, and each
+  // response it sends spends one of them. While the window has
+  // room the server sends every state change as it happens, so a
+  // client that keeps up sees every update at the rate they occur.
+  // Once the window is empty the server holds the response it has
+  // ready and merges every state that follows into it, so when the
+  // window reopens the client is sent a single response carrying the
+  // _latest_ state, with `stall_milliseconds` and `skipped_updates`
+  // saying how long it waited and how many updates that one response
+  // stood in for. So a client that keeps up loses nothing, and a
+  // client that cannot is at most a window behind rather than
+  // arbitrarily behind. A client that does not set
+  // `client_continues_query` gets responses at whatever rate the
+  // server produces them, whether or not it can consume them
+  // that fast.
+  //
+  // To continue a query a client names the sequence number of the
+  // last response it has fully processed, and the server credits it
+  // for every response up to that one. A client may therefore process
+  // several responses while a single `ContinueQuery` is in flight and
+  // name only the newest.
+  //
+  // How a client continues its query is determined by the transport
+  // its responses arrive on, and only that way works: a client
+  // reading over a websocket sends a `QueryRequest` with
+  // `continue_query_sequence_number` set on that same websocket, and
+  // a client reading over any other transport calls `ContinueQuery`.
+  // The server tracks each query's window per transport, so one that
+  // arrives the other way names a query the server has no record of,
+  // which it ignores: the request is accepted, no room is returned,
+  // and the query stops producing responses once its window
+  // empties.
   //
   // NOTE: the service name and state ID is expected to be part of the
   // gRPC metadata, exactly like any other reboot requests.
@@ -147,14 +192,14 @@ service React {
     };
   }
 
-  // Tells the server that a client has consumed a response from
-  // `Query` and wants the query to continue. Must be called on the
-  // same server that produced the response.
+  // Tells the server which responses from `Query` a client has fully
+  // processed, returning that much room to the query's window. Must
+  // be called on the same server that produced those responses.
   //
   // For a client whose responses arrive over a websocket this is the
   // wrong mechanism; such a client continues its query on the
   // websocket that carries its responses, by sending a `QueryRequest`
-  // with `continue_query_response_id` set.
+  // with `continue_query_sequence_number` set.
   rpc ContinueQuery(ContinueQueryRequest) returns (ContinueQueryResponse) {
     option (google.api.http) = {
       post: "/rbt.v1alpha1.React/ContinueQuery"
diff --git a/reboot/aio/contexts.py b/reboot/aio/contexts.py
index a37a8b8f4..958f60160 100644
--- a/reboot/aio/contexts.py
+++ b/reboot/aio/contexts.py
@@ -342,6 +342,65 @@ def from_grpc_metadata(cls, metadata: GrpcMetadata) -> 'Participants':
         return participants
 
 
+class QueryContinuations:
+    """Calls `React.ContinueQuery` for the responses of a `React.Query`
+    that a client has fully processed, which is what returns room to
+    that query's window.
+
+    Keeps at most one call in flight. While one is on its way the
+    client keeps processing, so the next call names only the newest
+    response it has handled; the server credits every response up to
+    that one, so nothing is lost by not naming each individually.
+    """
+
+    def __init__(
+        self,
+        stub: react_pb2_grpc.ReactStub,
+        metadata: GrpcMetadata,
+    ):
+        self._stub = stub
+        self._metadata = metadata
+        self._continuation: Optional[asyncio.Future] = None
+
+    async def continue_past(
+        self,
+        query_response: react_pb2.QueryResponse,
+    ) -> None:
+        """Continues the query past `query_response`, if there is no
+        call already in flight. Raises whatever a previous call raised,
+        so that a failure to continue surfaces on the read."""
+        if query_response.query_id == '':
+            # An older backend doesn't send a query ID and doesn't
+            # expect to be told.
+            return
+
+        if self._continuation is not None and self._continuation.done():
+            await self._continuation
+            self._continuation = None
+
+        if self._continuation is None:
+            self._continuation = asyncio.ensure_future(
+                self._stub.ContinueQuery(
+                    react_pb2.ContinueQueryRequest(
+                        query_id=query_response.query_id,
+                        sequence_number=query_response.sequence_number,
+                    ),
+                    # The same metadata ensures we're routed to the
+                    # same server.
+                    metadata=self._metadata,
+                )
+            )
+
+    async def stop(self) -> None:
+        if self._continuation is not None:
+            self._continuation.cancel()
+            try:
+                await self._continuation
+            except BaseException:
+                pass
+            self._continuation = None
+
+
 class React:
     """Encapsulates machinery necessary for contexts that are "reactive",
     aka, those that are initiated from calls to `React.Query` and who
@@ -522,26 +581,17 @@ async def loop():
                                 await self._used_response[task].wait()
 
                             # Only now that the response has been used
-                            # do we ask for a next one, so that we
-                            # can't fall behind a server that produces
+                            # do we continue past it, so that we can't
+                            # fall behind a server that produces
                             # responses faster than we consume them.
                             # See
                             # https://github.com/reboot-dev/mono/issues/4754.
-                            # An older backend doesn't send an ID and
-                            # doesn't expect to be asked for more.
-                            if query_response.query_response_id != '':
-                                await stub.ContinueQuery(
-                                    react_pb2.ContinueQueryRequest(
-                                        query_response_id=query_response.
-                                        query_response_id,
-                                    ),
-                                    # The same metadata ensures we're
-                                    # routed to the same server.
-                                    metadata=metadata,
-                                )
+                            await continuations.continue_past(query_response)
 
                         raise RuntimeError('React.Query should be infinite')
 
+                    continuations = QueryContinuations(stub, metadata)
+
                     try:
                         await loop()
                     except asyncio.CancelledError:
@@ -571,6 +621,12 @@ async def loop():
 
                         # Let's retry after a backoff!
                         await backoff()
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        await continuations.stop()
 
             task = asyncio.create_task(query(), name=f'query() in {__name__}')
 
diff --git a/reboot/aio/react.py b/reboot/aio/react.py
index 1c6b6da40..0e8b54773 100644
--- a/reboot/aio/react.py
+++ b/reboot/aio/react.py
@@ -2,6 +2,7 @@
 import grpc
 import logging
 import reboot.aio.placement
+import time
 import traceback
 import uuid
 import websockets
@@ -26,10 +27,89 @@
 from reboot.nodejs.python import should_print_stacktrace
 from reboot.settings import EVERY_LOCAL_NETWORK_ADDRESS
 from reboot.wait_for_tasks import wait_for_tasks
-from typing import AsyncIterable, Optional
+from typing import AsyncIterable, AsyncIterator, Optional
 
 logger = get_logger(__name__)
 
+# How many responses a query may run ahead of what its client has
+# reported processing. Bigger means a client that keeps up sees state
+# changes sooner, because the server doesn't wait to hear about the
+# previous response before sending the next; it also means a client
+# that can't keep up is further behind, since it works through what is
+# already in flight before it sees current state. One is the most
+# conservative choice and behaves like a strict request-per-response
+# protocol.
+#
+# TODO: estimate this per client from observed throughput rather than
+#       fixing it for everyone.
+QUERY_RESPONSE_WINDOW = 10
+
+# How long a response must wait for room before we say so, in the
+# server's log and in the response itself. 100ms is about where a
+# person stops experiencing an update as immediate and starts
+# perceiving lag, so a client that waits longer than this is one whose
+# user can see it waiting.
+REPORTABLE_STALL_MILLISECONDS = 100
+
+
+class _QueryWindow:
+    """How much room a query has to send responses before it must hear
+    from its client.
+
+    Starts with `QUERY_RESPONSE_WINDOW` room; `take()` spends one and
+    waits when there is none; `processed()` reports the last sequence
+    number a client has fully processed and returns the room that
+    accounts for.
+    """
+
+    def __init__(self):
+        self._room = QUERY_RESPONSE_WINDOW
+        self._has_room = asyncio.Event()
+        self._has_room.set()
+        # Sequence number of the next response to send, and of the
+        # last one the client has reported processing. The client has
+        # reported nothing until it does, hence -1.
+        self.sequence_number = 0
+        self._processed = -1
+
+    def try_take(self) -> Optional[int]:
+        """Returns the sequence number to send, or `None` when there is
+        no room to send anything."""
+        if self._room == 0:
+            return None
+
+        self._room -= 1
+
+        if self._room == 0:
+            self._has_room.clear()
+
+        sequence_number = self.sequence_number
+        self.sequence_number += 1
+        return sequence_number
+
+    async def take(self) -> int:
+        """Waits for room and returns the sequence number to send."""
+        while True:
+            await self._has_room.wait()
+            sequence_number = self.try_take()
+            if sequence_number is not None:
+                return sequence_number
+
+    def processed(self, sequence_number: int) -> None:
+        """Returns the room accounted for by a client reporting that it
+        has processed everything up to `sequence_number`."""
+        # A client can only have processed what we sent, and only ever
+        # more than it last reported; anything else is a duplicate or
+        # a retry, which returns no room rather than inventing any.
+        sequence_number = min(sequence_number, self.sequence_number - 1)
+
+        self._room += max(0, sequence_number - self._processed)
+
+        if self._room > 0:
+            self._has_room.set()
+
+        self._processed = max(self._processed, sequence_number)
+
 
 class _SuppressInvalidHandshakeFilter(logging.Filter):
     """Drop spurious `opening handshake failed` logs from non-WebSocket
@@ -73,10 +153,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 asks for the query to continue past
-        # that response.
-        self._query_continuations: dict[str, asyncio.Event] = {}
+        # Windows, keyed by query ID, for the queries served over a
+        # streaming transport; the websocket path keeps its windows on
+        # the connection instead.
+        self._query_windows: dict[str, _QueryWindow] = {}
 
         self._stop_websockets_serve = asyncio.Event()
 
@@ -343,9 +423,10 @@ async def _websocket_query(
         query_task = asyncio.current_task()
         assert query_task is not None
 
-        # Events, keyed by query response ID, that are set once the
-        # client asks to continue past the response with that ID.
-        continuations: dict[str, asyncio.Event] = {}
+        # This query's window, if the client asked for one. The
+        # websocket identifies the query, so unlike the streaming
+        # transport there is nothing to key on.
+        window = _QueryWindow() if request.client_continues_query else None
 
         async def consume_requests():
             try:
@@ -359,17 +440,12 @@ async def consume_requests():
                     continuation = react_pb2.QueryRequest()
                     continuation.ParseFromString(request_bytes)
 
-                    # Look the event up rather than take it: the loop
-                    # that produced the response owns the entry and
-                    # removes it once it is done waiting. A
-                    # continuation we no longer have an entry for is
-                    # one we have already acted on, or one whose
-                    # response we produced before a restart.
-                    may_continue = continuations.get(
-                        continuation.continue_query_response_id
-                    )
-                    if may_continue is not None:
-                        may_continue.set()
+                    if window is not None and continuation.HasField(
+                        'continue_query_sequence_number'
+                    ):
+                        window.processed(
+                            continuation.continue_query_sequence_number
+                        )
             except Exception:
                 # WebSocket closed (or errored); cancel the main query
                 # task to unblock `_query()` and trigger cleanup.
@@ -378,35 +454,14 @@ async def consume_requests():
         requests_task = asyncio.create_task(consume_requests())
 
         try:
-            async for response in self._query(
+            async for response in self._windowed_query(
                 request=request,
                 headers=headers,
                 middleware=middleware,
+                query_id=str(uuid.uuid4()),
+                window=window,
             ):
-                may_continue: Optional[asyncio.Event] = None
-
-                if request.client_continues_query:
-                    response.query_response_id = str(uuid.uuid4())
-                    may_continue = asyncio.Event()
-                    continuations[response.query_response_id] = may_continue
-
-                try:
-                    await websocket.send(response.SerializeToString())
-
-                    # A client that never asks for more gets
-                    # responses as fast as we produce them; the empty
-                    # ID tells it that we expect no such request.
-                    if may_continue is not None:
-                        # Wait for the client to tell us that it is
-                        # ready for a next response, so that it can't
-                        # fall behind us. While we wait here the state
-                        # may change any number of times, and the next
-                        # response we produce reflects the latest of
-                        # those states.
-                        await may_continue.wait()
-                finally:
-                    if may_continue is not None:
-                        del continuations[response.query_response_id]
+                await websocket.send(response.SerializeToString())
         finally:
             requests_task.cancel()
             await asyncio.gather(requests_task, return_exceptions=True)
@@ -472,37 +527,35 @@ async def ContinueQuery(
         request: react_pb2.ContinueQueryRequest,
         grpc_context: grpc.aio.ServicerContext,
     ) -> react_pb2.ContinueQueryResponse:
-        """Implements the React.ContinueQuery RPC that lets a
-        client tell us it has processed a response from `Query` and is
-        ready for a next one."""
+        """Implements the React.ContinueQuery RPC that lets a client
+        tell us which responses from `Query` it has processed, which
+        returns that much room to that query's window."""
         try:
             # Confirm that we are the server that produced the
-            # response.
+            # responses.
             self._middleware_for(Headers.from_grpc_context(grpc_context))
         except Aborted as aborted:
             await grpc_context.abort_with_status(
                 rpc_status.to_status(aborted.to_status())
             )
 
-        # Look the event up rather than take it: the `Query` call that
-        # produced the response owns the entry and removes it once it
-        # is done waiting.
-        may_continue = self._query_continuations.get(request.query_response_id)
+        # Look the window up rather than take it: the `Query` call
+        # owns it and removes it when it ends.
+        window = self._query_windows.get(request.query_id)
 
-        if may_continue is None:
+        if window is None:
             # There are several valid reasons why we may not know this
-            # response:
+            # query:
             # 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 the same request twice
-            #    (e.g. retried it), in which case we have already
-            #    produced a next response.
-            # Either way there is nothing left to do.
+            #    it. The client's `Query` call will have been broken by
+            #    that same restart, and it gets a fresh query once it
+            #    reconnects.
+            # 2. The query may have ended between the client sending
+            #    this and us receiving it.
+            # Either way there is no window left to return room to.
             return react_pb2.ContinueQueryResponse()
 
-        may_continue.set()
+        window.processed(request.sequence_number)
 
         return react_pb2.ContinueQueryResponse()
 
@@ -533,6 +586,126 @@ async def _query(
 
             yield query_response
 
+    async def _windowed_query(
+        self,
+        *,
+        request: react_pb2.QueryRequest,
+        headers: Headers,
+        middleware: Middleware,
+        query_id: str,
+        window: Optional[_QueryWindow],
+    ) -> AsyncIterator[react_pb2.QueryResponse]:
+        """Produces the responses of `_query()`, each stamped with the
+        query it belongs to and the room it is sent under.
+
+        Asks for states as fast as they are produced even while there
+        is no room to send one. A state that arrives while we are
+        waiting for room is merged into the response we are holding,
+        so the response we send once there is room carries the latest
+        state and says how long it waited and how many updates it
+        stood in for.
+        """
+        responses = self._query(
+            request=request,
+            headers=headers,
+            middleware=middleware,
+        ).__aiter__()
+
+        if window is None:
+            # A client that reports nothing back has no room to wait
+            # for; it gets responses as fast as we produce them.
+            async for response in responses:
+                yield response
+            return
+
+        # The response we have asked for but have no room for yet, and
+        # the room we are waiting on. Both outlive an iteration of the
+        # loop below: dropping an ask for a response would lose the
+        # state that ask is waiting for.
+        asked: Optional[asyncio.Future] = None
+        room: Optional[asyncio.Future] = None
+
+        try:
+            while True:
+                if asked is None:
+                    asked = asyncio.ensure_future(anext(responses, None))
+
+                response = await asked
+                asked = None
+
+                if response is None:
+                    return
+
+                sequence_number = window.try_take()
+
+                if sequence_number is None:
+                    stalled_at = time.monotonic()
+                    skipped = 0
+                    room = asyncio.ensure_future(window.take())
+
+                    while True:
+                        if asked is None:
+                            asked = asyncio.ensure_future(
+                                anext(responses, None)
+                            )
+
+                        await asyncio.wait(
+                            [room, asked],
+                            return_when=asyncio.FIRST_COMPLETED,
+                        )
+
+                        if asked.done():
+                            update = asked.result()
+                            asked = None
+
+                            if update is None:
+                                # What we hold is the last response of
+                                # this query; it still needs room.
+                                sequence_number = await room
+                                break
+
+                            skipped += 1
+
+                            # `MergeFrom` is exactly what one response
+                            # standing in for two means: the newer
+                            # state replaces the one we hold, an
+                            # update that carries no state of its own
+                            # leaves that state alone, and we keep the
+                            # idempotency keys of both, since a
+                            # mutation reported once must not be lost
+                            # because the response reporting it was
+                            # merged away.
+                            response.MergeFrom(update)
+
+                        if room.done():
+                            sequence_number = room.result()
+                            break
+
+                    room = None
+
+                    stall_milliseconds = round(
+                        (time.monotonic() - stalled_at) * 1000
+                    )
+
+                    response.stall_milliseconds = stall_milliseconds
+                    response.skipped_updates = skipped
+
+                    if stall_milliseconds > REPORTABLE_STALL_MILLISECONDS:
+                        logger.info(
+                            "A client of a reactive query to "
+                            f"`{request.method}` skipped {skipped} updates "
+                            f"because it fell {stall_milliseconds}ms behind"
+                        )
+
+                response.query_id = query_id
+                response.sequence_number = sequence_number
+
+                yield response
+        finally:
+            for future in (asked, room):
+                if future is not None:
+                    future.cancel()
+
     async def Query(
         self,
         request: react_pb2.QueryRequest,
@@ -570,50 +743,29 @@ def done_callback(_) -> None:
 
             middleware = self._middleware_for(headers)
 
-            async for response in self._query(
-                request=request,
-                headers=headers,
-                middleware=middleware,
-            ):
-                may_continue: Optional[asyncio.Event] = None
+            query_id = str(uuid.uuid4())
+            window: Optional[_QueryWindow] = None
 
-                if request.client_continues_query:
-                    response.query_response_id = str(uuid.uuid4())
-                    may_continue = asyncio.Event()
-                    self._query_continuations[response.query_response_id
-                                             ] = may_continue
+            if request.client_continues_query:
+                window = _QueryWindow()
+                self._query_windows[query_id] = window
 
-                try:
+            try:
+                async for response in self._windowed_query(
+                    request=request,
+                    headers=headers,
+                    middleware=middleware,
+                    query_id=query_id,
+                    window=window,
+                ):
                     yield response
-
-                    # A client that never asks for more gets
-                    # responses as fast as we produce them; the empty
-                    # ID tells it that we expect no such request.
-                    if may_continue is not None:
-                        # Wait for the client to tell us, via
-                        # `ContinueQuery`, that it is ready
-                        # for a next response, so that it can't fall
-                        # behind us. While we wait here the state may
-                        # change any number of times, and the next
-                        # response we produce reflects 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 may_continue.wait()
-                finally:
-                    # The `yield` is inside this `try` so that closing
-                    # the generator while it is suspended there still
-                    # takes the entry back out of a dictionary that
-                    # lives as long as the service.
-                    if may_continue is not None:
-                        del self._query_continuations[
-                            response.query_response_id]
+            finally:
+                # This `finally` covers the whole loop, so that
+                # closing this generator while it is suspended in a
+                # `yield` still takes the window out of a dictionary
+                # that lives as long as the service.
+                if window is not None:
+                    del self._query_windows[query_id]
         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 ed5ad612d..61a2128cf 100644
--- a/reboot/templates/reboot.py.j2
+++ b/reboot/templates/reboot.py.j2
@@ -5277,6 +5277,7 @@ class {{ client.proto.state_name }}:
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('{{ client.proto.state_full_name }}'),
@@ -5300,6 +5301,10 @@ class {{ client.proto.state_name }}:
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -5318,22 +5323,11 @@ class {{ client.proto.state_name }}:
                                     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 we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -5360,6 +5354,13 @@ class {{ client.proto.state_name }}:
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
diff --git a/reboot/web/index.ts b/reboot/web/index.ts
index c8e68e207..c4612ffde 100644
--- a/reboot/web/index.ts
+++ b/reboot/web/index.ts
@@ -419,19 +419,43 @@ export function reactively<
   return [responses(), setRequest];
 }
 
-// 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 request would leave the `Query` stream waiting
-// forever.
+// How long a response must have waited for us before we say so in
+// the console. 100ms is about where a person stops experiencing an
+// update as immediate and starts perceiving lag, so a response that
+// waited longer than this is one whose delay our user could see; the
+// backend uses the same threshold for its own log.
+const LOGGED_STALL_MILLISECONDS = 100;
+
+// Tells the developer that this client fell far enough behind its
+// backend that the backend merged updates it would otherwise have
+// sent. The state we go on to render is still the latest one; what
+// was lost is the updates on the way there.
+function logStall(method: string, response: react_pb.QueryResponse) {
+  if (response.stallMilliseconds > LOGGED_STALL_MILLISECONDS) {
+    console.info(
+      `[Reboot] A reactive query to \`${method}\` skipped ` +
+        `${response.skippedUpdates} updates because this client fell ` +
+        `${response.stallMilliseconds}ms behind`
+    );
+  }
+}
+
+// Tells the backend which responses of a query we have fully
+// processed, which returns that much room to the query's window.
+// Retries until the backend confirms, since a lost request would
+// leave the `Query` stream with less room than it should have, and
+// eventually with none.
 async function continueQuery({
   endpoint,
   headers,
-  queryResponseId,
+  queryId,
+  sequenceNumber,
   signal,
 }: {
   endpoint: string;
   headers: Headers;
-  queryResponseId: string;
+  queryId: string;
+  sequenceNumber: bigint;
   signal?: AbortSignal;
 }): Promise<void> {
   const url = new URL(`${endpoint}/rbt.v1alpha1.React/ContinueQuery`);
@@ -446,7 +470,10 @@ async function continueQuery({
       const response = await guardedFetch(url.toString(), {
         method: "POST",
         headers,
-        body: JSON.stringify({ queryResponseId }),
+        body: JSON.stringify({
+          queryId,
+          sequenceNumber: sequenceNumber.toString(),
+        }),
         signal,
       });
       // A `fetch()` only throws on network errors; an HTTP error
@@ -454,9 +481,8 @@ async function continueQuery({
       // ourselves.
       if (!response.ok) {
         throw new Error(
-          `Continuing the query past response ` +
-            `'${queryResponseId}' failed ` +
-            `with HTTP status ${response.status}`
+          `Continuing query '${queryId}' past response ` +
+            `${sequenceNumber} failed with HTTP status ${response.status}`
         );
       }
       return;
@@ -465,8 +491,8 @@ async function continueQuery({
         throw e;
       }
       console.warn(
-        `[Reboot] Failed to continue the query past response ` +
-          `'${queryResponseId}', retrying after backoff ...`
+        `[Reboot] Failed to continue query '${queryId}' past response ` +
+          `${sequenceNumber}, retrying after backoff ...`
       );
       await backoff.wait();
     }
@@ -505,21 +531,51 @@ export async function* reactiveReader({
       signal,
     });
 
+    // The one `ContinueQuery` that may be in flight at a time, and
+    // whether it has settled; see below.
+    let continuation: Promise<void> | undefined = undefined;
+    let settled = true;
+
     for await (const response of responses) {
+      logStall(request.method, response);
+
       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 to be asked for more.
-      if (response.queryResponseId !== "") {
-        await continueQuery({
+      // continue past it, so that we can't fall behind a backend that
+      // produces responses faster than we consume them.
+      if (response.queryId === "") {
+        // An older backend doesn't send a query ID and doesn't expect
+        // to be told.
+        continue;
+      }
+
+      // At most one `ContinueQuery` is in flight. While one is on its
+      // way we keep consuming, so the one we send next names only the
+      // newest response we have processed; the backend credits us for
+      // every response up to that one.
+      if (continuation !== undefined && settled) {
+        // Throws if continuing failed, which reconnects the query.
+        await continuation;
+        continuation = undefined;
+      }
+
+      if (continuation === undefined) {
+        settled = false;
+        continuation = continueQuery({
           endpoint,
           headers: continueHeaders,
-          queryResponseId: response.queryResponseId,
+          queryId: response.queryId,
+          sequenceNumber: response.sequenceNumber,
           signal,
+        }).finally(() => {
+          settled = true;
         });
+
+        // A failure surfaces on the `await` above, but a read that
+        // ends before we get there leaves it unobserved; observe it
+        // here too so that it can't become an unhandled rejection.
+        continuation.catch(() => {});
       }
     }
   } else {
@@ -536,11 +592,14 @@ export async function* reactiveReader({
       responseType: react_pb.QueryResponse,
       signal,
       // Continuations go back over the same websocket, so that a
-      // reactive read costs no extra round trips.
+      // reactive read costs no extra round trips; since sending one
+      // costs nothing extra we continue past every response as soon
+      // as we have processed it, rather than past the newest of
+      // several.
       continueRequest: (response: react_pb.QueryResponse) =>
-        response.queryResponseId !== ""
+        response.queryId !== ""
           ? new react_pb.QueryRequest({
-              continueQueryResponseId: response.queryResponseId,
+              continueQuerySequenceNumber: response.sequenceNumber,
             })
           : undefined,
     });
@@ -549,6 +608,9 @@ export async function* reactiveReader({
         responses.return();
         throw Status.fromJsonString(response.responseOrStatus.value);
       }
+
+      logStall(request.method, response);
+
       yield response;
     }
   }
diff --git a/tests/reboot/echo_rbt.golden.py b/tests/reboot/echo_rbt.golden.py
index f7a30941d..ce65a984e 100755
--- a/tests/reboot/echo_rbt.golden.py
+++ b/tests/reboot/echo_rbt.golden.py
@@ -20838,6 +20838,7 @@ async def Replay( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('tests.reboot.Echo'),
@@ -20859,6 +20860,10 @@ async def Replay( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -20877,22 +20882,11 @@ async def Replay( # type: ignore[misc]
                                     yield EchoReplayResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -20919,6 +20913,13 @@ async def Replay( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -21034,6 +21035,7 @@ async def WaitFor( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('tests.reboot.Echo'),
@@ -21055,6 +21057,10 @@ async def WaitFor( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -21073,22 +21079,11 @@ async def WaitFor( # type: ignore[misc]
                                     yield EchoWaitForResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -21115,6 +21110,13 @@ async def WaitFor( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
diff --git a/tests/reboot/greeter_rbt.golden.js b/tests/reboot/greeter_rbt.golden.js
index 42c5a9189..06bedcb50 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", "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");
 }
 importPys();
diff --git a/tests/reboot/greeter_rbt.golden.py b/tests/reboot/greeter_rbt.golden.py
index 15e2e8f89..7120ca11d 100755
--- a/tests/reboot/greeter_rbt.golden.py
+++ b/tests/reboot/greeter_rbt.golden.py
@@ -21729,6 +21729,7 @@ async def Greet( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('tests.reboot.Greeter'),
@@ -21750,6 +21751,10 @@ async def Greet( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -21768,22 +21773,11 @@ async def Greet( # type: ignore[misc]
                                     yield GreeterGreetResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -21810,6 +21804,13 @@ async def Greet( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -21919,6 +21920,7 @@ async def TryToConstructContext( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('tests.reboot.Greeter'),
@@ -21940,6 +21942,10 @@ async def TryToConstructContext( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -21958,22 +21964,11 @@ async def TryToConstructContext( # type: ignore[misc]
                                     yield GreeterTryToConstructContextResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22000,6 +21995,13 @@ async def TryToConstructContext( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -22109,6 +22111,7 @@ async def TryToConstructExternalContext( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('tests.reboot.Greeter'),
@@ -22130,6 +22133,10 @@ async def TryToConstructExternalContext( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -22148,22 +22155,11 @@ async def TryToConstructExternalContext( # type: ignore[misc]
                                     yield GreeterTryToConstructExternalContextResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22190,6 +22186,13 @@ async def TryToConstructExternalContext( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -22305,6 +22308,7 @@ async def TestLongRunningFetch( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('tests.reboot.Greeter'),
@@ -22326,6 +22330,10 @@ async def TestLongRunningFetch( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -22344,22 +22352,11 @@ async def TestLongRunningFetch( # type: ignore[misc]
                                     yield GreeterTestLongRunningFetchResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22386,6 +22383,13 @@ async def TestLongRunningFetch( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -22495,6 +22499,7 @@ async def GetWholeState( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('tests.reboot.Greeter'),
@@ -22516,6 +22521,10 @@ async def GetWholeState( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -22534,22 +22543,11 @@ async def GetWholeState( # type: ignore[misc]
                                     yield GreeterGetWholeStateResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22576,6 +22574,13 @@ async def GetWholeState( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -22685,6 +22690,7 @@ async def FailWithException( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('tests.reboot.Greeter'),
@@ -22706,6 +22712,10 @@ async def FailWithException( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -22724,22 +22734,11 @@ async def FailWithException( # type: ignore[misc]
                                     yield GreeterFailWithExceptionResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22766,6 +22765,13 @@ async def FailWithException( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -22875,6 +22881,7 @@ async def FailWithAborted( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('tests.reboot.Greeter'),
@@ -22896,6 +22903,10 @@ async def FailWithAborted( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -22914,22 +22925,11 @@ async def FailWithAborted( # type: ignore[misc]
                                     yield GreeterFailWithAbortedResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -22956,6 +22956,13 @@ async def FailWithAborted( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -23065,6 +23072,7 @@ async def ReadRecursiveMessage( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('tests.reboot.Greeter'),
@@ -23086,6 +23094,10 @@ async def ReadRecursiveMessage( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -23104,22 +23116,11 @@ async def ReadRecursiveMessage( # type: ignore[misc]
                                     yield GreeterReadRecursiveMessageResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -23146,6 +23147,13 @@ async def ReadRecursiveMessage( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
diff --git a/tests/reboot/ping_api_rbt.golden.py b/tests/reboot/ping_api_rbt.golden.py
index 1f5909016..108c3c70b 100755
--- a/tests/reboot/ping_api_rbt.golden.py
+++ b/tests/reboot/ping_api_rbt.golden.py
@@ -21325,6 +21325,7 @@ async def Describe( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('reboot.ping.Ping'),
@@ -21345,6 +21346,10 @@ async def Describe( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -21363,22 +21368,11 @@ async def Describe( # type: ignore[misc]
                                     yield PingDescribeResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -21405,6 +21399,13 @@ async def Describe( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -21479,6 +21480,7 @@ async def NumPings( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('reboot.ping.Ping'),
@@ -21499,6 +21501,10 @@ async def NumPings( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -21517,22 +21523,11 @@ async def NumPings( # type: ignore[misc]
                                     yield PingNumPingsResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -21559,6 +21554,13 @@ async def NumPings( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -24148,6 +24150,7 @@ async def NumPongs( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('reboot.ping.Pong'),
@@ -24168,6 +24171,10 @@ async def NumPongs( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -24186,22 +24193,11 @@ async def NumPongs( # type: ignore[misc]
                                     yield PongNumPongsResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -24228,6 +24224,13 @@ async def NumPongs( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -26903,6 +26906,7 @@ async def ListCounters( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('reboot.ping.User'),
@@ -26923,6 +26927,10 @@ async def ListCounters( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -26941,22 +26949,11 @@ async def ListCounters( # type: ignore[misc]
                                     yield UserListCountersResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -26983,6 +26980,13 @@ async def ListCounters( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -27057,6 +27061,7 @@ async def Whoami( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('reboot.ping.User'),
@@ -27077,6 +27082,10 @@ async def Whoami( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -27095,22 +27104,11 @@ async def Whoami( # type: ignore[misc]
                                     yield UserWhoamiResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -27137,6 +27135,13 @@ async def Whoami( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -30721,6 +30726,7 @@ async def Value( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('reboot.ping.Counter'),
@@ -30741,6 +30747,10 @@ async def Value( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -30759,22 +30769,11 @@ async def Value( # type: ignore[misc]
                                     yield CounterValueResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -30801,6 +30800,13 @@ async def Value( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
@@ -30875,6 +30881,7 @@ async def Description( # type: ignore[misc]
                 __query_backoff__ = IMPORT_reboot_aio_backoff.Backoff()
                 while True:
                     __call__ = None
+                    __continuations__ = None
                     try:
                         async with __context__.channel_manager.get_channel_to_state(
                             IMPORT_reboot_aio_types.StateTypeName('reboot.ping.Counter'),
@@ -30895,6 +30902,10 @@ async def Description( # type: ignore[misc]
                                 metadata=__metadata__,
                             )
 
+                            __continuations__ = IMPORT_reboot_aio_contexts.QueryContinuations(
+                                __stub__, __metadata__
+                            )
+
                             async for __query_response__ in __call__:
                                 # Clear the backoff so we don't wait
                                 # as long the next time we get
@@ -30913,22 +30924,11 @@ async def Description( # type: ignore[misc]
                                     yield CounterDescriptionResponseFromProto(__response__)
 
                                 # Only now that the caller has processed the
-                                # response do we ask the server for a next one,
-                                # so that we can't fall behind a server that
-                                # produces responses faster than we consume
-                                # them. See
+                                # response do we continue past it, so that we
+                                # can't fall behind a server that produces
+                                # responses faster than we consume them. See
                                 # https://github.com/reboot-dev/mono/issues/4754.
-                                # An older backend doesn't send an ID and
-                                # doesn't expect to be asked for more.
-                                if __query_response__.query_response_id != "":
-                                    await __stub__.ContinueQuery(
-                                        IMPORT_rbt_v1alpha1.react_pb2.ContinueQueryRequest(
-                                            query_response_id=__query_response__.query_response_id,
-                                        ),
-                                        # The same metadata ensures we're routed
-                                        # to the same server.
-                                        metadata=__metadata__,
-                                    )
+                                await __continuations__.continue_past(__query_response__)
 
                     except IMPORT_grpc.aio.AioRpcError as error:
                         # We expect to get disconnected from the server
@@ -30955,6 +30955,13 @@ async def Description( # type: ignore[misc]
                             ) from None
 
                         raise
+                    finally:
+                        # Whether we are retrying or giving up, this
+                        # attempt's continuation is about to be
+                        # irrelevant: a fresh `Query` gets a fresh
+                        # window.
+                        if __continuations__ is not None:
+                            await __continuations__.stop()
 
             # Keep the original functions on the client, so old code will
             # continue to work, but use the new 'snake_case' method in
diff --git a/tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel b/tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel
index d59bf8a96..621d8064d 100644
--- a/tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel
+++ b/tests/reboot/react/test_reactive_reader_flow_control/BUILD.bazel
@@ -39,6 +39,7 @@ py_library(
     visibility = ["//tests:__subpackages__"],
     deps = [
         "//reboot/aio:external_py",
+        "//reboot/aio:react_py",
         "//tests/reboot:greeter_servicers_py",
         "//tests/reboot/react:web_driver_runner",
     ],
diff --git a/tests/reboot/react/test_reactive_reader_flow_control/index.tsx b/tests/reboot/react/test_reactive_reader_flow_control/index.tsx
index 248ee4b51..c33e5e28c 100644
--- a/tests/reboot/react/test_reactive_reader_flow_control/index.tsx
+++ b/tests/reboot/react/test_reactive_reader_flow_control/index.tsx
@@ -7,10 +7,11 @@ const ID = "greeter-flow-control-test";
 
 declare global {
   interface Window {
-    // Lets the query continue past 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.
-    continueQuery: () => void;
+    // Lets the query continue past the response currently on screen,
+    // and past every response after it. The test calls this once it
+    // has made every state change that it wants the backend to have
+    // had no room to send.
+    stopHolding: () => void;
   }
 }
 
@@ -20,15 +21,29 @@ const App = ({ url }: { url: string }) => {
   useEffect(() => {
     const abortController = new AbortController();
 
+    // Whether every response is held back until the test says
+    // otherwise, and the release of the response held right now.
+    let holding = true;
+    let release: (() => void) | undefined = undefined;
+
+    // `window.stopHolding` is assigned here, synchronously, before the
+    // read below has anything to render, so a test that has seen a
+    // message rendered knows the hold is in place.
+    window.stopHolding = () => {
+      holding = false;
+      release?.();
+      release = undefined;
+    };
+
     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 lets the
-      // query continue: `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.
+      // query continue: `reactively()` reports a response as
+      // processed only once we ask this generator for a next one, so
+      // a response we have not asked for yet is a response the
+      // backend has been given no room to follow.
       const [responses] = await Greeter.ref(ID).reactively().greet(
         context,
         { name: "Jonathan" },
@@ -40,12 +55,11 @@ const App = ({ url }: { url: string }) => {
       for await (const response of responses) {
         setMessages((messages) => [...messages, response.message]);
 
-        // `window.continueQuery` 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<void>((resolve) => {
-          window.continueQuery = resolve;
-        });
+        if (holding) {
+          await new Promise<void>((resolve) => {
+            release = resolve;
+          });
+        }
       }
     };
 
diff --git a/tests/reboot/react/test_reactive_reader_flow_control/test.py b/tests/reboot/react/test_reactive_reader_flow_control/test.py
index ff098abab..e8baf64f2 100644
--- a/tests/reboot/react/test_reactive_reader_flow_control/test.py
+++ b/tests/reboot/react/test_reactive_reader_flow_control/test.py
@@ -2,34 +2,35 @@
 import os
 import time
 from reboot.aio.external import ExternalContext
+from reboot.aio.react import QUERY_RESPONSE_WINDOW
 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 back 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)
+# Adjectives to write while the browser holds back the response it is
+# showing; many more than the backend has room to send without hearing
+# back, so that most of them must be skipped.
+ADJECTIVES = [
+    f'adjective-{index}' for index in range(3 * QUERY_RESPONSE_WINDOW)
 ]
 
 
 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.
+    next response falls no further behind than the room the backend
+    has to send responses, and then skips to the latest state.
 
     The app in `index.tsx` consumes the reactive read itself and holds
-    each response back 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
-    hold must then produce exactly one response, carrying
-    the last state written in the round rather than the first one the
-    backend passed through."""
+    back every response until this test releases it, so every state
+    change below is known to have completed while the browser had
+    processed nothing beyond the state it started from. The backend
+    may therefore send at most a window's worth of responses however
+    many states are written, and the response that follows them once
+    the browser catches up must carry the last state written rather
+    than the next one the backend passed through. Falling that far
+    behind must also be reported to the browser's console."""
     await Greeter.idempotently(f"Create '{STATE_ID}'").Create(
         context,
         STATE_ID,
@@ -62,6 +63,13 @@ def wait_for_message_count(driver, count: int) -> list[str]:
             time.sleep(0.1)
         return rendered_messages(driver)
 
+    def wait_for_latest_message(driver, latest: str) -> list[str]:
+        rendered = rendered_messages(driver)
+        while len(rendered) == 0 or rendered[-1] != latest:
+            time.sleep(0.1)
+            rendered = rendered_messages(driver)
+        return rendered
+
     with web_driver(
         uri=uri,
         bundle_js_path=os.path.join(os.path.dirname(__file__), 'bundle.js'),
@@ -76,36 +84,52 @@ def wait_for_message_count(driver, count: int) -> list[str]:
         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 the browser has not continued past.
-            for adjective in adjectives:
-                await greeter.SetAdjective(context, adjective=adjective)
-
-            # Let the browser continue, which is the first moment
-            # the backend may produce a next response.
-            await asyncio.to_thread(
-                driver.execute_script,
-                'window.continueQuery()',
-            )
-
-            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
+        # 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 the browser has
+        # processed nothing beyond the one it started from.
+        for adjective in ADJECTIVES:
+            await greeter.SetAdjective(context, adjective=adjective)
+
+        # Let the browser consume, which is the first moment the
+        # backend gets room to produce anything beyond what it sent
+        # before the writes above began.
+        await asyncio.to_thread(driver.execute_script, 'window.stopHolding()')
+
+        rendered = await asyncio.to_thread(
+            wait_for_latest_message,
+            driver,
+            message(ADJECTIVES[-1]),
+        )
+
+        # The browser rendered the state it started from, whatever the
+        # backend had room to send while the browser was not
+        # consuming, and one more response carrying the skip to the
+        # latest state. Every state in between was skipped, and none
+        # of them was ever rendered.
+        assert len(rendered) <= QUERY_RESPONSE_WINDOW + 1, rendered
+        assert rendered[0] == message('tasty'), rendered
+
+        # The browser tells its developer that it fell behind, since
+        # it did so for long enough that a user would have seen it.
+        console = await asyncio.to_thread(driver.get_log, 'browser')
+
+        stalls = [
+            entry['message']
+            for entry in console
+            if 'A reactive query to' in entry['message']
+        ]
+
+        assert len(stalls) > 0, console
+        assert 'Greet` skipped' in stalls[0], stalls
+        assert 'updates because this client fell' in stalls[0], stalls
+
+        # Catching up gave the backend its room back, so the query is
+        # not stalled: a state written now still arrives.
+        await greeter.SetAdjective(context, adjective='delicious')
+
+        await asyncio.to_thread(
+            wait_for_latest_message,
+            driver,
+            message('delicious'),
+        )
diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py
index a196ed5eb..13191fd3f 100644
--- a/tests/reboot/reactivity_test.py
+++ b/tests/reboot/reactivity_test.py
@@ -5,6 +5,10 @@
 from reboot.aio.applications import Application
 from reboot.aio.contexts import ReaderContext
 from reboot.aio.external import ExternalContext
+from reboot.aio.react import (
+    QUERY_RESPONSE_WINDOW,
+    REPORTABLE_STALL_MILLISECONDS,
+)
 from reboot.aio.tests import Reboot
 from tests.reboot import greeter_rbt
 from tests.reboot.greeter_rbt import Greeter
@@ -49,10 +53,11 @@ def query_requests_without_continuations():
     `ReactStub` up on their modules at call time, so patching here
     covers both.
 
-    Yields the IDs this client was driven to continue past, which must
-    stay empty: a client from before `ContinueQuery` existed had no
-    such RPC to call, so a backend that kept the responses coming only
-    because this one called it would strand a real old client."""
+    Yields the IDs of the queries this client was driven to continue,
+    which must stay empty: a client from before `ContinueQuery` existed
+    had no such RPC to call, so a backend that kept the responses
+    coming only because this one called it would strand a real old
+    client."""
     continued: list[str] = []
 
     class ReactStub:
@@ -64,7 +69,7 @@ def __getattr__(self, name):
             return getattr(self._stub, name)
 
         def ContinueQuery(self, request, **kwargs):
-            continued.append(request.query_response_id)
+            continued.append(request.query_id)
             return self._stub.ContinueQuery(request, **kwargs)
 
     with patch.object(
@@ -141,6 +146,13 @@ async def get_adjectives(self, expected_number: int) -> list[str]:
 
         return self._accumulated_adjectives
 
+    async def accumulate_until_adjective(self, adjective: str) -> list[str]:
+        while self._accumulated_adjectives[-1] != adjective:
+            await self._accumulated_adjective.wait()
+            self._accumulated_adjective.clear()
+
+        return self._accumulated_adjectives
+
     async def test_reactive_get_all_state(self) -> None:
         """
         Regression test for https://github.com/reboot-dev/mono/issues/3135
@@ -179,8 +191,9 @@ async def test_reactive_get_all_state(self) -> None:
     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.
+        state changes falls no further behind than its window, and then
+        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()}")
@@ -197,18 +210,82 @@ async def test_skip_to_latest(self) -> None:
         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")
+        # Change the state many more times than the window gives the
+        # backend room to send without hearing back.
+        adjectives = [
+            f"adjective-{index}" for index in range(3 * QUERY_RESPONSE_WINDOW)
+        ]
+
+        for adjective in adjectives:
+            await greeter.SetAdjective(context, adjective=adjective)
 
-        # Now let the reactive reader consume a next response. It must
-        # be the latest state, not the oldest state it missed.
+        # Now let the reactive reader consume responses again. It must
+        # arrive at the latest state...
         self._can_accumulate_next_adjective.set()
-        self.assertEqual(
-            ["reactive", "fantastic"],
-            await self.get_adjectives(2),
+        accumulated = await self.accumulate_until_adjective(adjectives[-1])
+
+        # ... having seen at most a window's worth of responses on the
+        # way there rather than one per state change, since the backend
+        # stopped producing once it had a window's worth outstanding,
+        # and the states that changed while it waited were skipped. The
+        # window covers the first response too, and one more response
+        # carries the skip to the latest state.
+        self.assertLessEqual(
+            len(accumulated),
+            QUERY_RESPONSE_WINDOW + 1,
+            accumulated,
+        )
+
+    async def test_reports_a_stalled_client(self) -> None:
+        """
+        Tests that a backend holding a response for a client too slow
+        to take it says so, once it has held it for long enough that
+        the client's user could see the delay.
+        """
+        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))
+
+        with self.assertLogs(
+            'respect.reboot.aio.react',
+            level='INFO',
+        ) as logs:
+            # More changes than the window has room for, so that the
+            # backend ends up holding one it cannot send.
+            adjectives = [
+                f"adjective-{index}"
+                for index in range(2 * QUERY_RESPONSE_WINDOW)
+            ]
+
+            for adjective in adjectives:
+                await greeter.SetAdjective(context, adjective=adjective)
+
+            # Hold it there for longer than a user would fail to
+            # notice.
+            await asyncio.sleep(2 * REPORTABLE_STALL_MILLISECONDS / 1000)
+
+            self._can_accumulate_next_adjective.set()
+            await self.accumulate_until_adjective(adjectives[-1])
+
+        reported = "A client of a reactive query to `GetWholeState` skipped "
+
+        self.assertTrue(
+            any(
+                reported in line and "updates because it fell" in line
+                for line in logs.output
+            ),
+            logs.output,
         )
 
     async def test_transitive_skip_to_latest(self) -> None:
@@ -263,15 +340,20 @@ async def get_greetings(expected_number: int) -> list[str]:
             await get_greetings(1),
         )
 
-        adjectives = [f"adjective-{index}" for index in range(10)]
+        adjectives = [
+            f"adjective-{index}" for index in range(3 * QUERY_RESPONSE_WINDOW)
+        ]
+
         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.
+        # the latest state without seeing every state it missed. Each
+        # hop has a window of its own, but a hop with no room merges
+        # what it is holding rather than letting responses queue up
+        # behind it, so the hops don't add up: this reader is a single
+        # window behind, plus the one response that carries the skip
+        # to the latest state.
         can_greet_again.set()
 
         latest = f"Hi Alice, I am Mr. Robot the {adjectives[-1]}"
@@ -279,7 +361,11 @@ async def get_greetings(expected_number: int) -> list[str]:
             await greeted.wait()
             greeted.clear()
 
-        self.assertLessEqual(len(greetings), 3, greetings)
+        self.assertLessEqual(
+            len(greetings),
+            QUERY_RESPONSE_WINDOW + 1,
+            greetings,
+        )
 
     async def test_client_that_never_continues(self) -> None:
         """

From 9e59c2cd01e69f8b0ecbb0a86e1823794436da2f Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Thu, 10 Sep 2026 13:23:15 +0000
Subject: [PATCH 07/13] Add a rule: annotate every Python parameter

An un-annotated parameter turns `mypy` off for the whole function
body it belongs to, so leaving one out costs more than the
annotation would have. Nothing in the repo said to write them,
and review has had to ask for them one function at a time.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TQxdTEi8qsBfxCcuLxrNmQ
---
 .../rules/python-annotate-every-parameter.md  | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 .claude/rules/python-annotate-every-parameter.md

diff --git a/.claude/rules/python-annotate-every-parameter.md b/.claude/rules/python-annotate-every-parameter.md
new file mode 100644
index 000000000..e61c7b800
--- /dev/null
+++ b/.claude/rules/python-annotate-every-parameter.md
@@ -0,0 +1,21 @@
+# Annotate every Python parameter and return type
+
+Give every parameter of every Python function and method a type
+annotation, and every function a return type — including `self`-less
+helpers, nested functions, and parameters whose type feels obvious
+from the name. Leaving one off because `mypy` doesn't demand it is
+not a reason to leave it off.
+
+**Why:** `mypy` only checks a function's body once its signature is
+annotated, so a single un-annotated parameter silently switches off
+checking for everything that flows through it. An annotation is also
+the cheapest documentation a reader gets: `stub` says nothing,
+`stub: react_pb2_grpc.ReactStub` says where to look next.
+
+**How to apply:** When writing or editing a `def`, annotate all of
+its parameters and its return type in the same edit. When a
+parameter's type is a generated protobuf message or gRPC stub, name
+that type rather than falling back to `Any` — import it if the module
+doesn't already. `self` and `cls` need no annotation, and neither do
+`*args`/`**kwargs` when they are forwarded verbatim to an already
+typed callee.

From 0e1f6fa20e24253fbdee885f5f9bbdb75a8472b7 Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Fri, 11 Sep 2026 08:45:06 +0000
Subject: [PATCH 08/13] Simplify the windowing logic, per review comments

By splitting the single accumulate-and-send loop
into two loops, the logic becomes more linear and
easier to read. Simplifying the window helper
class also reduces complexity.
---
 reboot/aio/react.py | 268 ++++++++++++++++++++++----------------------
 1 file changed, 132 insertions(+), 136 deletions(-)

diff --git a/reboot/aio/react.py b/reboot/aio/react.py
index 0e8b54773..32b5dcbe2 100644
--- a/reboot/aio/react.py
+++ b/reboot/aio/react.py
@@ -6,6 +6,7 @@
 import traceback
 import uuid
 import websockets
+from asyncio import CancelledError
 from google.protobuf.json_format import MessageToJson
 from google.rpc import code_pb2, status_pb2
 from grpc_health.v1 import health_pb2
@@ -53,62 +54,34 @@
 
 
 class _QueryWindow:
-    """How much room a query has to send responses before it must hear
-    from its client.
+    """
+    A helper class to track whether there is room in a sending window.
 
-    Starts with `QUERY_RESPONSE_WINDOW` room; `take()` spends one and
-    waits when there is none; `processed()` reports the last sequence
-    number a client has fully processed and returns the room that
-    accounts for.
+    Its main added value is to convert "I've seen response sequence number X" to
+    "we can send N more responses".
     """
 
     def __init__(self):
-        self._room = QUERY_RESPONSE_WINDOW
-        self._has_room = asyncio.Event()
-        self._has_room.set()
-        # Sequence number of the next response to send, and of the
-        # last one the client has reported processing. The client has
-        # reported nothing until it does, hence -1.
-        self.sequence_number = 0
-        self._processed = -1
-
-    def try_take(self) -> Optional[int]:
-        """Returns the sequence number to send, or `None` when there is
-        no room to send anything."""
-        if self._room == 0:
-            return None
-
-        self._room -= 1
-
-        if self._room == 0:
-            self._has_room.clear()
-
-        sequence_number = self.sequence_number
-        self.sequence_number += 1
-        return sequence_number
-
-    async def take(self) -> int:
-        """Waits for room and returns the sequence number to send."""
-        while True:
-            await self._has_room.wait()
-            sequence_number = self.try_take()
-            if sequence_number is not None:
-                return sequence_number
-
-    def processed(self, sequence_number: int) -> None:
-        """Returns the room accounted for by a client reporting that it
-        has processed everything up to `sequence_number`."""
-        # A client can only have processed what we sent, and only ever
-        # more than it last reported; anything else is a duplicate or
-        # a retry, which returns no room rather than inventing any.
-        sequence_number = min(sequence_number, self.sequence_number - 1)
-
-        self._room += max(0, sequence_number - self._processed)
-
-        if self._room > 0:
-            self._has_room.set()
-
-        self._processed = max(self._processed, sequence_number)
+        self._room = asyncio.Semaphore(QUERY_RESPONSE_WINDOW)
+        # Neither has happened yet, and the first response to be sent
+        # is sequence number 0, hence -1.
+        self._last_acquired_sequence_number = -1
+        self._last_released_sequence_number = -1
+
+    async def acquire(self) -> int:
+        await self._room.acquire()
+        self._last_acquired_sequence_number += 1
+        return self._last_acquired_sequence_number
+
+    def release(self, sequence_number: int) -> None:
+        # A client can only reasonably send us a sequence number that's been
+        # issued.
+        if sequence_number > self._last_acquired_sequence_number:
+            return
+
+        while sequence_number > self._last_released_sequence_number:
+            self._room.release()
+            self._last_released_sequence_number += 1
 
 
 class _SuppressInvalidHandshakeFilter(logging.Filter):
@@ -443,7 +416,7 @@ async def consume_requests():
                     if window is not None and continuation.HasField(
                         'continue_query_sequence_number'
                     ):
-                        window.processed(
+                        window.release(
                             continuation.continue_query_sequence_number
                         )
             except Exception:
@@ -555,7 +528,7 @@ async def ContinueQuery(
             # Either way there is no window left to return room to.
             return react_pb2.ContinueQueryResponse()
 
-        window.processed(request.sequence_number)
+        window.release(request.sequence_number)
 
         return react_pb2.ContinueQueryResponse()
 
@@ -595,15 +568,14 @@ async def _windowed_query(
         query_id: str,
         window: Optional[_QueryWindow],
     ) -> AsyncIterator[react_pb2.QueryResponse]:
-        """Produces the responses of `_query()`, each stamped with the
-        query it belongs to and the room it is sent under.
-
-        Asks for states as fast as they are produced even while there
-        is no room to send one. A state that arrives while we are
-        waiting for room is merged into the response we are holding,
-        so the response we send once there is room carries the latest
-        state and says how long it waited and how many updates it
-        stood in for.
+        """
+        Produces the responses of `_query()`, but only when there is room in
+        `window`. While there is no room in `window`, accumulates responses into
+        a single response.
+
+        The produced responses carry information about the query that produced
+        them, their sequence number, and how long they were stalled waiting for
+        `window` to have room.
         """
         responses = self._query(
             request=request,
@@ -618,93 +590,117 @@ async def _windowed_query(
                 yield response
             return
 
-        # The response we have asked for but have no room for yet, and
-        # the room we are waiting on. Both outlive an iteration of the
-        # loop below: dropping an ask for a response would lose the
-        # state that ask is waiting for.
-        asked: Optional[asyncio.Future] = None
-        room: Optional[asyncio.Future] = None
+        # We'll run two loops concurrently:
+        # 1. Consume responses from the stream, and merge them into a single
+        #    "next response".
+        # 2. Wait for there to be room in our window, and send the next
+        #    response.
+        #
+        # Under normal conditions (if there's always room in the window), this
+        # will mostly forward the incoming responses verbatim - the assumption
+        # being that loop (1) will normally run slower than loop (2). If there's
+        # no room in the window, or for any other reason sending a response
+        # becomes very slow, loop (1) outpaces loop (2); in that case it'll
+        # start merging responses together, ensuring that clients always get the
+        # latest available result.
+        next_response: Optional[react_pb2.QueryResponse] = None
+        have_next_response = asyncio.Event()
+        responses_accumulated = 0
+        failure: Optional[BaseException] = None
+
+        async def accumulate_next_response():
+            nonlocal next_response, responses_accumulated, failure
 
-        try:
             while True:
-                if asked is None:
-                    asked = asyncio.ensure_future(anext(responses, None))
-
-                response = await asked
-                asked = None
-
-                if response is None:
+                try:
+                    response = await anext(
+                        responses
+                        # `responses` is never exhausted, so no default
+                        # is needed.
+                    )
+                except CancelledError:
+                    raise
+                except BaseException as exception:
+                    # Producing a state failed; that needs to be propagated to
+                    # the caller of `Query`. We can't just `raise` it from here,
+                    # because this loop is a background task, so we signal the
+                    # response-sending loop instead.
+                    failure = exception
+                    have_next_response.set()
                     return
 
-                sequence_number = window.try_take()
+                if next_response is None:
+                    next_response = response
+                else:
+                    # `MergeFrom` is exactly what one response standing in for two
+                    # means: the newer state replaces the one we hold, an update
+                    # that carries no state of its own leaves that state alone, and
+                    # we keep the idempotency keys of both, since a mutation
+                    # reported once must not be lost because the response reporting
+                    # it was merged away.
+                    next_response.MergeFrom(response)
 
-                if sequence_number is None:
-                    stalled_at = time.monotonic()
-                    skipped = 0
-                    room = asyncio.ensure_future(window.take())
+                responses_accumulated += 1
 
-                    while True:
-                        if asked is None:
-                            asked = asyncio.ensure_future(
-                                anext(responses, None)
-                            )
+                have_next_response.set()
 
-                        await asyncio.wait(
-                            [room, asked],
-                            return_when=asyncio.FIRST_COMPLETED,
-                        )
+        accumulator: asyncio.Task[None] = asyncio.create_task(
+            accumulate_next_response()
+        )
 
-                        if asked.done():
-                            update = asked.result()
-                            asked = None
-
-                            if update is None:
-                                # What we hold is the last response of
-                                # this query; it still needs room.
-                                sequence_number = await room
-                                break
-
-                            skipped += 1
-
-                            # `MergeFrom` is exactly what one response
-                            # standing in for two means: the newer
-                            # state replaces the one we hold, an
-                            # update that carries no state of its own
-                            # leaves that state alone, and we keep the
-                            # idempotency keys of both, since a
-                            # mutation reported once must not be lost
-                            # because the response reporting it was
-                            # merged away.
-                            response.MergeFrom(update)
-
-                        if room.done():
-                            sequence_number = room.result()
-                            break
-
-                    room = None
-
-                    stall_milliseconds = round(
-                        (time.monotonic() - stalled_at) * 1000
+        try:
+            while True:
+                # Wait for there to be some next response to send, or for
+                # producing one to have failed.
+                await have_next_response.wait()
+
+                if failure is not None:
+                    raise failure
+
+                # Wait for there to be room in the window.
+                stall_start = time.monotonic()
+                sequence_number = await window.acquire()
+
+                # Consume the `next_response`, clearing it so the other loop can
+                # accumulate a fresh one. It's important to note that this is
+                # done atomically, without yielding the event loop.
+                assert next_response is not None
+                response = next_response
+                next_response = None
+                skipped_updates = responses_accumulated - 1
+                responses_accumulated = 0
+
+                # Leave the event set if the accumulator failed while
+                # we waited for room: its `set()` landed on an event
+                # that was already set, so clearing here would throw
+                # away the only notice we get, and the next iteration
+                # would wait on a task that has already ended.
+                if failure is None:
+                    have_next_response.clear()
+
+                stall_milliseconds = round(
+                    (time.monotonic() - stall_start) * 1000
+                )
+                if stall_milliseconds > REPORTABLE_STALL_MILLISECONDS:
+                    logger.info(
+                        f"A client of a reactive query to `{request.method}` "
+                        f"skipped {skipped_updates} updates because it fell "
+                        f"{stall_milliseconds}ms behind"
                     )
 
-                    response.stall_milliseconds = stall_milliseconds
-                    response.skipped_updates = skipped
-
-                    if stall_milliseconds > REPORTABLE_STALL_MILLISECONDS:
-                        logger.info(
-                            "A client of a reactive query to "
-                            f"`{request.method}` skipped {skipped} updates "
-                            f"because it fell {stall_milliseconds}ms behind"
-                        )
-
+                # Send the response we'd accumulated.
                 response.query_id = query_id
                 response.sequence_number = sequence_number
-
+                response.skipped_updates = skipped_updates
+                response.stall_milliseconds = stall_milliseconds
                 yield response
+
         finally:
-            for future in (asked, room):
-                if future is not None:
-                    future.cancel()
+            accumulator.cancel()
+            try:
+                await accumulator
+            except CancelledError:
+                pass
 
     async def Query(
         self,

From e47d1b8c002534601456067ddb076cb574c38118 Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Fri, 11 Sep 2026 13:04:53 +0000
Subject: [PATCH 09/13] Remove backend-to-backend flow control

To avoid interfering with ongoing work in
backend-to-backend call coalescing, this removes
the backend-to-backend use of flow control.
---
 reboot/aio/contexts.py          | 38 +++++++++++++++------------------
 tests/reboot/reactivity_test.py | 11 +++++-----
 2 files changed, 22 insertions(+), 27 deletions(-)

diff --git a/reboot/aio/contexts.py b/reboot/aio/contexts.py
index 958f60160..923a961bb 100644
--- a/reboot/aio/contexts.py
+++ b/reboot/aio/contexts.py
@@ -539,7 +539,6 @@ async def query():
                         react_pb2.QueryRequest(
                             method=self._method,
                             request=serialized_request,
-                            client_continues_query=True,
                         ),
                         metadata=metadata,
                     )
@@ -559,6 +558,23 @@ async def query():
                     async def loop():
                         assert task is not None
 
+                        # Keep consuming however fast they arrive,
+                        # letting each response replace the one before
+                        # it. A reader that reads faster than this one
+                        # can re-run therefore has its updates
+                        # accumulated into the latest state, which is
+                        # the one waiting here when this reader next
+                        # asks for it. See
+                        # https://github.com/reboot-dev/mono/issues/4754.
+                        #
+                        # Replacing drops the idempotency keys the
+                        # response carried, which is deliberate: the
+                        # keys a reactive read reports upward are the
+                        # ones for its own state's mutations, which
+                        # `reactively()` aggregates for it, and a
+                        # browser observes a mutation on the query of
+                        # the state it mutated. Keys kept here would
+                        # reach no one.
                         async for query_response in call:
                             if query_response.HasField('response'):
                                 response = self._response_type()
@@ -566,8 +582,6 @@ async def loop():
                                     query_response.response
                                 )
 
-                                self._used_response[task].clear()
-
                                 self._calls[task] = call
 
                                 self._responses[task] = asyncio.Future()
@@ -578,20 +592,8 @@ async def loop():
                                 else:
                                     self._event.set()
 
-                                await self._used_response[task].wait()
-
-                            # Only now that the response has been used
-                            # do we continue past it, so that we can't
-                            # fall behind a server that produces
-                            # responses faster than we consume them.
-                            # See
-                            # https://github.com/reboot-dev/mono/issues/4754.
-                            await continuations.continue_past(query_response)
-
                         raise RuntimeError('React.Query should be infinite')
 
-                    continuations = QueryContinuations(stub, metadata)
-
                     try:
                         await loop()
                     except asyncio.CancelledError:
@@ -621,12 +623,6 @@ async def loop():
 
                         # Let's retry after a backoff!
                         await backoff()
-                    finally:
-                        # Whether we are retrying or giving up, this
-                        # attempt's continuation is about to be
-                        # irrelevant: a fresh `Query` gets a fresh
-                        # window.
-                        await continuations.stop()
 
             task = asyncio.create_task(query(), name=f'query() in {__name__}')
 
diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py
index 13191fd3f..cc45f5e6f 100644
--- a/tests/reboot/reactivity_test.py
+++ b/tests/reboot/reactivity_test.py
@@ -348,12 +348,11 @@ async def get_greetings(expected_number: int) -> list[str]:
             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. Each
-        # hop has a window of its own, but a hop with no room merges
-        # what it is holding rather than letting responses queue up
-        # behind it, so the hops don't add up: this reader is a single
-        # window behind, plus the one response that carries the skip
-        # to the latest state.
+        # the latest state without seeing every state it missed. Only
+        # the hop to this reader has a window; the `Greeter` read that
+        # the proxy does behind it keeps just the latest state it was
+        # sent. So this reader is a single window behind, plus the one
+        # response that carries the skip to the latest state.
         can_greet_again.set()
 
         latest = f"Hi Alice, I am Mr. Robot the {adjectives[-1]}"

From 8eb2e5efd840128fe30388c324ce170f7e2b399f Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Fri, 11 Sep 2026 13:14:14 +0000
Subject: [PATCH 10/13] Address Claude review comments

The rule this branch adds asks every Python parameter to carry a
type, and two of the test helpers it also adds did not: the
`ReactStub` shim that stands in for a client from before
`ContinueQuery` existed, and the three browser-polling helpers in
the flow control test, which annotated everything except the
`driver` they are handed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TQxdTEi8qsBfxCcuLxrNmQ
---
 reboot/aio/contexts.py                        |  2 +-
 reboot/aio/react.py                           |  6 +++---
 .../test_reactive_reader_flow_control/test.py | 15 +++++++++----
 tests/reboot/reactivity_test.py               | 21 ++++++++++++-------
 4 files changed, 28 insertions(+), 16 deletions(-)

diff --git a/reboot/aio/contexts.py b/reboot/aio/contexts.py
index 923a961bb..5b949ea34 100644
--- a/reboot/aio/contexts.py
+++ b/reboot/aio/contexts.py
@@ -357,7 +357,7 @@ def __init__(
         self,
         stub: react_pb2_grpc.ReactStub,
         metadata: GrpcMetadata,
-    ):
+    ) -> None:
         self._stub = stub
         self._metadata = metadata
         self._continuation: Optional[asyncio.Future] = None
diff --git a/reboot/aio/react.py b/reboot/aio/react.py
index 32b5dcbe2..7f80f90b0 100644
--- a/reboot/aio/react.py
+++ b/reboot/aio/react.py
@@ -61,7 +61,7 @@ class _QueryWindow:
     "we can send N more responses".
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._room = asyncio.Semaphore(QUERY_RESPONSE_WINDOW)
         # Neither has happened yet, and the first response to be sent
         # is sequence number 0, hence -1.
@@ -401,7 +401,7 @@ async def _websocket_query(
         # transport there is nothing to key on.
         window = _QueryWindow() if request.client_continues_query else None
 
-        async def consume_requests():
+        async def consume_requests() -> None:
             try:
                 while True:
                     request_bytes = await websocket.recv()
@@ -608,7 +608,7 @@ async def _windowed_query(
         responses_accumulated = 0
         failure: Optional[BaseException] = None
 
-        async def accumulate_next_response():
+        async def accumulate_next_response() -> None:
             nonlocal next_response, responses_accumulated, failure
 
             while True:
diff --git a/tests/reboot/react/test_reactive_reader_flow_control/test.py b/tests/reboot/react/test_reactive_reader_flow_control/test.py
index e8baf64f2..b7542df0d 100644
--- a/tests/reboot/react/test_reactive_reader_flow_control/test.py
+++ b/tests/reboot/react/test_reactive_reader_flow_control/test.py
@@ -4,6 +4,7 @@
 from reboot.aio.external import ExternalContext
 from reboot.aio.react import QUERY_RESPONSE_WINDOW
 from selenium.webdriver.common.by import By
+from selenium.webdriver.remote.webdriver import WebDriver
 from tests.reboot.greeter_rbt import Greeter
 from tests.reboot.react.web_driver_runner import web_driver
 
@@ -17,7 +18,7 @@
 ]
 
 
-async def test(context: ExternalContext, uri: str):
+async def test(context: ExternalContext, uri: str) -> None:
     """Tests that a reactive reader whose consumer is slow to ask for a
     next response falls no further behind than the room the backend
     has to send responses, and then skips to the latest state.
@@ -44,7 +45,7 @@ async def test(context: ExternalContext, uri: str):
     def message(adjective: str) -> str:
         return f'Hi Jonathan, I am Count Chocula the {adjective}'
 
-    def rendered_messages(driver) -> list[str]:
+    def rendered_messages(driver: WebDriver) -> list[str]:
         """Returns every message the browser has rendered, in order."""
         try:
             rendered = driver.find_element(By.ID, 'rendered'
@@ -58,12 +59,18 @@ def rendered_messages(driver) -> list[str]:
     # 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]:
+    def wait_for_message_count(
+        driver: WebDriver,
+        count: int,
+    ) -> list[str]:
         while len(rendered_messages(driver)) < count:
             time.sleep(0.1)
         return rendered_messages(driver)
 
-    def wait_for_latest_message(driver, latest: str) -> list[str]:
+    def wait_for_latest_message(
+        driver: WebDriver,
+        latest: str,
+    ) -> list[str]:
         rendered = rendered_messages(driver)
         while len(rendered) == 0 or rendered[-1] != latest:
             time.sleep(0.1)
diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py
index cc45f5e6f..b76642dfe 100644
--- a/tests/reboot/reactivity_test.py
+++ b/tests/reboot/reactivity_test.py
@@ -1,5 +1,6 @@
 import asyncio
 import contextlib
+import grpc
 import unittest
 from rbt.v1alpha1 import react_pb2, react_pb2_grpc
 from reboot.aio.applications import Application
@@ -13,7 +14,7 @@
 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 typing import Any, Iterator, Optional
 from unittest.mock import patch
 
 # `title` that marks a `Greeter` as one whose `Greet` reads another
@@ -40,13 +41,13 @@ class QueryRequestWithoutContinuations:
     SerializeToString = QUERY_REQUEST.SerializeToString
     FromString = QUERY_REQUEST.FromString
 
-    def __new__(cls, **kwargs):
+    def __new__(cls, **kwargs: Any) -> react_pb2.QueryRequest:
         kwargs.pop('client_continues_query', None)
         return QUERY_REQUEST(**kwargs)
 
 
 @contextlib.contextmanager
-def query_requests_without_continuations():
+def query_requests_without_continuations() -> Iterator[list[str]]:
     """Makes every reactive reader send a `QueryRequest` the way a
     client from before `ContinueQuery` existed did. Both the generated
     clients and `reboot.aio.contexts` look `QueryRequest` and
@@ -62,13 +63,17 @@ def query_requests_without_continuations():
 
     class ReactStub:
 
-        def __init__(self, channel):
+        def __init__(self, channel: grpc.aio.Channel) -> None:
             self._stub = REACT_STUB(channel)
 
-        def __getattr__(self, name):
+        def __getattr__(self, name: str) -> Any:
             return getattr(self._stub, name)
 
-        def ContinueQuery(self, request, **kwargs):
+        def ContinueQuery(
+            self,
+            request: react_pb2.ContinueQueryRequest,
+            **kwargs,
+        ) -> Any:
             continued.append(request.query_id)
             return self._stub.ContinueQuery(request, **kwargs)
 
@@ -131,7 +136,7 @@ async def _do():
 
         self._accumulate_task = asyncio.create_task(_do())
 
-    async def _stop_accumulating(self):
+    async def _stop_accumulating(self) -> None:
         assert self._accumulate_task is not None
         self._accumulate_task.cancel()
         try:
@@ -317,7 +322,7 @@ async def test_transitive_skip_to_latest(self) -> None:
         greeted = asyncio.Event()
         can_greet_again = asyncio.Event()
 
-        async def accumulate_greetings():
+        async def accumulate_greetings() -> None:
             async for response in proxy.reactively().Greet(
                 context,
                 name="Alice",

From ac5714184aa19916935e16a4d72ec9ee3bdb122a Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Mon, 14 Sep 2026 09:57:23 +0000
Subject: [PATCH 11/13] Address review comments

Before this change, `QueryResponse.query_id` signalled "no query to
continue" with an empty string, and two places that waited for a
task to end after cancelling it each spelled the cancel-and-await
dance out by hand. Review asked for the field to be `optional`, so
that its absence is tracked as presence rather than as a sentinel
value, and for both places to reuse `wait_for_tasks`.

- `rbt/v1alpha1/react.proto`: `optional string query_id`. The
  Python client checks `HasField('query_id')`; the TypeScript
  client checks for `undefined`, which is how protobuf-es renders
  an unset `optional` field.
- `QueryContinuations.stop()` and the accumulator cleanup in
  `_windowed_query()` go through `wait_for_tasks(..., cancel=True)`.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HfMTSCHtzXaNnhCvzQVcQd
---
 rbt/v1alpha1/react.proto |  6 +++---
 reboot/aio/contexts.py   | 13 ++++---------
 reboot/aio/react.py      |  6 +-----
 reboot/web/index.ts      |  4 ++--
 4 files changed, 10 insertions(+), 19 deletions(-)

diff --git a/rbt/v1alpha1/react.proto b/rbt/v1alpha1/react.proto
index 28f9d4f44..41621fb0f 100644
--- a/rbt/v1alpha1/react.proto
+++ b/rbt/v1alpha1/react.proto
@@ -63,9 +63,9 @@ message QueryResponse {
   // Unique ID of the query this response belongs to, which a client
   // names when it continues that query. The same for every response
   // of one `Query`. Only set when the client set
-  // `client_continues_query` on its `QueryRequest`; an empty ID means
-  // the client is not expected to continue anything.
-  string query_id = 4;
+  // `client_continues_query` on its `QueryRequest`; when unset, the
+  // client is not expected to continue anything.
+  optional string query_id = 4;
 
   // Position of this response within its query, counting from zero.
   // A client names the last one it has fully processed to continue
diff --git a/reboot/aio/contexts.py b/reboot/aio/contexts.py
index 5b949ea34..a8fea6812 100644
--- a/reboot/aio/contexts.py
+++ b/reboot/aio/contexts.py
@@ -360,7 +360,7 @@ def __init__(
     ) -> None:
         self._stub = stub
         self._metadata = metadata
-        self._continuation: Optional[asyncio.Future] = None
+        self._continuation: Optional[asyncio.Task] = None
 
     async def continue_past(
         self,
@@ -369,7 +369,7 @@ async def continue_past(
         """Continues the query past `query_response`, if there is no
         call already in flight. Raises whatever a previous call raised,
         so that a failure to continue surfaces on the read."""
-        if query_response.query_id == '':
+        if not query_response.HasField('query_id'):
             # An older backend doesn't send a query ID and doesn't
             # expect to be told.
             return
@@ -392,13 +392,8 @@ async def continue_past(
             )
 
     async def stop(self) -> None:
-        if self._continuation is not None:
-            self._continuation.cancel()
-            try:
-                await self._continuation
-            except BaseException:
-                pass
-            self._continuation = None
+        await wait_for_tasks([self._continuation], cancel=True)
+        self._continuation = None
 
 
 class React:
diff --git a/reboot/aio/react.py b/reboot/aio/react.py
index 7f80f90b0..a5f64fcdd 100644
--- a/reboot/aio/react.py
+++ b/reboot/aio/react.py
@@ -696,11 +696,7 @@ async def accumulate_next_response() -> None:
                 yield response
 
         finally:
-            accumulator.cancel()
-            try:
-                await accumulator
-            except CancelledError:
-                pass
+            await wait_for_tasks([accumulator], cancel=True)
 
     async def Query(
         self,
diff --git a/reboot/web/index.ts b/reboot/web/index.ts
index c4612ffde..9271a93c0 100644
--- a/reboot/web/index.ts
+++ b/reboot/web/index.ts
@@ -544,7 +544,7 @@ export async function* reactiveReader({
       // Only now that our consumer has processed the response do we
       // continue past it, so that we can't fall behind a backend that
       // produces responses faster than we consume them.
-      if (response.queryId === "") {
+      if (response.queryId === undefined) {
         // An older backend doesn't send a query ID and doesn't expect
         // to be told.
         continue;
@@ -597,7 +597,7 @@ export async function* reactiveReader({
       // as we have processed it, rather than past the newest of
       // several.
       continueRequest: (response: react_pb.QueryResponse) =>
-        response.queryId !== ""
+        response.queryId !== undefined
           ? new react_pb.QueryRequest({
               continueQuerySequenceNumber: response.sequenceNumber,
             })

From 0b7df66a4352be01f46a6403c0280e3465a36275 Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Mon, 14 Sep 2026 10:34:18 +0000
Subject: [PATCH 12/13] Address review comments

Before this change, a client that fell behind and had updates skipped
for it was told so only once it had waited more than 100ms, at `info`,
both in the server's log and in the browser console. Review asked to
warn on every skip until we have experience with which skips matter,
and to give a reader for which skipping is the point a way to opt
out.

- `QueryRequest` gains `suppress_flow_control_warning`. The server
  honors it and otherwise warns on every response that skipped
  updates, saying what to do about it.
- `reactively()` in `reboot/web` takes `warnOnFlowControl` (default
  `true`), sets that field from it, and warns the same way in the
  console. The generated `use<Method>(..., { warnOnFlowControl })`
  hook options and `reactively().<method>(..., { warnOnFlowControl })`
  pass it through.
- `REPORTABLE_STALL_MILLISECONDS` is gone. The reactivity test asserts
  the warning at its new level, and a new case asserts that a client
  which asked not to be warned is not.
- Goldens regenerated.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HfMTSCHtzXaNnhCvzQVcQd
---
 rbt/v1alpha1/react.proto                      |   7 +
 reboot/aio/react.py                           |  26 +--
 reboot/templates/reboot_react.ts.j2           |  19 ++-
 reboot/templates/reboot_web.ts.j2             |   3 +-
 reboot/web/index.ts                           |  44 +++--
 tests/reboot/greeter_rbt_react.golden.js      | 155 +++++++++++-------
 tests/reboot/greeter_rbt_web.golden.js        |   8 +
 .../test_reactive_reader_flow_control/test.py |   4 +-
 tests/reboot/reactivity_test.py               | 102 +++++++++---
 9 files changed, 252 insertions(+), 116 deletions(-)

diff --git a/rbt/v1alpha1/react.proto b/rbt/v1alpha1/react.proto
index 41621fb0f..4baf6ac40 100644
--- a/rbt/v1alpha1/react.proto
+++ b/rbt/v1alpha1/react.proto
@@ -37,6 +37,13 @@ message QueryRequest {
   // `QueryRequest`, which is why presence matters here: sequence
   // number zero is a real response.
   optional uint64 continue_query_sequence_number = 5;
+
+  // Whether this client has asked not to be warned when it falls
+  // behind and updates are skipped on its behalf. By default both the
+  // client and the server log a warning every time that happens, so
+  // that a client that expected to see every update learns that it
+  // did not; a client for which skipping is the point sets this.
+  bool suppress_flow_control_warning = 6;
 }
 
 message QueryResponse {
diff --git a/reboot/aio/react.py b/reboot/aio/react.py
index a5f64fcdd..be60939dc 100644
--- a/reboot/aio/react.py
+++ b/reboot/aio/react.py
@@ -45,13 +45,6 @@
 #       fixing it for everyone.
 QUERY_RESPONSE_WINDOW = 10
 
-# How long a response must wait for room before we say so, in the
-# server's log and in the response itself. 100ms is about where a
-# person stops experiencing an update as immediate and starts
-# perceiving lag, so a client that waits longer than this is one whose
-# user can see it waiting.
-REPORTABLE_STALL_MILLISECONDS = 100
-
 
 class _QueryWindow:
     """
@@ -681,11 +674,24 @@ async def accumulate_next_response() -> None:
                 stall_milliseconds = round(
                     (time.monotonic() - stall_start) * 1000
                 )
-                if stall_milliseconds > REPORTABLE_STALL_MILLISECONDS:
-                    logger.info(
+
+                # Warn every time updates are skipped, until we have
+                # enough experience with flow control to know which
+                # skips a developer needs to hear about; a client for
+                # which skipping is the point asks us not to.
+                if (
+                    skipped_updates > 0 and
+                    not request.suppress_flow_control_warning
+                ):
+                    logger.warning(
                         f"A client of a reactive query to `{request.method}` "
                         f"skipped {skipped_updates} updates because it fell "
-                        f"{stall_milliseconds}ms behind"
+                        f"{stall_milliseconds}ms behind. If skipping updates "
+                        "is not what you expect of this reactive read, make "
+                        "that client fast enough to process every response; "
+                        "if it is, pass `{ warnOnFlowControl: false }` in "
+                        "the options of the client's reader to silence this "
+                        "warning."
                     )
 
                 # Send the response we'd accumulated.
diff --git a/reboot/templates/reboot_react.ts.j2 b/reboot/templates/reboot_react.ts.j2
index 46c966ee3..de046a85e 100644
--- a/reboot/templates/reboot_react.ts.j2
+++ b/reboot/templates/reboot_react.ts.j2
@@ -541,7 +541,7 @@ export interface Use{{ client.proto.state_name }}Api {
   };
   use{{ method.proto.name | to_camel }}(
     partialRequest?: {{ client.proto.state_name }}.Partial{{ method.proto.name }}Request,
-    options?: { suspense: true }
+    options?: { suspense: true; warnOnFlowControl?: boolean }
   ): {
     response: {{ client.proto.state_name }}.{{ method.proto.name }}Response;
     isLoading: boolean;
@@ -553,7 +553,7 @@ export interface Use{{ client.proto.state_name }}Api {
   };
   use{{ method.proto.name | to_camel }}(
     partialRequest?: {{ client.proto.state_name }}.Partial{{ method.proto.name }}Request,
-    options?: { suspense: false }
+    options?: { suspense?: false; warnOnFlowControl?: boolean }
   ): {
     response: {{ client.proto.state_name }}.{{ method.proto.name }}Response | undefined;
     isLoading: boolean;
@@ -769,6 +769,7 @@ class {{ client.proto.state_name | to_camel }}Instance {
     method: string,
     serializedRequest: Uint8Array,
     bearerToken: string | undefined,
+    warnOnFlowControl: boolean,
     responseType: protobuf_es.MessageType<ResponseType>,
     reader: reboot_react.Reader<ResponseType>
   ) {
@@ -776,6 +777,7 @@ class {{ client.proto.state_name | to_camel }}Instance {
       method,
       request: serializedRequest,
       clientContinuesQuery: true,
+      suppressFlowControlWarning: !warnOnFlowControl,
       ...(bearerToken !== undefined && { bearerToken } || {}),
     });
 
@@ -1170,6 +1172,7 @@ class {{ client.proto.state_name | to_camel }}Instance {
     requestBearerTokenHash: string,
     serializedRequest: Uint8Array,
     bearerToken: string | undefined,
+    warnOnFlowControl: boolean,
     offlineCacheEnabled: boolean,
     cacheKey: string | null
   ) {
@@ -1278,6 +1281,7 @@ class {{ client.proto.state_name | to_camel }}Instance {
         "{{ method.proto.name }}",
         serializedRequest,
         bearerToken,
+        warnOnFlowControl,
         {{ method.output_type }},
         reader
       );
@@ -1316,6 +1320,7 @@ class {{ client.proto.state_name | to_camel }}Instance {
     requestBearerTokenHash: string,
     serializedRequest: Uint8Array,
     bearerToken: string | undefined,
+    warnOnFlowControl: boolean,
     offlineCacheEnabled: boolean,
     cacheKey: string | null,
     setResponse: (response: {{ method.output_type }}) => void,
@@ -1330,6 +1335,7 @@ class {{ client.proto.state_name | to_camel }}Instance {
       requestBearerTokenHash,
       serializedRequest,
       bearerToken,
+      warnOnFlowControl,
       offlineCacheEnabled,
       cacheKey
     );
@@ -1634,7 +1640,7 @@ export const use{{ client.proto.state_name | to_camel }} = (
 
   function use{{ method.proto.name | to_camel }}(
     partialRequest: {{ client.proto.state_name }}.Partial{{ method.proto.name}}Request = {},
-    options: { suspense: boolean } = { suspense: false }
+    options: { suspense?: boolean; warnOnFlowControl?: boolean } = {}
   ) {
     const newRequest = {{ client.proto.state_name }}{{ method.proto.name }}RequestToProtobuf(partialRequest);
 
@@ -1695,10 +1701,16 @@ export const use{{ client.proto.state_name | to_camel }} = (
     // we need to use the `reader.response` or `reader.status` during
     // render where one of them will be defined, i.e., after we've
     // waited for `reader.promise` via `React.use()`.
+    // Readers are shared between every component that reads the same
+    // request, so the first of them decides whether the console warns
+    // when the read falls behind.
+    const warnOnFlowControl = options.warnOnFlowControl ?? true;
+
     const reader = instance.start{{ method.proto.name | to_camel }}(
       requestBearerTokenHash,
       serializedRequest,
       bearerToken,
+      warnOnFlowControl,
       offlineCacheEnabled,
       cacheKey
     );
@@ -1732,6 +1744,7 @@ export const use{{ client.proto.state_name | to_camel }} = (
         requestBearerTokenHash,
         serializedRequest,
         bearerToken,
+        warnOnFlowControl,
         offlineCacheEnabled,
         cacheKey,
         (response: {{ method.output_type }}) => {
diff --git a/reboot/templates/reboot_web.ts.j2 b/reboot/templates/reboot_web.ts.j2
index ee651f664..3f840b11a 100644
--- a/reboot/templates/reboot_web.ts.j2
+++ b/reboot/templates/reboot_web.ts.j2
@@ -433,7 +433,7 @@ class _Reactively {
   async {{ method.proto.name | to_lower_camel }}(
     context: reboot_web.WebContext,
     partialRequest?: {{ client.proto.state_name }}.Partial{{ method.proto.name }}Request,
-    options?: { signal?: AbortSignal },
+    options?: { signal?: AbortSignal; warnOnFlowControl?: boolean },
   ): Promise<[
       AsyncGenerator<{{ client.proto.state_name }}.{{ method.proto.name }}Response, void, unknown>,
       (newRequest: {{ client.proto.state_name }}.Partial{{ method.proto.name }}Request) => void
@@ -452,6 +452,7 @@ class _Reactively {
         signal: options?.signal,
         bearerToken: context.bearerToken,
         websockets: context.websockets,
+        warnOnFlowControl: options?.warnOnFlowControl,
       }
     );
 
diff --git a/reboot/web/index.ts b/reboot/web/index.ts
index 9271a93c0..01614c39b 100644
--- a/reboot/web/index.ts
+++ b/reboot/web/index.ts
@@ -294,6 +294,7 @@ export function reactively<
   signal,
   bearerToken,
   websockets = false,
+  warnOnFlowControl = true,
 }: {
   url: string;
   state: string;
@@ -305,6 +306,9 @@ export function reactively<
   signal?: AbortSignal;
   bearerToken?: () => Promise<string | undefined>;
   websockets: boolean;
+  // Whether to warn in the console when this reader falls behind and
+  // the backend skips updates for it; see `logStall`.
+  warnOnFlowControl?: boolean;
 }): [
   AsyncGenerator<ResponseType, void, unknown>,
   (newRequest: PartialMessage<RequestType>) => void
@@ -382,6 +386,7 @@ export function reactively<
           method,
           request: request.toBinary(),
           clientContinuesQuery: true,
+          suppressFlowControlWarning: !warnOnFlowControl,
           ...((bearerToken !== undefined && {
             bearerToken: await bearerToken(),
           }) ||
@@ -419,23 +424,26 @@ export function reactively<
   return [responses(), setRequest];
 }
 
-// How long a response must have waited for us before we say so in
-// the console. 100ms is about where a person stops experiencing an
-// update as immediate and starts perceiving lag, so a response that
-// waited longer than this is one whose delay our user could see; the
-// backend uses the same threshold for its own log.
-const LOGGED_STALL_MILLISECONDS = 100;
-
-// Tells the developer that this client fell far enough behind its
-// backend that the backend merged updates it would otherwise have
-// sent. The state we go on to render is still the latest one; what
-// was lost is the updates on the way there.
-function logStall(method: string, response: react_pb.QueryResponse) {
-  if (response.stallMilliseconds > LOGGED_STALL_MILLISECONDS) {
-    console.info(
-      `[Reboot] A reactive query to \`${method}\` skipped ` +
+// Tells the developer that this client fell behind its backend, which
+// merged updates it would otherwise have sent. The state we go on to
+// render is still the latest one; what was lost is the updates on the
+// way there. Warns every time that happens, until we have enough
+// experience with flow control to know which skips a developer needs
+// to hear about; a reader for which skipping is the point asks us not
+// to, in the `request`.
+function logStall(
+  request: react_pb.QueryRequest,
+  response: react_pb.QueryResponse
+) {
+  if (response.skippedUpdates > 0 && !request.suppressFlowControlWarning) {
+    console.warn(
+      `[Reboot] A reactive query to \`${request.method}\` skipped ` +
         `${response.skippedUpdates} updates because this client fell ` +
-        `${response.stallMilliseconds}ms behind`
+        `${response.stallMilliseconds}ms behind. If skipping updates is ` +
+        `not what you expect of this reactive read, make this client ` +
+        `fast enough to process every response; if it is, pass ` +
+        `\`{ warnOnFlowControl: false }\` in the options of the reader ` +
+        `to silence this warning.`
     );
   }
 }
@@ -537,7 +545,7 @@ export async function* reactiveReader({
     let settled = true;
 
     for await (const response of responses) {
-      logStall(request.method, response);
+      logStall(request, response);
 
       yield response;
 
@@ -609,7 +617,7 @@ export async function* reactiveReader({
         throw Status.fromJsonString(response.responseOrStatus.value);
       }
 
-      logStall(request.method, response);
+      logStall(request, response);
 
       yield response;
     }
diff --git a/tests/reboot/greeter_rbt_react.golden.js b/tests/reboot/greeter_rbt_react.golden.js
index 3c5104132..03694fa45 100755
--- a/tests/reboot/greeter_rbt_react.golden.js
+++ b/tests/reboot/greeter_rbt_react.golden.js
@@ -1878,11 +1878,12 @@ class GreeterInstance {
             }
         });
     }
-    async read(method, serializedRequest, bearerToken, responseType, reader) {
+    async read(method, serializedRequest, bearerToken, warnOnFlowControl, responseType, reader) {
         const queryRequest = new reboot_api.react_pb.QueryRequest({
             method,
             request: serializedRequest,
             clientContinuesQuery: true,
+            suppressFlowControlWarning: !warnOnFlowControl,
             ...(bearerToken !== undefined && { bearerToken } || {}),
         });
         let expecteds = [];
@@ -2157,7 +2158,7 @@ class GreeterInstance {
     unuseCreate(id) {
         delete this.useCreateSetPendings[id];
     }
-    startGreet(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey) {
+    startGreet(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey) {
         var _a;
         let reader = this.useGreetReaders[requestBearerTokenHash];
         if (reader === undefined) {
@@ -2236,7 +2237,7 @@ class GreeterInstance {
             });
             this.useGreetReaders[requestBearerTokenHash] = reader;
             // Start fetching from the server.
-            this.read("Greet", serializedRequest, bearerToken, greeter_pb.GreetResponse, reader);
+            this.read("Greet", serializedRequest, bearerToken, warnOnFlowControl, greeter_pb.GreetResponse, reader);
             // Check if there is a cached result if applicable.
             if (offlineCacheEnabled) {
                 reboot_api.assert(cacheKey !== null);
@@ -2258,12 +2259,12 @@ class GreeterInstance {
         reboot_api.assert(reader !== undefined);
         return reader;
     }
-    useGreet(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
+    useGreet(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
         // We need to call start here because with strict mode the
         // `useEffect` that calls this method will also call "unuse"
         // which will mean the next time the `useEffect` calls here
         // we'll create a new reader in start.
-        const reader = this.startGreet(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        const reader = this.startGreet(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         reboot_api.assert(reader !== undefined);
         // Indicate that the reader has properly been used so that we don't
         // clean it up prematurely.
@@ -2499,7 +2500,7 @@ class GreeterInstance {
     unuseTransactionSetAdjective(id) {
         delete this.useTransactionSetAdjectiveSetPendings[id];
     }
-    startTryToConstructContext(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey) {
+    startTryToConstructContext(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey) {
         var _a;
         let reader = this.useTryToConstructContextReaders[requestBearerTokenHash];
         if (reader === undefined) {
@@ -2578,7 +2579,7 @@ class GreeterInstance {
             });
             this.useTryToConstructContextReaders[requestBearerTokenHash] = reader;
             // Start fetching from the server.
-            this.read("TryToConstructContext", serializedRequest, bearerToken, Empty, reader);
+            this.read("TryToConstructContext", serializedRequest, bearerToken, warnOnFlowControl, Empty, reader);
             // Check if there is a cached result if applicable.
             if (offlineCacheEnabled) {
                 reboot_api.assert(cacheKey !== null);
@@ -2600,12 +2601,12 @@ class GreeterInstance {
         reboot_api.assert(reader !== undefined);
         return reader;
     }
-    useTryToConstructContext(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
+    useTryToConstructContext(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
         // We need to call start here because with strict mode the
         // `useEffect` that calls this method will also call "unuse"
         // which will mean the next time the `useEffect` calls here
         // we'll create a new reader in start.
-        const reader = this.startTryToConstructContext(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        const reader = this.startTryToConstructContext(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         reboot_api.assert(reader !== undefined);
         // Indicate that the reader has properly been used so that we don't
         // clean it up prematurely.
@@ -2645,7 +2646,7 @@ class GreeterInstance {
             }, 3000);
         }
     }
-    startTryToConstructExternalContext(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey) {
+    startTryToConstructExternalContext(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey) {
         var _a;
         let reader = this.useTryToConstructExternalContextReaders[requestBearerTokenHash];
         if (reader === undefined) {
@@ -2724,7 +2725,7 @@ class GreeterInstance {
             });
             this.useTryToConstructExternalContextReaders[requestBearerTokenHash] = reader;
             // Start fetching from the server.
-            this.read("TryToConstructExternalContext", serializedRequest, bearerToken, Empty, reader);
+            this.read("TryToConstructExternalContext", serializedRequest, bearerToken, warnOnFlowControl, Empty, reader);
             // Check if there is a cached result if applicable.
             if (offlineCacheEnabled) {
                 reboot_api.assert(cacheKey !== null);
@@ -2746,12 +2747,12 @@ class GreeterInstance {
         reboot_api.assert(reader !== undefined);
         return reader;
     }
-    useTryToConstructExternalContext(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
+    useTryToConstructExternalContext(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
         // We need to call start here because with strict mode the
         // `useEffect` that calls this method will also call "unuse"
         // which will mean the next time the `useEffect` calls here
         // we'll create a new reader in start.
-        const reader = this.startTryToConstructExternalContext(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        const reader = this.startTryToConstructExternalContext(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         reboot_api.assert(reader !== undefined);
         // Indicate that the reader has properly been used so that we don't
         // clean it up prematurely.
@@ -2791,7 +2792,7 @@ class GreeterInstance {
             }, 3000);
         }
     }
-    startTestLongRunningFetch(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey) {
+    startTestLongRunningFetch(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey) {
         var _a;
         let reader = this.useTestLongRunningFetchReaders[requestBearerTokenHash];
         if (reader === undefined) {
@@ -2870,7 +2871,7 @@ class GreeterInstance {
             });
             this.useTestLongRunningFetchReaders[requestBearerTokenHash] = reader;
             // Start fetching from the server.
-            this.read("TestLongRunningFetch", serializedRequest, bearerToken, Empty, reader);
+            this.read("TestLongRunningFetch", serializedRequest, bearerToken, warnOnFlowControl, Empty, reader);
             // Check if there is a cached result if applicable.
             if (offlineCacheEnabled) {
                 reboot_api.assert(cacheKey !== null);
@@ -2892,12 +2893,12 @@ class GreeterInstance {
         reboot_api.assert(reader !== undefined);
         return reader;
     }
-    useTestLongRunningFetch(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
+    useTestLongRunningFetch(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
         // We need to call start here because with strict mode the
         // `useEffect` that calls this method will also call "unuse"
         // which will mean the next time the `useEffect` calls here
         // we'll create a new reader in start.
-        const reader = this.startTestLongRunningFetch(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        const reader = this.startTestLongRunningFetch(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         reboot_api.assert(reader !== undefined);
         // Indicate that the reader has properly been used so that we don't
         // clean it up prematurely.
@@ -3035,7 +3036,7 @@ class GreeterInstance {
     unuseTestLongRunningWriter(id) {
         delete this.useTestLongRunningWriterSetPendings[id];
     }
-    startGetWholeState(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey) {
+    startGetWholeState(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey) {
         var _a;
         let reader = this.useGetWholeStateReaders[requestBearerTokenHash];
         if (reader === undefined) {
@@ -3114,7 +3115,7 @@ class GreeterInstance {
             });
             this.useGetWholeStateReaders[requestBearerTokenHash] = reader;
             // Start fetching from the server.
-            this.read("GetWholeState", serializedRequest, bearerToken, GreeterProto, reader);
+            this.read("GetWholeState", serializedRequest, bearerToken, warnOnFlowControl, GreeterProto, reader);
             // Check if there is a cached result if applicable.
             if (offlineCacheEnabled) {
                 reboot_api.assert(cacheKey !== null);
@@ -3136,12 +3137,12 @@ class GreeterInstance {
         reboot_api.assert(reader !== undefined);
         return reader;
     }
-    useGetWholeState(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
+    useGetWholeState(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
         // We need to call start here because with strict mode the
         // `useEffect` that calls this method will also call "unuse"
         // which will mean the next time the `useEffect` calls here
         // we'll create a new reader in start.
-        const reader = this.startGetWholeState(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        const reader = this.startGetWholeState(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         reboot_api.assert(reader !== undefined);
         // Indicate that the reader has properly been used so that we don't
         // clean it up prematurely.
@@ -3181,7 +3182,7 @@ class GreeterInstance {
             }, 3000);
         }
     }
-    startFailWithException(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey) {
+    startFailWithException(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey) {
         var _a;
         let reader = this.useFailWithExceptionReaders[requestBearerTokenHash];
         if (reader === undefined) {
@@ -3260,7 +3261,7 @@ class GreeterInstance {
             });
             this.useFailWithExceptionReaders[requestBearerTokenHash] = reader;
             // Start fetching from the server.
-            this.read("FailWithException", serializedRequest, bearerToken, Empty, reader);
+            this.read("FailWithException", serializedRequest, bearerToken, warnOnFlowControl, Empty, reader);
             // Check if there is a cached result if applicable.
             if (offlineCacheEnabled) {
                 reboot_api.assert(cacheKey !== null);
@@ -3282,12 +3283,12 @@ class GreeterInstance {
         reboot_api.assert(reader !== undefined);
         return reader;
     }
-    useFailWithException(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
+    useFailWithException(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
         // We need to call start here because with strict mode the
         // `useEffect` that calls this method will also call "unuse"
         // which will mean the next time the `useEffect` calls here
         // we'll create a new reader in start.
-        const reader = this.startFailWithException(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        const reader = this.startFailWithException(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         reboot_api.assert(reader !== undefined);
         // Indicate that the reader has properly been used so that we don't
         // clean it up prematurely.
@@ -3327,7 +3328,7 @@ class GreeterInstance {
             }, 3000);
         }
     }
-    startFailWithAborted(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey) {
+    startFailWithAborted(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey) {
         var _a;
         let reader = this.useFailWithAbortedReaders[requestBearerTokenHash];
         if (reader === undefined) {
@@ -3406,7 +3407,7 @@ class GreeterInstance {
             });
             this.useFailWithAbortedReaders[requestBearerTokenHash] = reader;
             // Start fetching from the server.
-            this.read("FailWithAborted", serializedRequest, bearerToken, Empty, reader);
+            this.read("FailWithAborted", serializedRequest, bearerToken, warnOnFlowControl, Empty, reader);
             // Check if there is a cached result if applicable.
             if (offlineCacheEnabled) {
                 reboot_api.assert(cacheKey !== null);
@@ -3428,12 +3429,12 @@ class GreeterInstance {
         reboot_api.assert(reader !== undefined);
         return reader;
     }
-    useFailWithAborted(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
+    useFailWithAborted(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
         // We need to call start here because with strict mode the
         // `useEffect` that calls this method will also call "unuse"
         // which will mean the next time the `useEffect` calls here
         // we'll create a new reader in start.
-        const reader = this.startFailWithAborted(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        const reader = this.startFailWithAborted(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         reboot_api.assert(reader !== undefined);
         // Indicate that the reader has properly been used so that we don't
         // clean it up prematurely.
@@ -3669,7 +3670,7 @@ class GreeterInstance {
     unuseStoreRecursiveMessage(id) {
         delete this.useStoreRecursiveMessageSetPendings[id];
     }
-    startReadRecursiveMessage(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey) {
+    startReadRecursiveMessage(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey) {
         var _a;
         let reader = this.useReadRecursiveMessageReaders[requestBearerTokenHash];
         if (reader === undefined) {
@@ -3748,7 +3749,7 @@ class GreeterInstance {
             });
             this.useReadRecursiveMessageReaders[requestBearerTokenHash] = reader;
             // Start fetching from the server.
-            this.read("ReadRecursiveMessage", serializedRequest, bearerToken, greeter_pb.ReadRecursiveMessageResponse, reader);
+            this.read("ReadRecursiveMessage", serializedRequest, bearerToken, warnOnFlowControl, greeter_pb.ReadRecursiveMessageResponse, reader);
             // Check if there is a cached result if applicable.
             if (offlineCacheEnabled) {
                 reboot_api.assert(cacheKey !== null);
@@ -3770,12 +3771,12 @@ class GreeterInstance {
         reboot_api.assert(reader !== undefined);
         return reader;
     }
-    useReadRecursiveMessage(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
+    useReadRecursiveMessage(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, setResponse, setIsLoading, setStatus) {
         // We need to call start here because with strict mode the
         // `useEffect` that calls this method will also call "unuse"
         // which will mean the next time the `useEffect` calls here
         // we'll create a new reader in start.
-        const reader = this.startReadRecursiveMessage(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        const reader = this.startReadRecursiveMessage(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         reboot_api.assert(reader !== undefined);
         // Indicate that the reader has properly been used so that we don't
         // clean it up prematurely.
@@ -4029,7 +4030,8 @@ export function useGreeter({ id: providedId } = {}) {
         return create;
     }
     const create = useCreate();
-    function useGreet(partialRequest = {}, options = { suspense: false }) {
+    function useGreet(partialRequest = {}, options = {}) {
+        var _a;
         const newRequest = GreeterGreetRequestToProtobuf(partialRequest);
         const [request, setRequest] = useState(newRequest);
         const [isLoading, setIsLoading] = useState(true);
@@ -4070,7 +4072,11 @@ export function useGreeter({ id: providedId } = {}) {
         // we need to use the `reader.response` or `reader.status` during
         // render where one of them will be defined, i.e., after we've
         // waited for `reader.promise` via `React.use()`.
-        const reader = instance.startGreet(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        // Readers are shared between every component that reads the same
+        // request, so the first of them decides whether the console warns
+        // when the read falls behind.
+        const warnOnFlowControl = (_a = options.warnOnFlowControl) !== null && _a !== void 0 ? _a : true;
+        const reader = instance.startGreet(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         const [response, setResponse] = useState(reader.response && GreeterGreetResponseFromProtobufShape(reader.response));
         const [aborted, setAborted] = useState(reader.status && GreeterGreetAborted.fromStatus(reader.status));
         // Track which state ID the current `response` and `aborted` belong
@@ -4087,7 +4093,7 @@ export function useGreeter({ id: providedId } = {}) {
         }
         useEffect(() => {
             const id = uuidv4();
-            instance.useGreet(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, (response) => {
+            instance.useGreet(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, (response) => {
                 setAborted(undefined);
                 setResponse(GreeterGreetResponseFromProtobufShape(response));
             }, setIsLoading, (status) => {
@@ -4406,7 +4412,8 @@ export function useGreeter({ id: providedId } = {}) {
         return transactionSetAdjective;
     }
     const transactionSetAdjective = useTransactionSetAdjective();
-    function useTryToConstructContext(partialRequest = {}, options = { suspense: false }) {
+    function useTryToConstructContext(partialRequest = {}, options = {}) {
+        var _a;
         const newRequest = GreeterTryToConstructContextRequestToProtobuf(partialRequest);
         const [request, setRequest] = useState(newRequest);
         const [isLoading, setIsLoading] = useState(true);
@@ -4447,7 +4454,11 @@ export function useGreeter({ id: providedId } = {}) {
         // we need to use the `reader.response` or `reader.status` during
         // render where one of them will be defined, i.e., after we've
         // waited for `reader.promise` via `React.use()`.
-        const reader = instance.startTryToConstructContext(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        // Readers are shared between every component that reads the same
+        // request, so the first of them decides whether the console warns
+        // when the read falls behind.
+        const warnOnFlowControl = (_a = options.warnOnFlowControl) !== null && _a !== void 0 ? _a : true;
+        const reader = instance.startTryToConstructContext(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         const [response, setResponse] = useState(reader.response && GreeterTryToConstructContextResponseFromProtobufShape(reader.response));
         const [aborted, setAborted] = useState(reader.status && GreeterTryToConstructContextAborted.fromStatus(reader.status));
         // Track which state ID the current `response` and `aborted` belong
@@ -4464,7 +4475,7 @@ export function useGreeter({ id: providedId } = {}) {
         }
         useEffect(() => {
             const id = uuidv4();
-            instance.useTryToConstructContext(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, (response) => {
+            instance.useTryToConstructContext(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, (response) => {
                 setAborted(undefined);
                 setResponse(GreeterTryToConstructContextResponseFromProtobufShape(response));
             }, setIsLoading, (status) => {
@@ -4693,7 +4704,8 @@ export function useGreeter({ id: providedId } = {}) {
             };
         }
     }
-    function useTryToConstructExternalContext(partialRequest = {}, options = { suspense: false }) {
+    function useTryToConstructExternalContext(partialRequest = {}, options = {}) {
+        var _a;
         const newRequest = GreeterTryToConstructExternalContextRequestToProtobuf(partialRequest);
         const [request, setRequest] = useState(newRequest);
         const [isLoading, setIsLoading] = useState(true);
@@ -4734,7 +4746,11 @@ export function useGreeter({ id: providedId } = {}) {
         // we need to use the `reader.response` or `reader.status` during
         // render where one of them will be defined, i.e., after we've
         // waited for `reader.promise` via `React.use()`.
-        const reader = instance.startTryToConstructExternalContext(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        // Readers are shared between every component that reads the same
+        // request, so the first of them decides whether the console warns
+        // when the read falls behind.
+        const warnOnFlowControl = (_a = options.warnOnFlowControl) !== null && _a !== void 0 ? _a : true;
+        const reader = instance.startTryToConstructExternalContext(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         const [response, setResponse] = useState(reader.response && GreeterTryToConstructExternalContextResponseFromProtobufShape(reader.response));
         const [aborted, setAborted] = useState(reader.status && GreeterTryToConstructExternalContextAborted.fromStatus(reader.status));
         // Track which state ID the current `response` and `aborted` belong
@@ -4751,7 +4767,7 @@ export function useGreeter({ id: providedId } = {}) {
         }
         useEffect(() => {
             const id = uuidv4();
-            instance.useTryToConstructExternalContext(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, (response) => {
+            instance.useTryToConstructExternalContext(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, (response) => {
                 setAborted(undefined);
                 setResponse(GreeterTryToConstructExternalContextResponseFromProtobufShape(response));
             }, setIsLoading, (status) => {
@@ -4980,7 +4996,8 @@ export function useGreeter({ id: providedId } = {}) {
             };
         }
     }
-    function useTestLongRunningFetch(partialRequest = {}, options = { suspense: false }) {
+    function useTestLongRunningFetch(partialRequest = {}, options = {}) {
+        var _a;
         const newRequest = GreeterTestLongRunningFetchRequestToProtobuf(partialRequest);
         const [request, setRequest] = useState(newRequest);
         const [isLoading, setIsLoading] = useState(true);
@@ -5021,7 +5038,11 @@ export function useGreeter({ id: providedId } = {}) {
         // we need to use the `reader.response` or `reader.status` during
         // render where one of them will be defined, i.e., after we've
         // waited for `reader.promise` via `React.use()`.
-        const reader = instance.startTestLongRunningFetch(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        // Readers are shared between every component that reads the same
+        // request, so the first of them decides whether the console warns
+        // when the read falls behind.
+        const warnOnFlowControl = (_a = options.warnOnFlowControl) !== null && _a !== void 0 ? _a : true;
+        const reader = instance.startTestLongRunningFetch(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         const [response, setResponse] = useState(reader.response && GreeterTestLongRunningFetchResponseFromProtobufShape(reader.response));
         const [aborted, setAborted] = useState(reader.status && GreeterTestLongRunningFetchAborted.fromStatus(reader.status));
         // Track which state ID the current `response` and `aborted` belong
@@ -5038,7 +5059,7 @@ export function useGreeter({ id: providedId } = {}) {
         }
         useEffect(() => {
             const id = uuidv4();
-            instance.useTestLongRunningFetch(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, (response) => {
+            instance.useTestLongRunningFetch(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, (response) => {
                 setAborted(undefined);
                 setResponse(GreeterTestLongRunningFetchResponseFromProtobufShape(response));
             }, setIsLoading, (status) => {
@@ -5312,7 +5333,8 @@ export function useGreeter({ id: providedId } = {}) {
         return testLongRunningWriter;
     }
     const testLongRunningWriter = useTestLongRunningWriter();
-    function useGetWholeState(partialRequest = {}, options = { suspense: false }) {
+    function useGetWholeState(partialRequest = {}, options = {}) {
+        var _a;
         const newRequest = GreeterGetWholeStateRequestToProtobuf(partialRequest);
         const [request, setRequest] = useState(newRequest);
         const [isLoading, setIsLoading] = useState(true);
@@ -5353,7 +5375,11 @@ export function useGreeter({ id: providedId } = {}) {
         // we need to use the `reader.response` or `reader.status` during
         // render where one of them will be defined, i.e., after we've
         // waited for `reader.promise` via `React.use()`.
-        const reader = instance.startGetWholeState(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        // Readers are shared between every component that reads the same
+        // request, so the first of them decides whether the console warns
+        // when the read falls behind.
+        const warnOnFlowControl = (_a = options.warnOnFlowControl) !== null && _a !== void 0 ? _a : true;
+        const reader = instance.startGetWholeState(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         const [response, setResponse] = useState(reader.response && GreeterGetWholeStateResponseFromProtobufShape(reader.response));
         const [aborted, setAborted] = useState(reader.status && GreeterGetWholeStateAborted.fromStatus(reader.status));
         // Track which state ID the current `response` and `aborted` belong
@@ -5370,7 +5396,7 @@ export function useGreeter({ id: providedId } = {}) {
         }
         useEffect(() => {
             const id = uuidv4();
-            instance.useGetWholeState(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, (response) => {
+            instance.useGetWholeState(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, (response) => {
                 setAborted(undefined);
                 setResponse(GreeterGetWholeStateResponseFromProtobufShape(response));
             }, setIsLoading, (status) => {
@@ -5599,7 +5625,8 @@ export function useGreeter({ id: providedId } = {}) {
             };
         }
     }
-    function useFailWithException(partialRequest = {}, options = { suspense: false }) {
+    function useFailWithException(partialRequest = {}, options = {}) {
+        var _a;
         const newRequest = GreeterFailWithExceptionRequestToProtobuf(partialRequest);
         const [request, setRequest] = useState(newRequest);
         const [isLoading, setIsLoading] = useState(true);
@@ -5640,7 +5667,11 @@ export function useGreeter({ id: providedId } = {}) {
         // we need to use the `reader.response` or `reader.status` during
         // render where one of them will be defined, i.e., after we've
         // waited for `reader.promise` via `React.use()`.
-        const reader = instance.startFailWithException(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        // Readers are shared between every component that reads the same
+        // request, so the first of them decides whether the console warns
+        // when the read falls behind.
+        const warnOnFlowControl = (_a = options.warnOnFlowControl) !== null && _a !== void 0 ? _a : true;
+        const reader = instance.startFailWithException(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         const [response, setResponse] = useState(reader.response && GreeterFailWithExceptionResponseFromProtobufShape(reader.response));
         const [aborted, setAborted] = useState(reader.status && GreeterFailWithExceptionAborted.fromStatus(reader.status));
         // Track which state ID the current `response` and `aborted` belong
@@ -5657,7 +5688,7 @@ export function useGreeter({ id: providedId } = {}) {
         }
         useEffect(() => {
             const id = uuidv4();
-            instance.useFailWithException(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, (response) => {
+            instance.useFailWithException(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, (response) => {
                 setAborted(undefined);
                 setResponse(GreeterFailWithExceptionResponseFromProtobufShape(response));
             }, setIsLoading, (status) => {
@@ -5886,7 +5917,8 @@ export function useGreeter({ id: providedId } = {}) {
             };
         }
     }
-    function useFailWithAborted(partialRequest = {}, options = { suspense: false }) {
+    function useFailWithAborted(partialRequest = {}, options = {}) {
+        var _a;
         const newRequest = GreeterFailWithAbortedRequestToProtobuf(partialRequest);
         const [request, setRequest] = useState(newRequest);
         const [isLoading, setIsLoading] = useState(true);
@@ -5927,7 +5959,11 @@ export function useGreeter({ id: providedId } = {}) {
         // we need to use the `reader.response` or `reader.status` during
         // render where one of them will be defined, i.e., after we've
         // waited for `reader.promise` via `React.use()`.
-        const reader = instance.startFailWithAborted(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        // Readers are shared between every component that reads the same
+        // request, so the first of them decides whether the console warns
+        // when the read falls behind.
+        const warnOnFlowControl = (_a = options.warnOnFlowControl) !== null && _a !== void 0 ? _a : true;
+        const reader = instance.startFailWithAborted(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         const [response, setResponse] = useState(reader.response && GreeterFailWithAbortedResponseFromProtobufShape(reader.response));
         const [aborted, setAborted] = useState(reader.status && GreeterFailWithAbortedAborted.fromStatus(reader.status));
         // Track which state ID the current `response` and `aborted` belong
@@ -5944,7 +5980,7 @@ export function useGreeter({ id: providedId } = {}) {
         }
         useEffect(() => {
             const id = uuidv4();
-            instance.useFailWithAborted(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, (response) => {
+            instance.useFailWithAborted(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, (response) => {
                 setAborted(undefined);
                 setResponse(GreeterFailWithAbortedResponseFromProtobufShape(response));
             }, setIsLoading, (status) => {
@@ -6263,7 +6299,8 @@ export function useGreeter({ id: providedId } = {}) {
         return storeRecursiveMessage;
     }
     const storeRecursiveMessage = useStoreRecursiveMessage();
-    function useReadRecursiveMessage(partialRequest = {}, options = { suspense: false }) {
+    function useReadRecursiveMessage(partialRequest = {}, options = {}) {
+        var _a;
         const newRequest = GreeterReadRecursiveMessageRequestToProtobuf(partialRequest);
         const [request, setRequest] = useState(newRequest);
         const [isLoading, setIsLoading] = useState(true);
@@ -6304,7 +6341,11 @@ export function useGreeter({ id: providedId } = {}) {
         // we need to use the `reader.response` or `reader.status` during
         // render where one of them will be defined, i.e., after we've
         // waited for `reader.promise` via `React.use()`.
-        const reader = instance.startReadRecursiveMessage(requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey);
+        // Readers are shared between every component that reads the same
+        // request, so the first of them decides whether the console warns
+        // when the read falls behind.
+        const warnOnFlowControl = (_a = options.warnOnFlowControl) !== null && _a !== void 0 ? _a : true;
+        const reader = instance.startReadRecursiveMessage(requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey);
         const [response, setResponse] = useState(reader.response && GreeterReadRecursiveMessageResponseFromProtobufShape(reader.response));
         const [aborted, setAborted] = useState(reader.status && GreeterReadRecursiveMessageAborted.fromStatus(reader.status));
         // Track which state ID the current `response` and `aborted` belong
@@ -6321,7 +6362,7 @@ export function useGreeter({ id: providedId } = {}) {
         }
         useEffect(() => {
             const id = uuidv4();
-            instance.useReadRecursiveMessage(id, requestBearerTokenHash, serializedRequest, bearerToken, offlineCacheEnabled, cacheKey, (response) => {
+            instance.useReadRecursiveMessage(id, requestBearerTokenHash, serializedRequest, bearerToken, warnOnFlowControl, offlineCacheEnabled, cacheKey, (response) => {
                 setAborted(undefined);
                 setResponse(GreeterReadRecursiveMessageResponseFromProtobufShape(response));
             }, setIsLoading, (status) => {
diff --git a/tests/reboot/greeter_rbt_web.golden.js b/tests/reboot/greeter_rbt_web.golden.js
index 554dc3755..9d99fa6ab 100755
--- a/tests/reboot/greeter_rbt_web.golden.js
+++ b/tests/reboot/greeter_rbt_web.golden.js
@@ -1668,6 +1668,7 @@ class _Reactively {
             signal: options === null || options === void 0 ? void 0 : options.signal,
             bearerToken: context.bearerToken,
             websockets: context.websockets,
+            warnOnFlowControl: options === null || options === void 0 ? void 0 : options.warnOnFlowControl,
         });
         const setTypedRequest = (newRequest) => {
             const typedRequest = GreeterGreetRequestToProtobuf(newRequest);
@@ -1695,6 +1696,7 @@ class _Reactively {
             signal: options === null || options === void 0 ? void 0 : options.signal,
             bearerToken: context.bearerToken,
             websockets: context.websockets,
+            warnOnFlowControl: options === null || options === void 0 ? void 0 : options.warnOnFlowControl,
         });
         const setTypedRequest = (newRequest) => {
             const typedRequest = GreeterTryToConstructContextRequestToProtobuf(newRequest);
@@ -1722,6 +1724,7 @@ class _Reactively {
             signal: options === null || options === void 0 ? void 0 : options.signal,
             bearerToken: context.bearerToken,
             websockets: context.websockets,
+            warnOnFlowControl: options === null || options === void 0 ? void 0 : options.warnOnFlowControl,
         });
         const setTypedRequest = (newRequest) => {
             const typedRequest = GreeterTryToConstructExternalContextRequestToProtobuf(newRequest);
@@ -1749,6 +1752,7 @@ class _Reactively {
             signal: options === null || options === void 0 ? void 0 : options.signal,
             bearerToken: context.bearerToken,
             websockets: context.websockets,
+            warnOnFlowControl: options === null || options === void 0 ? void 0 : options.warnOnFlowControl,
         });
         const setTypedRequest = (newRequest) => {
             const typedRequest = GreeterTestLongRunningFetchRequestToProtobuf(newRequest);
@@ -1776,6 +1780,7 @@ class _Reactively {
             signal: options === null || options === void 0 ? void 0 : options.signal,
             bearerToken: context.bearerToken,
             websockets: context.websockets,
+            warnOnFlowControl: options === null || options === void 0 ? void 0 : options.warnOnFlowControl,
         });
         const setTypedRequest = (newRequest) => {
             const typedRequest = GreeterGetWholeStateRequestToProtobuf(newRequest);
@@ -1803,6 +1808,7 @@ class _Reactively {
             signal: options === null || options === void 0 ? void 0 : options.signal,
             bearerToken: context.bearerToken,
             websockets: context.websockets,
+            warnOnFlowControl: options === null || options === void 0 ? void 0 : options.warnOnFlowControl,
         });
         const setTypedRequest = (newRequest) => {
             const typedRequest = GreeterFailWithExceptionRequestToProtobuf(newRequest);
@@ -1830,6 +1836,7 @@ class _Reactively {
             signal: options === null || options === void 0 ? void 0 : options.signal,
             bearerToken: context.bearerToken,
             websockets: context.websockets,
+            warnOnFlowControl: options === null || options === void 0 ? void 0 : options.warnOnFlowControl,
         });
         const setTypedRequest = (newRequest) => {
             const typedRequest = GreeterFailWithAbortedRequestToProtobuf(newRequest);
@@ -1857,6 +1864,7 @@ class _Reactively {
             signal: options === null || options === void 0 ? void 0 : options.signal,
             bearerToken: context.bearerToken,
             websockets: context.websockets,
+            warnOnFlowControl: options === null || options === void 0 ? void 0 : options.warnOnFlowControl,
         });
         const setTypedRequest = (newRequest) => {
             const typedRequest = GreeterReadRecursiveMessageRequestToProtobuf(newRequest);
diff --git a/tests/reboot/react/test_reactive_reader_flow_control/test.py b/tests/reboot/react/test_reactive_reader_flow_control/test.py
index b7542df0d..2532fd539 100644
--- a/tests/reboot/react/test_reactive_reader_flow_control/test.py
+++ b/tests/reboot/react/test_reactive_reader_flow_control/test.py
@@ -117,8 +117,8 @@ def wait_for_latest_message(
         assert len(rendered) <= QUERY_RESPONSE_WINDOW + 1, rendered
         assert rendered[0] == message('tasty'), rendered
 
-        # The browser tells its developer that it fell behind, since
-        # it did so for long enough that a user would have seen it.
+        # The browser warns its developer that it fell behind and
+        # updates were skipped for it.
         console = await asyncio.to_thread(driver.get_log, 'browser')
 
         stalls = [
diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py
index b76642dfe..ada541100 100644
--- a/tests/reboot/reactivity_test.py
+++ b/tests/reboot/reactivity_test.py
@@ -6,10 +6,7 @@
 from reboot.aio.applications import Application
 from reboot.aio.contexts import ReaderContext
 from reboot.aio.external import ExternalContext
-from reboot.aio.react import (
-    QUERY_RESPONSE_WINDOW,
-    REPORTABLE_STALL_MILLISECONDS,
-)
+from reboot.aio.react import QUERY_RESPONSE_WINDOW
 from reboot.aio.tests import Reboot
 from tests.reboot import greeter_rbt
 from tests.reboot.greeter_rbt import Greeter
@@ -46,6 +43,34 @@ def __new__(cls, **kwargs: Any) -> react_pb2.QueryRequest:
         return QUERY_REQUEST(**kwargs)
 
 
+class QueryRequestSuppressingFlowControlWarnings:
+    """Constructs a `QueryRequest` the way a client that passed
+    `warnOnFlowControl: false` does, i.e. with
+    `suppress_flow_control_warning` set.
+
+    Keeps `SerializeToString` and `FromString` reachable for the same
+    reason `QueryRequestWithoutContinuations` does.
+    """
+
+    SerializeToString = QUERY_REQUEST.SerializeToString
+    FromString = QUERY_REQUEST.FromString
+
+    def __new__(cls, **kwargs: Any) -> react_pb2.QueryRequest:
+        return QUERY_REQUEST(suppress_flow_control_warning=True, **kwargs)
+
+
+@contextlib.contextmanager
+def query_requests_suppressing_flow_control_warnings() -> Iterator[None]:
+    """Makes every reactive reader send a `QueryRequest` the way a
+    client that asked not to be warned about skipped updates does."""
+    with patch.object(
+        react_pb2,
+        'QueryRequest',
+        QueryRequestSuppressingFlowControlWarnings,
+    ):
+        yield
+
+
 @contextlib.contextmanager
 def query_requests_without_continuations() -> Iterator[list[str]]:
     """Makes every reactive reader send a `QueryRequest` the way a
@@ -158,6 +183,24 @@ async def accumulate_until_adjective(self, adjective: str) -> list[str]:
 
         return self._accumulated_adjectives
 
+    async def make_the_client_fall_behind(
+        self, greeter: Greeter.WeakReference, context: ExternalContext
+    ) -> None:
+        """Makes more changes than the window has room for while the
+        reactive reader started by `start_accumulating_adjectives()`
+        is still holding its first response, so that the backend ends
+        up holding one it cannot send, then lets the reader catch up,
+        which is when the backend skips the updates it merged."""
+        adjectives = [
+            f"adjective-{index}" for index in range(2 * QUERY_RESPONSE_WINDOW)
+        ]
+
+        for adjective in adjectives:
+            await greeter.SetAdjective(context, adjective=adjective)
+
+        self._can_accumulate_next_adjective.set()
+        await self.accumulate_until_adjective(adjectives[-1])
+
     async def test_reactive_get_all_state(self) -> None:
         """
         Regression test for https://github.com/reboot-dev/mono/issues/3135
@@ -241,11 +284,10 @@ async def test_skip_to_latest(self) -> None:
             accumulated,
         )
 
-    async def test_reports_a_stalled_client(self) -> None:
+    async def test_warns_about_a_client_that_fell_behind(self) -> None:
         """
-        Tests that a backend holding a response for a client too slow
-        to take it says so, once it has held it for long enough that
-        the client's user could see the delay.
+        Tests that a backend which skipped updates for a client too
+        slow to take them warns that it did.
         """
         await self.rbt.up(Application(servicers=[MyGreeterServicer]))
         context = self.rbt.create_external_context(name=f"test-{self.id()}")
@@ -264,24 +306,9 @@ async def test_reports_a_stalled_client(self) -> None:
 
         with self.assertLogs(
             'respect.reboot.aio.react',
-            level='INFO',
+            level='WARNING',
         ) as logs:
-            # More changes than the window has room for, so that the
-            # backend ends up holding one it cannot send.
-            adjectives = [
-                f"adjective-{index}"
-                for index in range(2 * QUERY_RESPONSE_WINDOW)
-            ]
-
-            for adjective in adjectives:
-                await greeter.SetAdjective(context, adjective=adjective)
-
-            # Hold it there for longer than a user would fail to
-            # notice.
-            await asyncio.sleep(2 * REPORTABLE_STALL_MILLISECONDS / 1000)
-
-            self._can_accumulate_next_adjective.set()
-            await self.accumulate_until_adjective(adjectives[-1])
+            await self.make_the_client_fall_behind(greeter, context)
 
         reported = "A client of a reactive query to `GetWholeState` skipped "
 
@@ -293,6 +320,31 @@ async def test_reports_a_stalled_client(self) -> None:
             logs.output,
         )
 
+    async def test_client_that_asked_not_to_be_warned(self) -> None:
+        """
+        Tests that a backend which skipped updates for a client that
+        asked not to be warned about that stays quiet.
+        """
+        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_suppressing_flow_control_warnings():
+            await self.start_accumulating_adjectives(greeter, context)
+            self.assertEqual(["reactive"], await self.get_adjectives(1))
+
+            with self.assertNoLogs(
+                'respect.reboot.aio.react',
+                level='WARNING',
+            ):
+                await self.make_the_client_fall_behind(greeter, context)
+
     async def test_transitive_skip_to_latest(self) -> None:
         """
         Tests that a reactive reader that reads through another reactive

From 832c9f55192ef1549b84837be05b7beeeba06701 Mon Sep 17 00:00:00 2001
From: Robert-Jan Huijsman <22160949+rjhuijsman@users.noreply.github.com>
Date: Mon, 14 Sep 2026 10:42:07 +0000
Subject: [PATCH 13/13] React: decide the server-side flow control warning per
 method

Before this change, a client that had asked not to be warned about
skipped updates silenced the server's warning too, over a
`QueryRequest` field. Whether skipping is the point of a reactive
read is a property of the method being read, not of whichever client
happens to read it, so the server now decides from the method's own
options; the client's `warnOnFlowControl` only ever concerned the
console, which is where it stays.

- `ReaderMethodOptions` gains `warn_on_flow_control`; unset means
  warn. `Middleware.warns_on_flow_control()` reads it off the
  method's descriptor, and `React.Query` warns only when it says so.
- `QueryRequest.suppress_flow_control_warning` is gone;
  `reactiveReader()` takes `warnOnFlowControl` directly instead of
  reading it off the request.
- `Greet` in the test `Greeter` opts out, and the reactivity test
  reads through it to show that the server then stays quiet.
- Goldens regenerated.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HfMTSCHtzXaNnhCvzQVcQd
---
 rbt/v1alpha1/options.proto               |  7 ++
 rbt/v1alpha1/react.proto                 |  7 --
 reboot/aio/internals/middleware.py       | 29 ++++++++
 reboot/aio/react.py                      | 17 +++--
 reboot/templates/reboot_react.ts.j2      |  2 +-
 reboot/web/index.ts                      | 21 +++---
 tests/reboot/greeter.proto               |  3 +
 tests/reboot/greeter_rbt.golden.js       |  2 +-
 tests/reboot/greeter_rbt_react.golden.js |  2 +-
 tests/reboot/reactivity_test.py          | 88 +++++++++++-------------
 10 files changed, 104 insertions(+), 74 deletions(-)

diff --git a/rbt/v1alpha1/options.proto b/rbt/v1alpha1/options.proto
index 592b580d5..82f1fe423 100644
--- a/rbt/v1alpha1/options.proto
+++ b/rbt/v1alpha1/options.proto
@@ -17,6 +17,13 @@ message ReaderMethodOptions {
     STREAMING = 2;
   }
   State state = 3;
+
+  // Whether the server warns, in its log, every time a client of a
+  // reactive read of this method falls behind and has updates skipped
+  // for it. Unset means yes. A method whose readers only ever want
+  // its latest state, so that skipping the states in between is the
+  // point, sets this to `false`.
+  optional bool warn_on_flow_control = 4;
 }
 
 message WriterMethodOptions {
diff --git a/rbt/v1alpha1/react.proto b/rbt/v1alpha1/react.proto
index 4baf6ac40..41621fb0f 100644
--- a/rbt/v1alpha1/react.proto
+++ b/rbt/v1alpha1/react.proto
@@ -37,13 +37,6 @@ message QueryRequest {
   // `QueryRequest`, which is why presence matters here: sequence
   // number zero is a real response.
   optional uint64 continue_query_sequence_number = 5;
-
-  // Whether this client has asked not to be warned when it falls
-  // behind and updates are skipped on its behalf. By default both the
-  // client and the server log a warning every time that happens, so
-  // that a client that expected to see every update learns that it
-  // did not; a client for which skipping is the point sets this.
-  bool suppress_flow_control_warning = 6;
 }
 
 message QueryResponse {
diff --git a/reboot/aio/internals/middleware.py b/reboot/aio/internals/middleware.py
index d330a71de..95059a7df 100644
--- a/reboot/aio/internals/middleware.py
+++ b/reboot/aio/internals/middleware.py
@@ -6,6 +6,7 @@
 import uuid
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
+from google.protobuf import descriptor_pool
 from google.protobuf.message import Message
 from logging import Logger
 from reboot.aio.auth.authorizers import Authorizer
@@ -37,6 +38,7 @@
     StateRef,
     StateTypeName,
 )
+from reboot.options import get_method_options
 from reboot.settings import DOCS_BASE_URL
 from reboot.time import DateTimeWithTimeZone
 from typing import (
@@ -135,6 +137,33 @@ def state_type_name(self) -> StateTypeName:
     def service_names(self) -> list[ServiceName]:
         return self._service_names
 
+    def warns_on_flow_control(self, method: str) -> bool:
+        """Whether the server warns every time a client of a reactive
+        read of `method` falls behind and has updates skipped for it,
+        which is what the method's `warn_on_flow_control` reader
+        option decides; a method that has not set it warns."""
+        pool = descriptor_pool.Default()
+
+        for service_name in self._service_names:
+            try:
+                service = pool.FindServiceByName(service_name)
+            except KeyError:
+                continue
+
+            descriptor = service.methods_by_name.get(method)
+
+            if descriptor is None:
+                continue
+
+            reader = get_method_options(descriptor).reader
+
+            if reader.HasField('warn_on_flow_control'):
+                return reader.warn_on_flow_control
+
+            return True
+
+        return True
+
     def create_context(
         self,
         *,
diff --git a/reboot/aio/react.py b/reboot/aio/react.py
index be60939dc..12dac4264 100644
--- a/reboot/aio/react.py
+++ b/reboot/aio/react.py
@@ -583,6 +583,8 @@ async def _windowed_query(
                 yield response
             return
 
+        warn_on_flow_control = middleware.warns_on_flow_control(request.method)
+
         # We'll run two loops concurrently:
         # 1. Consume responses from the stream, and merge them into a single
         #    "next response".
@@ -677,21 +679,18 @@ async def accumulate_next_response() -> None:
 
                 # Warn every time updates are skipped, until we have
                 # enough experience with flow control to know which
-                # skips a developer needs to hear about; a client for
-                # which skipping is the point asks us not to.
-                if (
-                    skipped_updates > 0 and
-                    not request.suppress_flow_control_warning
-                ):
+                # skips a developer needs to hear about; a method for
+                # which skipping is the point has opted out.
+                if skipped_updates > 0 and warn_on_flow_control:
                     logger.warning(
                         f"A client of a reactive query to `{request.method}` "
                         f"skipped {skipped_updates} updates because it fell "
                         f"{stall_milliseconds}ms behind. If skipping updates "
                         "is not what you expect of this reactive read, make "
                         "that client fast enough to process every response; "
-                        "if it is, pass `{ warnOnFlowControl: false }` in "
-                        "the options of the client's reader to silence this "
-                        "warning."
+                        "if it is, set `warn_on_flow_control: false` in the "
+                        f"`reader` options of `{request.method}` to silence "
+                        "this warning."
                     )
 
                 # Send the response we'd accumulated.
diff --git a/reboot/templates/reboot_react.ts.j2 b/reboot/templates/reboot_react.ts.j2
index de046a85e..27566aa62 100644
--- a/reboot/templates/reboot_react.ts.j2
+++ b/reboot/templates/reboot_react.ts.j2
@@ -777,7 +777,6 @@ class {{ client.proto.state_name | to_camel }}Instance {
       method,
       request: serializedRequest,
       clientContinuesQuery: true,
-      suppressFlowControlWarning: !warnOnFlowControl,
       ...(bearerToken !== undefined && { bearerToken } || {}),
     });
 
@@ -862,6 +861,7 @@ class {{ client.proto.state_name | to_camel }}Instance {
             endpoint: `${this.url}/__/reboot/rpc/${this.stateRef}`,
             request: queryRequest,
             signal: reader.abortController.signal,
+            warnOnFlowControl,
           });
 
           for await (const queryResponse of queryResponses) {
diff --git a/reboot/web/index.ts b/reboot/web/index.ts
index 01614c39b..b92e60383 100644
--- a/reboot/web/index.ts
+++ b/reboot/web/index.ts
@@ -386,7 +386,6 @@ export function reactively<
           method,
           request: request.toBinary(),
           clientContinuesQuery: true,
-          suppressFlowControlWarning: !warnOnFlowControl,
           ...((bearerToken !== undefined && {
             bearerToken: await bearerToken(),
           }) ||
@@ -400,6 +399,7 @@ export function reactively<
           request: queryRequest,
           signal: responsesAbortController.signal,
           websockets,
+          warnOnFlowControl,
         });
 
         for await (const queryResponse of queryResponses) {
@@ -429,15 +429,16 @@ export function reactively<
 // render is still the latest one; what was lost is the updates on the
 // way there. Warns every time that happens, until we have enough
 // experience with flow control to know which skips a developer needs
-// to hear about; a reader for which skipping is the point asks us not
-// to, in the `request`.
+// to hear about; a reader for which skipping is the point is created
+// with `warnOnFlowControl: false`.
 function logStall(
-  request: react_pb.QueryRequest,
+  method: string,
+  warnOnFlowControl: boolean,
   response: react_pb.QueryResponse
 ) {
-  if (response.skippedUpdates > 0 && !request.suppressFlowControlWarning) {
+  if (warnOnFlowControl && response.skippedUpdates > 0) {
     console.warn(
-      `[Reboot] A reactive query to \`${request.method}\` skipped ` +
+      `[Reboot] A reactive query to \`${method}\` skipped ` +
         `${response.skippedUpdates} updates because this client fell ` +
         `${response.stallMilliseconds}ms behind. If skipping updates is ` +
         `not what you expect of this reactive read, make this client ` +
@@ -512,11 +513,15 @@ export async function* reactiveReader({
   request,
   signal,
   websockets = false,
+  warnOnFlowControl = true,
 }: {
   endpoint: string;
   request: react_pb.QueryRequest;
   signal: AbortSignal;
   websockets: boolean;
+  // Whether to warn in the console when this reader falls behind and
+  // the backend skips updates for it; see `logStall`.
+  warnOnFlowControl?: boolean;
 }): AsyncGenerator<react_pb.QueryResponse, void, unknown> {
   const url = new URL(`${endpoint}/rbt.v1alpha1.React/Query`);
 
@@ -545,7 +550,7 @@ export async function* reactiveReader({
     let settled = true;
 
     for await (const response of responses) {
-      logStall(request, response);
+      logStall(request.method, warnOnFlowControl, response);
 
       yield response;
 
@@ -617,7 +622,7 @@ export async function* reactiveReader({
         throw Status.fromJsonString(response.responseOrStatus.value);
       }
 
-      logStall(request, response);
+      logStall(request.method, warnOnFlowControl, response);
 
       yield response;
     }
diff --git a/tests/reboot/greeter.proto b/tests/reboot/greeter.proto
index bc9968892..84833c1f3 100644
--- a/tests/reboot/greeter.proto
+++ b/tests/reboot/greeter.proto
@@ -113,8 +113,11 @@ service GreeterMethods {
     };
   }
 
+  // Reading this reactively never warns about skipped updates, so
+  // that tests can read through a method that opted out of that.
   rpc Greet(GreetRequest) returns (GreetResponse) {
     option (rbt.v1alpha1.method).reader = {
+      warn_on_flow_control: false,
     };
   }
 
diff --git a/tests/reboot/greeter_rbt.golden.js b/tests/reboot/greeter_rbt.golden.js
index 06bedcb50..cdec13c55 100755
--- a/tests/reboot/greeter_rbt.golden.js
+++ b/tests/reboot/greeter_rbt.golden.js
@@ -5507,7 +5507,7 @@ Greeter._ConstructIdempotently = (_j = class {
     _idempotency_1 = new WeakMap(),
     _j);
 export function importPys() {
-    reboot_native.importPy("tests.reboot.greeter_pb2", "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");
+    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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");
 }
diff --git a/tests/reboot/greeter_rbt_react.golden.js b/tests/reboot/greeter_rbt_react.golden.js
index 03694fa45..324349e04 100755
--- a/tests/reboot/greeter_rbt_react.golden.js
+++ b/tests/reboot/greeter_rbt_react.golden.js
@@ -1883,7 +1883,6 @@ class GreeterInstance {
             method,
             request: serializedRequest,
             clientContinuesQuery: true,
-            suppressFlowControlWarning: !warnOnFlowControl,
             ...(bearerToken !== undefined && { bearerToken } || {}),
         });
         let expecteds = [];
@@ -1938,6 +1937,7 @@ class GreeterInstance {
                         endpoint: `${this.url}/__/reboot/rpc/${this.stateRef}`,
                         request: queryRequest,
                         signal: reader.abortController.signal,
+                        warnOnFlowControl,
                     });
                     for await (const queryResponse of queryResponses) {
                         if (!loaded) {
diff --git a/tests/reboot/reactivity_test.py b/tests/reboot/reactivity_test.py
index ada541100..9cbd20f31 100644
--- a/tests/reboot/reactivity_test.py
+++ b/tests/reboot/reactivity_test.py
@@ -11,7 +11,7 @@
 from tests.reboot import greeter_rbt
 from tests.reboot.greeter_rbt import Greeter
 from tests.reboot.greeter_servicers import MyGreeterServicer
-from typing import Any, Iterator, Optional
+from typing import Any, AsyncIterator, Iterator, Optional
 from unittest.mock import patch
 
 # `title` that marks a `Greeter` as one whose `Greet` reads another
@@ -43,34 +43,6 @@ def __new__(cls, **kwargs: Any) -> react_pb2.QueryRequest:
         return QUERY_REQUEST(**kwargs)
 
 
-class QueryRequestSuppressingFlowControlWarnings:
-    """Constructs a `QueryRequest` the way a client that passed
-    `warnOnFlowControl: false` does, i.e. with
-    `suppress_flow_control_warning` set.
-
-    Keeps `SerializeToString` and `FromString` reachable for the same
-    reason `QueryRequestWithoutContinuations` does.
-    """
-
-    SerializeToString = QUERY_REQUEST.SerializeToString
-    FromString = QUERY_REQUEST.FromString
-
-    def __new__(cls, **kwargs: Any) -> react_pb2.QueryRequest:
-        return QUERY_REQUEST(suppress_flow_control_warning=True, **kwargs)
-
-
-@contextlib.contextmanager
-def query_requests_suppressing_flow_control_warnings() -> Iterator[None]:
-    """Makes every reactive reader send a `QueryRequest` the way a
-    client that asked not to be warned about skipped updates does."""
-    with patch.object(
-        react_pb2,
-        'QueryRequest',
-        QueryRequestSuppressingFlowControlWarnings,
-    ):
-        yield
-
-
 @contextlib.contextmanager
 def query_requests_without_continuations() -> Iterator[list[str]]:
     """Makes every reactive reader send a `QueryRequest` the way a
@@ -147,13 +119,32 @@ async def asyncTearDown(self) -> None:
         await self.rbt.stop()
 
     async def start_accumulating_adjectives(
-        self, greeter: Greeter.WeakReference, context: ExternalContext
-    ):
-
-        async def _do():
-            async for greeter_state in greeter.reactively(
-            ).GetWholeState(context):
-                self._accumulated_adjectives.append(greeter_state.adjective)
+        self,
+        greeter: Greeter.WeakReference,
+        context: ExternalContext,
+        *,
+        through: str = 'GetWholeState',
+    ) -> None:
+        """Reads `greeter` reactively through `through`, which is
+        `GetWholeState` or `Greet`, accumulating the adjective that
+        each response carries."""
+
+        async def adjectives() -> AsyncIterator[str]:
+            if through == 'GetWholeState':
+                async for greeter_state in greeter.reactively(
+                ).GetWholeState(context):
+                    yield greeter_state.adjective
+            else:
+                assert through == 'Greet'
+                async for greeting in greeter.reactively().Greet(
+                    context, name='Jonathan'
+                ):
+                    # A greeting ends in "the <adjective>".
+                    yield greeting.message.rsplit(' the ', 1)[-1]
+
+        async def _do() -> None:
+            async for adjective in adjectives():
+                self._accumulated_adjectives.append(adjective)
                 self._accumulated_adjective.set()
                 # Hold up the reactive reader until the test says we
                 # may consume a next response.
@@ -320,10 +311,11 @@ async def test_warns_about_a_client_that_fell_behind(self) -> None:
             logs.output,
         )
 
-    async def test_client_that_asked_not_to_be_warned(self) -> None:
+    async def test_method_that_opted_out_of_warning(self) -> None:
         """
-        Tests that a backend which skipped updates for a client that
-        asked not to be warned about that stays quiet.
+        Tests that a backend which skipped updates for a client of a
+        method whose `warn_on_flow_control` option is `false` stays
+        quiet about it.
         """
         await self.rbt.up(Application(servicers=[MyGreeterServicer]))
         context = self.rbt.create_external_context(name=f"test-{self.id()}")
@@ -335,15 +327,17 @@ async def test_client_that_asked_not_to_be_warned(self) -> None:
             adjective="reactive",
         )
 
-        with query_requests_suppressing_flow_control_warnings():
-            await self.start_accumulating_adjectives(greeter, context)
-            self.assertEqual(["reactive"], await self.get_adjectives(1))
+        # `Greet` is the reader that opted out; see `greeter.proto`.
+        await self.start_accumulating_adjectives(
+            greeter, context, through='Greet'
+        )
+        self.assertEqual(["reactive"], await self.get_adjectives(1))
 
-            with self.assertNoLogs(
-                'respect.reboot.aio.react',
-                level='WARNING',
-            ):
-                await self.make_the_client_fall_behind(greeter, context)
+        with self.assertNoLogs(
+            'respect.reboot.aio.react',
+            level='WARNING',
+        ):
+            await self.make_the_client_fall_behind(greeter, context)
 
     async def test_transitive_skip_to_latest(self) -> None:
         """