From f20f2fe9281e59e9749a58ab49e9be10caa11f72 Mon Sep 17 00:00:00 2001
From: Marcelo Trylesinski <marcelotryle@gmail.com>
Date: Thu, 12 Jun 2025 14:01:27 +0200
Subject: [PATCH 1/6] Add MCP Streamable HTTP implementation

---
 docs/mcp/client.md                  |  63 +++++++--
 pydantic_ai_slim/pydantic_ai/mcp.py | 194 ++++++++++++++++++++--------
 pydantic_ai_slim/pyproject.toml     |   2 +-
 tests/test_examples.py              |   3 +-
 tests/test_mcp.py                   |   6 +-
 uv.lock                             |   8 +-
 6 files changed, 207 insertions(+), 69 deletions(-)

diff --git a/docs/mcp/client.md b/docs/mcp/client.md
index 4b643d493a..65d8cc5e2b 100644
--- a/docs/mcp/client.md
+++ b/docs/mcp/client.md
@@ -18,17 +18,18 @@ pip/uv-add "pydantic-ai-slim[mcp]"
 
 PydanticAI comes with two ways to connect to MCP servers:
 
-- [`MCPServerHTTP`][pydantic_ai.mcp.MCPServerHTTP] which connects to an MCP server using the [HTTP SSE](https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse) transport
+- [`MCPServerSSE`][pydantic_ai.mcp.MCPServerSSE] which connects to an MCP server using the [HTTP SSE](https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse) transport
+- [`MCPServerStreamableHTTP`][pydantic_ai.mcp.MCPServerStreamableHTTP] which connects to an MCP server using the [Streamable HTTP](https://modelcontextprotocol.io/introduction#streamable-http) transport
 - [`MCPServerStdio`][pydantic_ai.mcp.MCPServerStdio] which runs the server as a subprocess and connects to it using the [stdio](https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#stdio) transport
 
 Examples of both are shown below; [mcp-run-python](run-python.md) is used as the MCP server in both examples.
 
 ### SSE Client
 
-[`MCPServerHTTP`][pydantic_ai.mcp.MCPServerHTTP] connects over HTTP using the [HTTP + Server Sent Events transport](https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse) to a server.
+[`MCPServerSSE`][pydantic_ai.mcp.MCPServerSSE] connects over HTTP using the [HTTP + Server Sent Events transport](https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse) to a server.
 
 !!! note
-    [`MCPServerHTTP`][pydantic_ai.mcp.MCPServerHTTP] requires an MCP server to be running and accepting HTTP connections before calling [`agent.run_mcp_servers()`][pydantic_ai.Agent.run_mcp_servers]. Running the server is not managed by PydanticAI.
+    [`MCPServerSSE`][pydantic_ai.mcp.MCPServerSSE] requires an MCP server to be running and accepting HTTP connections before calling [`agent.run_mcp_servers()`][pydantic_ai.Agent.run_mcp_servers]. Running the server is not managed by PydanticAI.
 
 The name "HTTP" is used since this implemented will be adapted in future to use the new
 [Streamable HTTP](https://github.com/modelcontextprotocol/specification/pull/206) currently in development.
@@ -43,9 +44,9 @@ deno run \
 
 ```python {title="mcp_sse_client.py" py="3.10"}
 from pydantic_ai import Agent
-from pydantic_ai.mcp import MCPServerHTTP
+from pydantic_ai.mcp import MCPServerSSE
 
-server = MCPServerHTTP(url='http://localhost:3001/sse')  # (1)!
+server = MCPServerSSE(url='http://localhost:3001/sse')  # (1)!
 agent = Agent('openai:gpt-4o', mcp_servers=[server])  # (2)!
 
 
@@ -84,6 +85,52 @@ Will display as follows:
 
 ![Logfire run python code](../img/logfire-run-python-code.png)
 
+### Streamable HTTP Client
+
+[`MCPServerStreamableHTTP`][pydantic_ai.mcp.MCPServerStreamableHTTP] connects over HTTP using the
+[Streamable HTTP](https://modelcontextprotocol.io/introduction#streamable-http) transport to a server.
+
+!!! note
+    [`MCPServerStreamableHTTP`][pydantic_ai.mcp.MCPServerStreamableHTTP] requires an MCP server to be
+    running and accepting HTTP connections before calling
+    [`agent.run_mcp_servers()`][pydantic_ai.Agent.run_mcp_servers]. Running the server is not
+    managed by PydanticAI.
+
+Before creating the Streamable HTTP client, we need to run a server that supports the Streamable HTTP transport.
+
+```python {title="streamable_http_server.py" py="3.10" test="skip"}
+from mcp.server.fastmcp import FastMCP
+
+app = FastMCP()
+
+@app.tool()
+def add(a: int, b: int) -> int:
+    return a + b
+
+app.run(transport='streamable-http')
+```
+
+Then we can create the client:
+
+```python {title="mcp_streamable_http_client.py" py="3.10"}
+from pydantic_ai import Agent
+from pydantic_ai.mcp import MCPServerStreamableHTTP
+
+server = MCPServerStreamableHTTP('http://localhost:8000/mcp')
+agent = Agent('openai:gpt-4o', mcp_servers=[server])
+
+async def main():
+    async with agent.run_mcp_servers():  # (3)!
+        result = await agent.run('How many days between 2000-01-01 and 2025-03-18?')
+    print(result.output)
+    #> There are 9,208 days between January 1, 2000, and March 18, 2025.
+```
+
+1. Create an agent with the MCP server attached.
+2. Create a client session to connect to the server.
+
+_(This example is complete, it can be run "as is" with Python 3.10+ — you'll need to add `asyncio.run(main())` to run `main`)_
+
 ### MCP "stdio" Server
 
 The other transport offered by MCP is the [stdio transport](https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#stdio) where the server is run as a subprocess and communicates with the client over `stdin` and `stdout`. In this case, you'd use the [`MCPServerStdio`][pydantic_ai.mcp.MCPServerStdio] class.
@@ -135,15 +182,15 @@ This allows you to use multiple servers that might have overlapping tool names w
 
 ```python {title="mcp_tool_prefix_http_client.py" py="3.10"}
 from pydantic_ai import Agent
-from pydantic_ai.mcp import MCPServerHTTP
+from pydantic_ai.mcp import MCPServerSSE
 
 # Create two servers with different prefixes
-weather_server = MCPServerHTTP(
+weather_server = MCPServerSSE(
     url='http://localhost:3001/sse',
     tool_prefix='weather'  # Tools will be prefixed with 'weather_'
 )
 
-calculator_server = MCPServerHTTP(
+calculator_server = MCPServerSSE(
     url='http://localhost:3002/sse',
     tool_prefix='calc'  # Tools will be prefixed with 'calc_'
 )
diff --git a/pydantic_ai_slim/pydantic_ai/mcp.py b/pydantic_ai_slim/pydantic_ai/mcp.py
index debe95ccda..7eb76271e8 100644
--- a/pydantic_ai_slim/pydantic_ai/mcp.py
+++ b/pydantic_ai_slim/pydantic_ai/mcp.py
@@ -5,25 +5,28 @@
 import json
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator, Sequence
-from contextlib import AsyncExitStack, asynccontextmanager
+from contextlib import AbstractAsyncContextManager, AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
 from pathlib import Path
 from types import TracebackType
-from typing import Any
+from typing import Any, Callable
 
 import anyio
 import httpx
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from mcp.client.streamable_http import GetSessionIdCallback, streamablehttp_client
 from mcp.shared.message import SessionMessage
 from mcp.types import (
+    AudioContent,
     BlobResourceContents,
+    Content,
     EmbeddedResource,
     ImageContent,
     LoggingLevel,
     TextContent,
     TextResourceContents,
 )
-from typing_extensions import Self, assert_never
+from typing_extensions import Self, assert_never, deprecated
 
 from pydantic_ai.exceptions import ModelRetry
 from pydantic_ai.messages import BinaryContent
@@ -160,9 +163,7 @@ async def __aexit__(
         await self._exit_stack.aclose()
         self.is_running = False
 
-    def _map_tool_result_part(
-        self, part: TextContent | ImageContent | EmbeddedResource
-    ) -> str | BinaryContent | dict[str, Any] | list[Any]:
+    def _map_tool_result_part(self, part: Content) -> str | BinaryContent | dict[str, Any] | list[Any]:
         # See https://github.com/jlowin/fastmcp/blob/main/docs/servers/tools.mdx#return-values
 
         if isinstance(part, TextContent):
@@ -175,6 +176,8 @@ def _map_tool_result_part(
             return text
         elif isinstance(part, ImageContent):
             return BinaryContent(data=base64.b64decode(part.data), media_type=part.mimeType)
+        elif isinstance(part, AudioContent):
+            return BinaryContent(data=base64.b64decode(part.data), media_type=part.mimeType)
         elif isinstance(part, EmbeddedResource):
             resource = part.resource
             if isinstance(resource, TextResourceContents):
@@ -287,44 +290,12 @@ def _get_client_initialize_timeout(self) -> float:
 
 
 @dataclass
-class MCPServerHTTP(MCPServer):
-    """An MCP server that connects over streamable HTTP connections.
-
-    This class implements the SSE transport from the MCP specification.
-    See <https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse> for more information.
-
-    The name "HTTP" is used since this implemented will be adapted in future to use the new
-    [Streamable HTTP](https://github.com/modelcontextprotocol/specification/pull/206) currently in development.
-
-    !!! note
-        Using this class as an async context manager will create a new pool of HTTP connections to connect
-        to a server which should already be running.
-
-    Example:
-    ```python {py="3.10"}
-    from pydantic_ai import Agent
-    from pydantic_ai.mcp import MCPServerHTTP
-
-    server = MCPServerHTTP('http://localhost:3001/sse')  # (1)!
-    agent = Agent('openai:gpt-4o', mcp_servers=[server])
-
-    async def main():
-        async with agent.run_mcp_servers():  # (2)!
-            ...
-    ```
-
-    1. E.g. you might be connecting to a server run with [`mcp-run-python`](../mcp/run-python.md).
-    2. This will connect to a server running on `localhost:3001`.
-    """
-
+class _MCPServerHTTP(MCPServer):
     url: str
-    """The URL of the SSE endpoint on the MCP server.
-
-    For example for a server running locally, this might be `http://localhost:3001/sse`.
-    """
+    """The URL of the endpoint on the MCP server."""
 
     headers: dict[str, Any] | None = None
-    """Optional HTTP headers to be sent with each request to the SSE endpoint.
+    """Optional HTTP headers to be sent with each request to the endpoint.
 
     These headers will be passed directly to the underlying `httpx.AsyncClient`.
     Useful for authentication, custom headers, or other HTTP-specific configurations.
@@ -336,22 +307,22 @@ async def main():
     """
 
     http_client: httpx.AsyncClient | None = None
-    """An `httpx.AsyncClient` to use with the SSE endpoint.
+    """An `httpx.AsyncClient` to use with the endpoint.
 
     This client may be configured to use customized connection parameters like self-signed certificates.
 
     !!! note
         You can either pass `headers` or `http_client`, but not both.
 
-        If you want to use both, you can pass the headers to the `http_client` instead:
+        If you want to use both, you can pass the headers to the `http_client` instead.
 
-        ```python {py="3.10"}
+        ```python {py="3.10" test="skip"}
         import httpx
 
-        from pydantic_ai.mcp import MCPServerHTTP
+        from pydantic_ai.mcp import MCPServerSSE
 
         http_client = httpx.AsyncClient(headers={'Authorization': 'Bearer ...'})
-        server = MCPServerHTTP('http://localhost:3001/sse', http_client=http_client)
+        server = MCPServerSSE('http://localhost:3001/sse', http_client=http_client)
         ```
     """
 
@@ -369,10 +340,11 @@ async def main():
     If no new messages are received within this time, the connection will be considered stale
     and may be closed. Defaults to 5 minutes (300 seconds).
     """
+
     log_level: LoggingLevel | None = None
     """The log level to set when connecting to the server, if any.
 
-    See <https://modelcontextprotocol.io/specification/2025-03-26/server/utilities/logging#logging> for more details.
+    See <https://modelcontextprotocol.io/introduction#logging> for more details.
 
     If `None`, no log level will be set.
     """
@@ -385,6 +357,27 @@ async def main():
     For example, if `tool_prefix='foo'`, then a tool named `bar` will be registered as `foo_bar`
     """
 
+    @property
+    @abstractmethod
+    def _transport_client(
+        self,
+    ) -> Callable[
+        ...,
+        AbstractAsyncContextManager[
+            tuple[
+                MemoryObjectReceiveStream[SessionMessage | Exception],
+                MemoryObjectSendStream[SessionMessage],
+                GetSessionIdCallback,
+            ],
+        ]
+        | AbstractAsyncContextManager[
+            tuple[
+                MemoryObjectReceiveStream[SessionMessage | Exception],
+                MemoryObjectSendStream[SessionMessage],
+            ]
+        ],
+    ]: ...
+
     @asynccontextmanager
     async def client_streams(
         self,
@@ -394,8 +387,8 @@ async def client_streams(
         if self.http_client and self.headers:
             raise ValueError('`http_client` is mutually exclusive with `headers`.')
 
-        sse_client_partial = functools.partial(
-            sse_client,
+        transport_client_partial = functools.partial(
+            self._transport_client,
             url=self.url,
             timeout=self.timeout,
             sse_read_timeout=self.sse_read_timeout,
@@ -411,17 +404,114 @@ def httpx_client_factory(
                 assert self.http_client is not None
                 return self.http_client
 
-            async with sse_client_partial(httpx_client_factory=httpx_client_factory) as (read_stream, write_stream):
+            async with transport_client_partial(httpx_client_factory=httpx_client_factory) as (
+                read_stream,
+                write_stream,
+                *_,
+            ):
                 yield read_stream, write_stream
         else:
-            async with sse_client_partial(headers=self.headers) as (read_stream, write_stream):
+            async with transport_client_partial(headers=self.headers) as (read_stream, write_stream, *_):
                 yield read_stream, write_stream
 
     def _get_log_level(self) -> LoggingLevel | None:
         return self.log_level
 
     def __repr__(self) -> str:  # pragma: no cover
-        return f'MCPServerHTTP(url={self.url!r}, tool_prefix={self.tool_prefix!r})'
+        return f'{self.__class__.__name__}(url={self.url!r}, tool_prefix={self.tool_prefix!r})'
 
     def _get_client_initialize_timeout(self) -> float:  # pragma: no cover
         return self.timeout
+
+
+@dataclass
+class MCPServerSSE(_MCPServerHTTP):
+    """An MCP server that connects over streamable HTTP connections.
+
+    This class implements the SSE transport from the MCP specification.
+    See <https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse> for more information.
+
+    !!! note
+        Using this class as an async context manager will create a new pool of HTTP connections to connect
+        to a server which should already be running.
+
+    Example:
+    ```python {py="3.10"}
+    from pydantic_ai import Agent
+    from pydantic_ai.mcp import MCPServerSSE
+
+    server = MCPServerSSE('http://localhost:3001/sse')  # (1)!
+    agent = Agent('openai:gpt-4o', mcp_servers=[server])
+
+    async def main():
+        async with agent.run_mcp_servers():  # (2)!
+            ...
+    ```
+
+    1. E.g. you might be connecting to a server run with [`mcp-run-python`](../mcp/run-python.md).
+    2. This will connect to a server running on `localhost:3001`.
+    """
+
+    @property
+    def _transport_client(self):
+        return sse_client
+
+
+@deprecated('The `MCPServerHTTP` class is deprecated, use `MCPServerSSE` instead.')
+@dataclass
+class MCPServerHTTP(MCPServerSSE):
+    """An MCP server that connects over HTTP using the old SSE transport.
+
+    This class implements the SSE transport from the MCP specification.
+    See <https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse> for more information.
+
+    !!! note
+        Using this class as an async context manager will create a new pool of HTTP connections to connect
+        to a server which should already be running.
+
+    Example:
+    ```python {py="3.10" test="skip"}
+    from pydantic_ai import Agent
+    from pydantic_ai.mcp import MCPServerHTTP
+
+    server = MCPServerHTTP('http://localhost:3001/sse')  # (1)!
+    agent = Agent('openai:gpt-4o', mcp_servers=[server])
+
+    async def main():
+        async with agent.run_mcp_servers():  # (2)!
+            ...
+    ```
+
+    1. E.g. you might be connecting to a server run with [`mcp-run-python`](../mcp/run-python.md).
+    2. This will connect to a server running on `localhost:3001`.
+    """
+
+
+@dataclass
+class MCPServerStreamableHTTP(_MCPServerHTTP):
+    """An MCP server that connects over HTTP using the Streamable HTTP transport.
+
+    This class implements the Streamable HTTP transport from the MCP specification.
+    See <https://modelcontextprotocol.io/introduction#streamable-http> for more information.
+
+    !!! note
+        Using this class as an async context manager will create a new pool of HTTP connections to connect
+        to a server which should already be running.
+
+    Example:
+    ```python {py="3.10"}
+    from pydantic_ai import Agent
+    from pydantic_ai.mcp import MCPServerStreamableHTTP
+
+    server = MCPServerStreamableHTTP('http://localhost:8000/mcp')  # (1)!
+    agent = Agent('openai:gpt-4o', mcp_servers=[server])
+
+    async def main():
+        async with agent.run_mcp_servers():  # (2)!
+            ...
+    ```
+    """
+
+    @property
+    def _transport_client(self):
+        return streamablehttp_client
diff --git a/pydantic_ai_slim/pyproject.toml b/pydantic_ai_slim/pyproject.toml
index cac9720405..e2ca415575 100644
--- a/pydantic_ai_slim/pyproject.toml
+++ b/pydantic_ai_slim/pyproject.toml
@@ -75,7 +75,7 @@ tavily = ["tavily-python>=0.5.0"]
 # CLI
 cli = ["rich>=13", "prompt-toolkit>=3", "argcomplete>=3.5.0"]
 # MCP
-mcp = ["mcp>=1.9.2; python_version >= '3.10'"]
+mcp = ["mcp>=1.9.4; python_version >= '3.10'"]
 # Evals
 evals = ["pydantic-evals=={{ version }}"]
 # A2A
diff --git a/tests/test_examples.py b/tests/test_examples.py
index ad377bedbf..98edf8a9e7 100644
--- a/tests/test_examples.py
+++ b/tests/test_examples.py
@@ -127,7 +127,8 @@ def print(self, *args: Any, **kwargs: Any) -> None:
     mocker.patch('pydantic_evals.dataset.EvaluationReport', side_effect=CustomEvaluationReport)
 
     if sys.version_info >= (3, 10):  # pragma: lax no cover
-        mocker.patch('pydantic_ai.mcp.MCPServerHTTP', return_value=MockMCPServer())
+        mocker.patch('pydantic_ai.mcp.MCPServerSSE', return_value=MockMCPServer())
+        mocker.patch('pydantic_ai.mcp.MCPServerStreamableHTTP', return_value=MockMCPServer())
         mocker.patch('mcp.server.fastmcp.FastMCP')
 
     env.set('OPENAI_API_KEY', 'testing')
diff --git a/tests/test_mcp.py b/tests/test_mcp.py
index 735f76e55c..2f79d86600 100644
--- a/tests/test_mcp.py
+++ b/tests/test_mcp.py
@@ -23,7 +23,7 @@
 from .conftest import IsDatetime, try_import
 
 with try_import() as imports_successful:
-    from pydantic_ai.mcp import MCPServerHTTP, MCPServerStdio
+    from pydantic_ai.mcp import MCPServerSSE, MCPServerStdio
     from pydantic_ai.models.openai import OpenAIModel
     from pydantic_ai.providers.openai import OpenAIProvider
 
@@ -71,13 +71,13 @@ async def test_stdio_server_with_cwd():
 
 
 def test_sse_server():
-    sse_server = MCPServerHTTP(url='http://localhost:8000/sse')
+    sse_server = MCPServerSSE(url='http://localhost:8000/sse')
     assert sse_server.url == 'http://localhost:8000/sse'
     assert sse_server._get_log_level() is None  # pyright: ignore[reportPrivateUsage]
 
 
 def test_sse_server_with_header_and_timeout():
-    sse_server = MCPServerHTTP(
+    sse_server = MCPServerSSE(
         url='http://localhost:8000/sse',
         headers={'my-custom-header': 'my-header-value'},
         timeout=10,
diff --git a/uv.lock b/uv.lock
index 40dd158dbe..eac5fe26dd 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1748,7 +1748,7 @@ wheels = [
 
 [[package]]
 name = "mcp"
-version = "1.9.2"
+version = "1.9.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio", marker = "python_full_version >= '3.10'" },
@@ -1761,9 +1761,9 @@ dependencies = [
     { name = "starlette", marker = "python_full_version >= '3.10'" },
     { name = "uvicorn", marker = "python_full_version >= '3.10' and sys_platform != 'emscripten'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ea/03/77c49cce3ace96e6787af624611b627b2828f0dca0f8df6f330a10eea51e/mcp-1.9.2.tar.gz", hash = "sha256:3c7651c053d635fd235990a12e84509fe32780cd359a5bbef352e20d4d963c05", size = 333066, upload-time = "2025-05-29T14:42:17.76Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f2/dc2450e566eeccf92d89a00c3e813234ad58e2ba1e31d11467a09ac4f3b9/mcp-1.9.4.tar.gz", hash = "sha256:cfb0bcd1a9535b42edaef89947b9e18a8feb49362e1cc059d6e7fc636f2cb09f", size = 333294, upload-time = "2025-06-12T08:20:30.158Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5d/a6/8f5ee9da9f67c0fd8933f63d6105f02eabdac8a8c0926728368ffbb6744d/mcp-1.9.2-py3-none-any.whl", hash = "sha256:bc29f7fd67d157fef378f89a4210384f5fecf1168d0feb12d22929818723f978", size = 131083, upload-time = "2025-05-29T14:42:16.211Z" },
+    { url = "https://files.pythonhosted.org/packages/97/fc/80e655c955137393c443842ffcc4feccab5b12fa7cb8de9ced90f90e6998/mcp-1.9.4-py3-none-any.whl", hash = "sha256:7fcf36b62936adb8e63f89346bccca1268eeca9bf6dfb562ee10b1dfbda9dac0", size = 130232, upload-time = "2025-06-12T08:20:28.551Z" },
 ]
 
 [package.optional-dependencies]
@@ -3085,7 +3085,7 @@ requires-dist = [
     { name = "groq", marker = "extra == 'groq'", specifier = ">=0.15.0" },
     { name = "httpx", specifier = ">=0.27" },
     { name = "logfire", marker = "extra == 'logfire'", specifier = ">=3.11.0" },
-    { name = "mcp", marker = "python_full_version >= '3.10' and extra == 'mcp'", specifier = ">=1.9.2" },
+    { name = "mcp", marker = "python_full_version >= '3.10' and extra == 'mcp'", specifier = ">=1.9.4" },
     { name = "mistralai", marker = "extra == 'mistral'", specifier = ">=1.2.5" },
     { name = "openai", marker = "extra == 'openai'", specifier = ">=1.75.0" },
     { name = "opentelemetry-api", specifier = ">=1.28.0" },

From 456934692fe02e4407dd6b20f8328d74f121eaea Mon Sep 17 00:00:00 2001
From: Marcelo Trylesinski <marcelotryle@gmail.com>
Date: Thu, 12 Jun 2025 14:05:49 +0200
Subject: [PATCH 2/6] Add more on __all__

---
 pydantic_ai_slim/pydantic_ai/mcp.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pydantic_ai_slim/pydantic_ai/mcp.py b/pydantic_ai_slim/pydantic_ai/mcp.py
index 7eb76271e8..80ff34d8a5 100644
--- a/pydantic_ai_slim/pydantic_ai/mcp.py
+++ b/pydantic_ai_slim/pydantic_ai/mcp.py
@@ -42,7 +42,7 @@
         'you can use the `mcp` optional group — `pip install "pydantic-ai-slim[mcp]"`'
     ) from _import_error
 
-__all__ = 'MCPServer', 'MCPServerStdio', 'MCPServerHTTP'
+__all__ = 'MCPServer', 'MCPServerStdio', 'MCPServerHTTP', 'MCPServerSSE', 'MCPServerStreamableHTTP'
 
 
 class MCPServer(ABC):

From 3774b33c1b011e8153226558e65ac0b773fd7691 Mon Sep 17 00:00:00 2001
From: Marcelo Trylesinski <marcelotryle@gmail.com>
Date: Thu, 12 Jun 2025 15:15:53 +0200
Subject: [PATCH 3/6] Increase coverage

---
 pydantic_ai_slim/pydantic_ai/mcp.py           |   4 +-
 .../test_tool_returning_audio_resource.yaml   | 226 ++++++++++++++++++
 tests/mcp_server.py                           |  14 ++
 tests/test_mcp.py                             |  73 +++++-
 4 files changed, 303 insertions(+), 14 deletions(-)
 create mode 100644 tests/cassettes/test_mcp/test_tool_returning_audio_resource.yaml

diff --git a/pydantic_ai_slim/pydantic_ai/mcp.py b/pydantic_ai_slim/pydantic_ai/mcp.py
index 80ff34d8a5..2b5c205fbc 100644
--- a/pydantic_ai_slim/pydantic_ai/mcp.py
+++ b/pydantic_ai_slim/pydantic_ai/mcp.py
@@ -454,7 +454,7 @@ async def main():
 
     @property
     def _transport_client(self):
-        return sse_client
+        return sse_client  # pragma: no cover
 
 
 @deprecated('The `MCPServerHTTP` class is deprecated, use `MCPServerSSE` instead.')
@@ -514,4 +514,4 @@ async def main():
 
     @property
     def _transport_client(self):
-        return streamablehttp_client
+        return streamablehttp_client  # pragma: no cover
diff --git a/tests/cassettes/test_mcp/test_tool_returning_audio_resource.yaml b/tests/cassettes/test_mcp/test_tool_returning_audio_resource.yaml
new file mode 100644
index 0000000000..dd6929d563
--- /dev/null
+++ b/tests/cassettes/test_mcp/test_tool_returning_audio_resource.yaml
@@ -0,0 +1,226 @@
+interactions:
+- request:
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '1283'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+    method: POST
+    parsed_body:
+      contents:
+      - parts:
+        - text: What's the content of the audio resource?
+        role: user
+      tools:
+        functionDeclarations:
+        - description: "Convert Celsius to Fahrenheit.\n\n    Args:\n        celsius: Temperature in Celsius\n\n    Returns:\n
+            \       Temperature in Fahrenheit\n    "
+          name: celsius_to_fahrenheit
+          parameters:
+            properties:
+              celsius:
+                type: number
+            required:
+            - celsius
+            type: object
+        - description: "Get the weather forecast for a location.\n\n    Args:\n        location: The location to get the weather
+            forecast for.\n\n    Returns:\n        The weather forecast for the location.\n    "
+          name: get_weather_forecast
+          parameters:
+            properties:
+              location:
+                type: string
+            required:
+            - location
+            type: object
+        - description: ''
+          name: get_image_resource
+        - description: ''
+          name: get_audio_resource
+        - description: ''
+          name: get_product_name
+        - description: ''
+          name: get_image
+        - description: ''
+          name: get_dict
+        - description: ''
+          name: get_error
+          parameters:
+            properties:
+              value:
+                type: boolean
+            type: object
+        - description: ''
+          name: get_none
+        - description: ''
+          name: get_multiple_items
+        - description: "Get the current log level.\n\n    Returns:\n        The current log level.\n    "
+          name: get_log_level
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro-preview-03-25:generateContent
+  response:
+    headers:
+      alt-svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      content-length:
+      - '655'
+      content-type:
+      - application/json; charset=UTF-8
+      server-timing:
+      - gfet4t7; dur=2646
+      transfer-encoding:
+      - chunked
+      vary:
+      - Origin
+      - X-Origin
+      - Referer
+    parsed_body:
+      candidates:
+      - content:
+          parts:
+          - functionCall:
+              args: {}
+              name: get_audio_resource
+          role: model
+        finishReason: STOP
+        index: 0
+      modelVersion: models/gemini-2.5-pro-preview-05-06
+      responseId: NtBKaNyJNuzRvdIPls2XuQc
+      usageMetadata:
+        candidatesTokenCount: 12
+        promptTokenCount: 383
+        promptTokensDetails:
+        - modality: TEXT
+          tokenCount: 383
+        thoughtsTokenCount: 125
+        totalTokenCount: 520
+    status:
+      code: 200
+      message: OK
+- request:
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '73381'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+    method: POST
+    parsed_body:
+      contents:
+      - parts:
+        - text: What's the content of the audio resource?
+        role: user
+      - parts:
+        - functionCall:
+            args: {}
+            name: get_audio_resource
+        role: model
+      - parts:
+        - functionResponse:
+            name: get_audio_resource
+            response:
+              return_value: See file 2d36ae
+        - text: 'This is file 2d36ae:'
+        - inlineData:
+            data: //t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADwAABpAAAACAAADSAAAAETEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAACgAABpAAAACO/NZ3Zh6MxM9EuXIoAWwUxAQwCk6zHhg0ICGYSoXl1FYHYhlMdHClvwAzhnDTK9dfbEkcIkADJwM8VgjekqC5Bcguw/MPxN2W9XEEEIHAqHpptxc2Zk2nD5HGkEYXcHOXtFkvRDKbAdEo9bMky5v1GXQhBpk7VaLMu6jMA1FlVmg2vxXwc4sbmd44zTOM/HrUfJe2c5G1dEIe2XaF3iP1IoGA6G1noTwcDgnDZEzVb+VnYJskrLGxuRO1uBFT5bx6zLXiFnOXNzyxwkMZGeRWGTZFQwcB4miCg4GgNAUAsU93dEM4r+E+v+nd7IMECJB85F948kcR1MQU1FAwAJCAAEAAAAAAAAAAAAAAAAAAAAAAA//t0xAABjp0tGyS81IoFJeNI9I9RwAAAACuW1SJ0UYBA+uKDpNqAkcwwgjqjkeKI5EQuG2g60+daou50hvNLs60IgUpDgVumQhlUrSZNEoAGp1hU3zwGugBn7lKKQ+uWdjYfsa8eNzca9y7y8hs1u3/+3+Xts+tOopSl/fw9qwYkIBm+tdP6f/v6LOG0k88ltvgawyhEgVDxDhyhik+EwCNHQrKtyQwV6GKgnw4imEEPplFkTqaIaaY60UNBQxjJFpLGfaMXaWcWdzY8gWbIElyJuqC3dpg/NAThYnUJWoyXpNNl77gWQwiGqxMjMjbMlLZ8utCI4TfrGOFXpmTOCJYrCakVF16ao3WepiCmooGABIQAAgAAAAAAAAAAAAAA//t0xAABDqE5J0ek0Qofp2KBhI9RgQAAABKu3EdXPHXmhPiZLZzpE5WcskkS5ErD26YcC4In5UTCoIY08o6LOQQCAyFGHGVMnc7/X/oul7PfpPS8LOMPdyrtVIziNzFkAWILHb3hnbUjmwwye33/7Hym/xv2jGuH14QasosvGelR1CTwyyQJHJn8q3oEbLOtRfSjRUZawtei6hgaXg953kj03zKxVz6M1a87bbw6k+z2BYkFFzCr3Cl8leZYeCnHUyTZIQJPqKkxl2I3yZ13qpr1ipxXit9VMNyXOIzB1NNUGUxqGvU7KkgtM+HyRuKoYlQosUiw/HqkCa1FJ6fUEe5Kakfxq/OkyXbsHbso73D3LJiCmooGABIQAAgAAAAA//t0xAAADwDnHEek2kmhqmZ0kw46AAltL9niugq2In46GrIEEyAHNpP4wTWJERLfFdo0va5GCpJ0WoGtCnj9MGgdZcGVgTRYIgvjvZi3F4Z3J1ltVVPzMxrIXWoUn1FBQeCMWZG+X+J73nVX5x7921suM+SjXr7ocJct/PUZ1uNHZneAb+/tXap+Tu7ahJQBAAARSciWGJNSesLGu6erL5rjNlZPpV6owzSW7aDH5mygvmJRu+Z1tn1l/4///27J6wnok6//LKSLrxGeDI4NpwAh+h+KFsDVjEJoiF2d90Bg/YWQhycFUoMW7/g45tizFDcMk7EpiCmooGABIQAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAABDXlPKaSka8o3qeLE9JtLhIAAAAAQCd2qm6hPGIpUH4Iy7cGWVhEnSMwjySccbLgA3JJoFPVEwiBdGWgZdLjSUz6mfzXY6sZYGNQSzi0m9OuJwEoDGBifqkKqNDErluVJWWPkvNrKo2KH+HttQTbbhHSRQRAczh25in/wA3zmdRyWKt9cGGh66DZBADFbjpUI9QYoQ1kPhcZX6ottQpwJwzlSJ0LEtHyHhvISzq46yWot8cSdIwTtDVldn4W34rnVGE5TWPsxaXkCwZVVW8JOWMQBiuEPwJ0SYJl5Nb5glclot6xE5LXjc2sqdekrn/5Xx7c8ouYHyDQ0WxEhT4UaWIo0Xxad6Dlv0mIKaigYAEhAACAAAAAAAAAA//t0xAABC/lDKUMIeAIsrKPowydhKgAAAyPXbLNVqaeykIwmKlZmP5syXUjUOkdd49gSBNp1AODHig1Lk+IIyV+msEalgOoM0RJyP0/kwaCDUhyf4giFrYxLEpehtYkK+x5tBbIhkqEaAGinu+FUYWtCmduikEAFKO6qgyLyREXEo4llYjA2YAcGImHpIH4xxlYoHUkMv/A+6OAsiPXx+hfto8EMfkh7SbdSJKfDVk0icwVK7RdFs0c9n6eYbRhyGYkYUBbiCjKc3wl9Ptkcu8OpyrTrdItp+uVs3dxqaa7C6o83ClKgyd0kVR4h1G6EtTLt3yrUkcm2nSivIRmr5JiCmooGABIQAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAABjwVVHSYYeoHmq6P08w9ZkAAAACbeKK9tDAsTwdISh8kFsQgMhsmZ4EgDLXi+Irbo9GjB+IJbHdCMUYSBW2VCZU/LhnhwZmLPud5kMbpBepdtK2naK6N8wtEub5s9FtJTByMmNsUJJAUqFylnrq5FzQjPJH6cCyKO2z2TSox+R7mzDqRS+dJUwAAFpxUqSPuGf+G9QtdC7H+OI7iwtGXrtdJxytGV1HDTt40Rk/HlaVO3sj1W5VULblEWaMe7z3rzpaa9QnMf8rKIXGsiisPmPTN2s/R4Oy17eMlcMXvz1vZ9CYjaSgihSaZxkA1jllGPD2QPJHrIhG/2wWKsaO/lN50xBTUUDAAkIAAQAAAAAAAAAAAAAAAAAAAA//t0xAABjk1hIUYkcUojKmLY9g9RAwAAAABJyS6obukbZXVSF4GZ/UfggWh8VD60kOWPLoHYsdFQYgaXPgwRwRkiMKaJB4S2zC6klLkAkXa9JaKruEjxSpDArbyGZwEEJgZF0a45ezw1a5rlvFZNnY+9stdemLVqUQHykH/sGq5NH+cF/S/tMADTwjwpcvU+KM65RQXxPmc5QuxbABUXeiRY0OX1kyEVBaoEUwy8paKrRNw30JPVGsDYyIaIesCLMK4RbEd6gFjz8CSYxeXKaaZ0muEU5PHHh6s46TT9591VVq1Ga+sBEiNqaEeSrqpobFNDX0qU3qEpbmVdxn1Bq2CKIJI0J2lBCGFTU69rqfgmIKaigYAEhAACAAAAAAAA//t0xAABjv1FHueYfEHjqOPk8w+JgAAAAVHmq/BcYD/eWB8fBxJyAVmkJcVxCjLStjTQWn+L526LaCha66y3UU5djXJYTZC1lvZGWHPWBdTIwuyfjwe6XSeKr02oC6a72NyW+d/KIec4Zp0oe/9r/WBuxoRpX9sEcwa4wYUHFwsLAZ+LrgllgAkL0VIRgAV+3Nmj1UENkbYz09ksfqEk0Y15+pn00K8NRsyimxHY9LtXQGxTslUdLFek7TCHLhcvWp4vYjXV0BKoI1dsej03pAEemuZomKXaZDv2yoXvLYjeyO7n+XyZgTeuvv094dOzWzJzzQ0NlUB/AzF0hw4HAGNP5R9+cTEFNRQMACQgABAAAAAAAAAAAAAAAAAAAAAA//t0xAABjJEZKUSwegoIrSTox5tBxEAEAAJuW0DtknS0VKiYXCohmI4DEEt3oR/Lz+KJjLqadydAgB4MHBrKl7P3key8RSCDKP3Lrmaba5gCquNPhHXc0OEZqaB8vMnix0Jzd3nvf8iTPXF/cUe1jIJMB0HtO3V3v7+wJc/tOL4ETyx0/SL1urFINTwzFV1zr9olzXXycPJ2sqVyYwOCqEbAcAxEiJt/VJPBXbCGqCmJWJsXuXfrNvdzgRCnA4Yy9t/7s52z/Gyenena+s86gqDheYuqu9h5f01b6We7YifI0xLdskbLHEW7xHsthTJ2dgEjSk3JYgiz3L7aYgpqKBgASEAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAABkDVdJUekfEHHqqVcxA+JiAAAAAAFTVNVniQH+layMql5AiGwFmaJpqXVIkFfizet5IMeFZ4rFYhyKMs+i3lwToc6DjtgZidIezNiojFhMYvYnJHooecvqv8+kHbpCFiCCeFW2N898c2iEA6UsKUyKCeCRRKwcCERoifTvb3LlBdd0kRKNM1PJKVLeoT0AVD/TwCrp29XHdtY6rEmjEwCK9SoHNRxdgx6v03bVlFZ5l5EeoWGGGCGBxSfkoHTZBJuFNleNIHRPOyaGnd/rtzvo4RL4qK+Ju4Wg4TPEv/aMzC3viYLguU9S8v/74cxgNgaiFMOKJuOQMeDNlDMiEqhqmfPxMQU1FAwAJCAAEAAAAAAAAAAAAAAAAAA//t0xAAAD5VNKUS81omwrGd0kyG6gFAAAAAJ2PWqM1mG2ULQaLAcJh0gMCEhSZSQ7F4gxtmTj6b7CsiVqh4sAkRYz+cpH+yYl0OCKp2AyFk+Vs63yuHSOXe9+W+dLUe9ZP78r0ynMbkt8d7fZLweg9eqNTOY92L141+9eJzmYVPf1G/+Y9zteZxppJIoAWx/VtVBlAAogApOU8OxqkZDtNoFpecsmhBwIq5ZSCC9fbqeyB/s2gdauiymTaeCHlhZuV+YauK0Eo71WueLvxjdm07vGljKpKmiorTCUR6gaRYntdFnrj4+aRNtjWsuX+/iotrm2QaXcxUvQ9xoEKUxBTUUDAAkIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAAAjmT5LUY9GEIOKuVoZ6G4sAAAAAAJ2bPwL00TjZ1l3LwicZrSYoChg09miBZZeBuzr7spBLOkMVkwyOBcj6eI1mY0ijE+l3I4RTC6nIdrgdL8c5LTZ9Pbz5FjPVkv5HaSgOnSbUNnQvL7fLHVIwfAwwhgq9HOi4AcNfZApdxSCJRDiOgKAAG65HaRMKOoAGIhDw+ZTtgibGrAZIa+2NtYcBld0e71J1WuoqlVY3zmQtmIU0n29QgOd7CdixAiSCGmxlgXT5A/MYUTkUQHB2YD1HqWcTYpJtGnjJF0G0L8YwwozTm0QZZAuhzVBNcVN/xP+1bmOw1GmONjnSLm59pnG2QIxY3ZQmIKaigYAEhAACAAAAAAAAAAAAAA//t0xAABDzVTL6M9FonzK2X0Z47hiAAAABAAAMzr0mUNuuRsoYzIMASZEpKaI2hy9iUpXttPmuBk/zEIylnSESkRIaShZTcXnEUlZVsBtOyIEIeB2NKJgxhwlcXMD5ynKGmyb//k3BznnxY06qept0FGows5bPRLG1N//886PDzxEdfdJ/L6xxRrIHkqeNwhEAAAATtMpgRMKVlhixRA088w4jDHNGM1ONRSsg2dOlG0I8+FEmm9nSEZ9FBwMpTsSxFPl6xHnU5yWOKyyOpWSvbG+au1YhtLdVQaabP/j4y3hhZUGgsPDDlMExzKDzWDBELO///+ZsUayHmkpd2P4+A1iDAg+Aqo8nd/iYgpqKBgASEAAIAAAAAAAAAAAAAA//t0xAAAjtVRNaMxFRIkq2Vo9IvIgABAIAAAALhhrIKS2maEkXmnIoFDWfcdu+c8YS/00hHVQrurufrxYWV6JGeieVzF8qr0MupycznXepjlkaVW+ecGhE0HcMenu1zn3w9cU1VKULXLWOKFxADwwoUUWWG///2+KG3vHdLbmWtOjvKRnSJyTzKG11YAAAAHcSRMscaZ7K/miQnJ5PI+Uyre2zdtX3m4bLEqp4KudSNi+ZSeT6+nVIc6XqStUnaBuc12k0YfBYTkNk7UCRTm1LKJgns0tKlJGQUI6bdC1AGTzaf8aayEEa0tJKYzFEkKepNmIIbIGCNehYEZRzMQxhmr0+hvDFJS1JZHmallGRStFg7ILTEFNRQMACQgABAA//t0xAAAjqldMaGxFsoan+U0x6apxCAIAAAAAF6CoCBKo+OcAVFWjC14Oe9etTawT1z+slIeR9gEcvnScrFWIfTkOyqKn0yMOjgj39ew+fRzUqrhULjkyENhBY/dws79/lSO2VdSuKZyaMUcowoz5zfr///+oS6to71ktHiUteuqlo5Kth6NPBZJKQAwAAAVaP3au5ZhpV7VKrlV1TR2Hm3glCJV3V59qnsqMUTjleaIaKOlSPoJqlWKQhSvHCh68VRxM4lzNhhUKc44rYlmxUqFyZctw+cbuaAyin3BQnb12wT2+Ly4kYaS6lmrEiaqZVe7POJcb7Ep0vGGLxGXt/NAWhfI/Xmfo31bp5ETpbe2mIKaigYAEhAACAAAAAAA//t0xAAAD+VbLaS9GEm4qye0lA3ziJDAAAAAAM2J0gZ1iEPAwhyI6eIiJgZi1niICidWxIaJTtSKayI1XnC+GydEdpjrox4B4M9CNIeMRClyipyxijAGFB65YNjdQHh4ScjXmCA21QrjCpsPtZH0eHMuxKL3wUYXEpkcft/P/EfdNNNXfc+NjoybbGzAyFQoNqdm7caZSRJIAJTlTSQI41iG771tg2I1VIOkbFIISb2dFsKptdEDBh1DhVaRx7kng8qCuJzNaWEEjmQ0QEw4HHU8MN8vQyBWAA4pwzuYwGHdbCc0FJTBiSxLHn9597kUsonSZ+VYzWnF5CA3B1l0Ea6/UxBTUUDAAkIAAQAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAAAjhFBN6MkU9oiKmX09I+RiKCBJAAABLh4hMlzRzzBievpc4FzTg6Oyo4bRqoMYwR+UqagwIeS8AB6IsDgUmSkA0DdjwLk0VOh36ynGJPk/Lc8Ur0tLetXitM89G6UWGt42XTtPIzSTMlCHuRiSb/7Vsdnur3NdTg3oe3mjkmHuawBAIAAAmpf58Rqx1Y4zvHt5bwJ4Ua0GTTJHkZyCTHHHdQBD4kKNCR7edUSGcrOAdlhor0+OgrCFr6ceqt6XkuTuMGDONDY4iDICmWgl/aFwjFTAfFy5ZyFMnYYEpsVMYjZUNLrQOK7H+WvGQIIBw0iM7///5lkqH5w6R965Me1PMMLFJ0Tc9n8TEFNRQMACQgABAAAAAAAAAAA//t0xAABj61XMaY8uoHLJKY09I+J2DAAAAAAAN3Qpy1iRzrOxZd31FI79HVbr1FJcjVJioU6JglWHN7OmSVAUKgvLDY8j4QliBrBIGQ9puhzFAN2RwveGrdfUz2LN/huX3GMvPtVgsU7BBvGCQnQQcOGCcjqKUaqOVTyMMPo5W/0mO0is+YqvdHeQjmqW4xVGqU5gBAO3crhlEFsWPGi1rbVmTdXGlN41S3hywWNylgJhlnpLjvYkjs0siOGM+YU6clpsEDPxYmWT+RxoIx2Z+st6hirrI62qsVIVWILxoPEguhGFFx/BvR+yl/fUGDBiDy3IpP7Sk6kEmsqthRcEluaDGSKpiCmooGABIQAAgAAAAAAAAAAAAAAAAAAAAAA//t0xAABjwT3LUHhgknupKTlh445wBAAAAAKWxxDzAFa9ZSvy9k9edm5mmbhp92zEcLOpDnV5gr9YjvJ/+NPFgGYgKjcHh/VLyuHo8i1DTmAVGReZTTbJPX0Svsm3njN8o2uJRz1Vrb89T/ZXZVuPa7fvmszv5D0TOzoP/9MaVJvayZL5PaWoYlexf1uwCA/rVR9GZmICnNS/jzKUy/eVyeiUqly6mx4I4i+zsKyil5tOtcHzHj0hUkpI8mkOhTRkp1BBLorgDAxOxlASdrPAi2X5rmKiUa5b1P6vIMSzB3q7YYuGe3z19EdErFu9JmMVh5oOTPpJo5ldDNmQrRaATmc37JinWTbbTEFNRQMACQgABAAAAAAAAAAAAAAAAAA//t0xAAAj0j5J6ewz8nQm+Rk9huBoDBAAAAAATkfMjNFBVNjc2OPjK5mlncIDyFt8tMkU6RuD8+jQUwkuNmmomZ9t/HRKhHEnGS10qhowIp6WHB5RCdV6/zlIDJmn/cwgdVmJCTp0iJD7sVtW5VFJfPqczKnNrKncMjcL6OuxijB7MNKB+i95IIfmZuTr+68ABAFvAk0uQtJwvpntobguHOLDRk9KTsd+di26ttcsJvsKgVymV3g5tlmq6iREOcHjIkE9MXAYRqvWOKtqyEBg1fydvh2Htiq3XWzQ76gacC71h7NL1i/4ObvypwbDZTtduSMRlpdIExWp8bHk3r1kNadnMmIKaigYAEhAACAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAABjkVJJaMxE0njKKS0l5sRgIAAAAAAAMdz1JMThEPygsQ8mkiSu5m8niq8d1gMjtqvRdq6Xb3js1BKIiFdv0i5CDO2Zz6GOBhkfbSh6LmLRtaUNcu+aBeIzLIjRHMirFqW1I6M+zwb1MI0mx6qnV/xYw1rEjWh1mr6Y+EGPWtHy8TZVoAkOzaS9pTkfZm6K7cGET2Gnz+B8QwcgURZNzSUaxeBVmkODSHHJc5uRSVetrVmNpza51plmbbu4vgp1gc/qUe/3UKMNbCfVKm5RK1msnk4/b/MFRy6lbLJeH2dnIaonEk2NQyOIImm1kkzzTd0ksMDB5eTAx2lepiCmooGABIQAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAAAjjzdHQS9OEoQqWOwx6cBgAAAAlpye3VlASgYiXNrCYENEJK3GrxuaRrS4m0sgZnE6tfSYhLFoL5IqEyAUINE/G5nTjDFenVEnD4EiUkLMn3/ik1Jb6jlKUf5jS9Ysxcp06RtbpOxmcGGFAdgKOlxgVInQZjdCOx+eZjo3hY////5ikACAAuBsfQ6IrK2E2iO47JHCECRMXJGiq6ueJZy7Lra27UBy42kQ+XvORn0fb6VQvhokDb5Emk44S7cDY0TtLlIolNtdZdRfLpqmKWWL9SDCcWWWl001b8t2PlcaaVbQuhElZrGv7nmb47zqFNfYJsV9ZaUbgyVhVsItjFDLJLt08v6TEFNRQMACQgABAAAAAAAAAAAAAAA//t0xAAAD0U1Fqewz8m0KSR0kZppIAANcUtGcn6eYDLItjNO0FtDXXjKtFAwpZPEXQaMI/EEsB8uPIjOg8PausjQi9SSP50MNTnSj2S0VrWfKcK2YCr7C7qalQStF6zTM4NXssymqkTZ1PV5tLXRx1GEu7fftUr+9v8qP83tLZ3aqSrUU9T5bpYDIp/tbuzHCSAQCSCpLGZ4q9NHnFggi05K011drHq1AFCJlAVI5lIJRyEPuBo6liWsBhV0dxoNhgpnvIBuvXgvGM5qu+YClIDOVWe/ktvm8hsyXxqvXg9uzFy2a43Ox50IdKtuUZkmhGQaxe3LBbzeYuYHpiCmooGABIQAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADjmjZEgYk2EokKWII9Jn4xuF5+IsspAnHJYFrp8PyseBKEUskNBtJbosVcdn5keK3DMjH2xB4ZviZsxQlGhnmGD5lEm9oLI1CwWRQMgs2xJqVnMQQTByFlyROYvZooktlHTmTdF0rrVwZCqiSe8zHE0oKPXljkYekCAqGzmvZL6u7g4GNvKwI/fIYyt0IQ5EyGu8SsqE0yIQRIUhxCK2B5CBASbPMmgMopIVSJghURtwRRpxMhQEQJQPkxSj4qRnAdiZRpkaBeZ1BQC9U+BLWcSRfG3eQnfFs3LW5nxi/1WjyiTPVnYVXY2Nua0lzq5hvhR4eFAiekmk+N6UHUpeFyQeBiMLqpXvZX//6UxBTUUDAAkIAAQAAAAAA//t0xAABDx1FFSek0UnDqCNoNJgoWAAAAFkaqSRZW+RMWLaRs6mV6oT8RL1eYZEaqwlICMjWJBAXWJCQhRjTEZCVNyaqaJCjjq42gt7q1DPEzMJzDPzbzRzRU8OLZ3PerZjGT1ngzRUI/4TtF9Z9fSDNt31pVHre3zVLevuIb4vWjNx2ryc3a4XZHvt9tPgAAkxxMHR6oh06ColGQ80FlQtMOY5/Hqs7ECSNWkg7pudS2LfazpuylnY2eYSUWvWpPMNJP2Nxti6eKRppZryj0RYUkW6LyvGrUVahy8n7ef7O+nqd3dycnQkmsekskayT30M6/qYOgI8yMXKLPH+tMQU1FAwAJCAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAAADw1RFLTEAAI8JaQXE5ABQAAb7HMxLVpQMgPFQdTk8AOjYEcTB2cIFh6SAmUQkhGaTKARGGC5R8Gh2di1uI4ejhADRrlmEOI5I8lrF4rtDRRacXG+xg5Jl3R5e1RVeaGOyc8S7u73aVCIQiR3z3M3VfufoPuntCEQ97H269pV5drKLKBFQSz9IAgEAgTEsS2goNHDiNoYG2wyZfdrz1e1a5jQ75BseoIJu50tRqyCNKwAUmRHT/jZzQBpqSy9fHAmIvRRP7e5y7+5unnKmGPKb958wwqcx/XcsLfbluWyqDaXOd/Gkq3daw+9e3Lq+7V3GN2ZVINZZ4Yf/O9/e97z3vPmH63+dTDvcLHL3hP3bEaw+/fhmT1JiCmg//t0xAAAEC09IzyZAAH6paOkl5pZvAQAAUftN8ca6kRqQ6xaB+tGR9NlGbltI4aGpqgYGw8FUS8PoH7CEIB0gLYDjFhNSGGJqkkYFpN6JnQWpJIwNk0FIGqkNkTRKmpAxSUYJJUS4nRppXUtrpmqzGp0tJkXLqlqSUkkjSRRWk9Wkix8xWxqtkEXZkWSWZCh4kgsQUK9/AAAAAASaG0oMQWAcSicQ2UCopPkA0+SR5eDxzKgQhikWAvyRHSpi5AmysJEBLC4lyJoR6LZ9yTPoUyEni8EBlbkwb6ayBpjZlWRSYJ6sXGUzrzoGRhDg6d5ZSj0bdIgr9jsEI10Mh6h7+3Gu7//271Dpnd9gnAE5plpWAT4G0xBTUUDAAkIAAQA//t0xAABjpFXJ6YM3EIaq6PwnBopkyIAAAAAAUqyzXu1u2Vl7WPMQMFvmKvVdXdLYjEmJY8rDMs2LQZkNSWSVYGNCydOwdlHYO5H/wUn5974M80sY7BFet1c56Fyjh3k1+Y27t1zmFFm3zlW0JW7bfj1bNqmYZR/u9bKpNVdTeDmpqlpdcIONI6XiAAHkwX/lEqfLFiMTIjAPDpqCMKzMzCmgVpt/iYzk0EAjwItTyx3FArN9w47CmTQNE5TDNHY+nuWKaq2CnmK07dtTFQUVJExPpZkGmZPIj6fOckCXQnnJxpNQotjeSalmLpjeegzFMjs0+5/mZ2v19n35xel6ljxR++u/xtUbkZPLpwMeJ2mIKaigYAEhAACAAAAAAAA//t0xAABj5FRI0S81MnfqqOk9I8hszAAAAABS8WhWJRow0062hGSz69lyowVVIz4ZAjBbQpCeKvDmYbOW5RGQa7LRsWcPn+t0YoT84W3V3lZGStKfQWkHtHNeclKXRf7zzxXizqJH8wR0SJ+sfF+2qqauRLtj+33/5/+5VM17uYrJbuzRE7EfyyCilcjeRTXndoBAaH7vq31SLAf0msc7Msx6srLFqoFE6e9Tql0mSQoxib28/nuBNSRuLw0bTKkJE9JbIDJh7poXKv9yUpNAieh3Lj3S9a3d7tEESU5MhJrjcCY6zqU8zLd87AxxT5rw8oZKs1LCEw1Uw5H99rfWs0+JgmyyRaiv4mIKaigYAEhAACAAAAAAAAAAAAAAAAA//t0xAABjq1NGyYYeQIgK2Mk9JsgpQAAACqihpHjbDzSYvvOKAfL6EZ2mLOPkqfT7KMyNL+Li6Io6i8oEd9JQIcbgMWSXBFYlJzMJaR1Cnqzko1HCittsk6vrzWFKMY9KsuU7W11/BqGGZPkOdEbRmjonTa2BxnQIXYDEC2FI060QsILBoaCmcdzJgABQsQIkVzvo/DwRDa4Rx9tKFMiNcWTEVJBhjWqx2qzTx3bkr3A2mUOdSEYamQ2jNkbbKrVt4GxLMjI0bc9lKDur4IKScorTFaxNT4PpMiBNdzBlta9ML1SDkAYJyMmZWYy+angzTYgvLfccrXZk2IPWTm3BUk1/32iG7ZbdQzIylpDJUCinWmIKaigYAEhAACAAAAA//t0xAAAj3lRI6SkdcoJq6Pk9I65hZAAAAAAACim3Gt6yNcvtaKCEoS1N8lViQGWccddrLFfkQjArS8JNRpdNeElIyQMQJ4QThsMhVsIplAoygdD/Wowqqi1YbYxuRGkZmjUAJ0R6QgKhKYJdPD7ikDmsSY1FrO/+G7/mHxwPdocd55GZNM1NFEPGzEh/eXxxhQAEB5I+72vSd5EhbngKaAiyTR4N4DiwK9ggQYscwgRCLsUF4B/ZugrqbFvnVG0iAXlBhRuatZjXcaKEw4NrTrGnmqz0bIMOEoYH1lxmSLRCJQ0fFMFiLFB5DBGuXYIBJEUuWTxEblt3P/fOo7A+nGx1Cd9mB5aI9Jy5gqCKFwL7qAmIKaigYAEhAACAAAA//t0xAABj1VVHSSkdcoGqiLUxJuRdBAAAAC6c5T6qpAegi0ohJhk0TbiSw8D00m2ZPXVXmqWEYpnt6pNHBLnmdeRssBKBPOyaryC1QWEyNAFyx97UZx1aU3MLyYjxKy2B5RetcRikiQzWGfJlYhRYYs0cq1Vkctz14V+lK6j9NwfS4hznohw38OUBnU74B9UAd1qO9cWsiPAPVTZ84UrzJSVnygeDiaIfnq44uzUqlBUl52mrE0RovULKnXMn5qKgZFPWcoer76OKZCYQETZQpOKuitZ+WhlpummAurpEgOR1DJzxMo5GWNRQ5DQqCaLUJIqjW1u7ezJDbVX9rG03DmnbTZds7/NL1jSMYoCYfb8kxBTUUDAAkIAAQAAAAAA//t0xAABjnFTFqYkcYIhKuIAxI54kAAK6dei2LzorKmTVwlEttaV4AlIceQy1IoVt0XConeRSWtpayhLqLrFd5CjFSRxRFTcLOJYzOXXjIeIWIgTaMRPR2gIMKihioaIjBBhALKFFRmDhlwdF1w7sLrjQlTRICOSIYjNMjOyfVW8OA4FJFpwfo3Mqw081hwEoDTQ4AHMTodwZFo9WqBLO22IogLPnhCcVjAkGiZYuRtSGwXg2WaI2QMtoWyYjEInSbxhs+Li5OjAoLDBonmrxwgO6sysicTnZsyVgRT9z7JhmSyVKxxhu6wpwdmCiRKseIlDO19CZhQYlKbJtcDC0do66W00GAIASWQwwhcp2r+1MQU1FAwAJCAAEAAAAAAA//t0xAAADwVJFyMkx0oOrKJkxJpxxAAAEGuFMsdIabZDPFJ6g+SIdEOMqoguKzpA2Hh5PLJ3wpZxLpuTo80i/BzghFVx1F0Iw7TNRWYYVQ6DX0JjSgliEk2mN2G8GEnUcRtpPOKZH5e9DE3VZTlnf3t1k+/ZqEtAyWPu3SlD6fJ+KR01tM12cejF/1ztIAAEADNL0hdsw1i2EbnaG7GDGg5jqPo+njbIKvIZeyysCYuJS5BEqgtI8bdOpYwmxgwyiYJ1XwUkdk0QwKTVxuKdsSXGEM5osw0pBRu7YUBEDje9mAVRy7iLKZsbPLeshnS102hKbg99N1RWPKCcr3Nqog4+U7/2p94136dAcAjZyi8BMQU1FAwAJCAAEAAAAAAA//t0xAABjnFREwYM3oH5KGIkxJnpLAAAA9bU0cxpZi5gip2AEWuuCE+cOFzg/pj5rj/XSy8furXy5cyiT+uvVx5hw951pPDEsYflykMMJ6v1+8Nm2+psOaApylmGCQzZGTMU91WHkeh21CJF40y3uRq1uzzPS/zM2R2FR/mTlVtLGJXIhYTZ7oCABluq11g85GPiOqGfMA3uWQVISIhRkYZQTeRKCF0G2D8OTiMYV1GiRDxyJDUkcpiiyKx60CzwQiOFAZFZI8ITBF6Mwl7NAMGLqmpzWONE1enRnv9bRynbCp6DH1H1+6tyrpm5xmzKJW9BPJlOUoclhZFSGZQHB2va1GtW78UxBTUUDAAkIAAQAAAAAAAAAAAAAAAAAAAA//t0xAAAjV1DGSSYc8pCqyFA9hpwlQQEALukywwlmImutC18gnKBQSMoGz4CIokLlDCQ3DTAQjysKXeMV3a145HZwxPbjpqli9LOeahBAffWm+pspmwnMYsCqmfT2yWsqD4c6qaGi2exlUfvTq0xxf26LaPErgzGkbyRA6+3f66nVjewN8sCWG1sq2klMqkFtkENPh4pdkybxsvNjgxIxNMTkPDkel5fSLzw/NV1hcVimfpXx5OVI5JD1qblIrGRZYWklEcuUEcxQlL6UtsPHy2NExvsrqwvTgji0yAPZ2AXS08q/50o1cLbfT33SaWSRW3g3TEZhos9qop5It/tX/uFZT6UaVDQFuzgncLVM76kxBTUUDAAkIAAQAAAAAAA//t0xAABj2FJEQMkzUn9p2GAww/IYAAADzLsMyCcBzpFpiZEI0VAsgHiYszQmJAyYeWMwkLEyq6gZIymBXB6ZiIUoQhldMIMcCG0lm2lKchRTokiyhcJkDSGFSEWi8JxPOwtP3yC/G7edzL/otum+7iLagp67ZuHw5vZIzU1ymtqx2czw5v+MI6ujT5g1V3bTpWrLxOeTtLi0cLkqYESjQdTpGloEbxdo3cXJzslRnXPjNMBosDvbCyXV5XQ0WlKEinar05IElYpQC1jxeSHTOorJtcuYWeCI3JDVPMGU2WKN041Znnpo0W/WjnWjsCYv3Ono4I2HGMbLd3xyPYjeA0LFiDTJYEyQWFG7LHM8smIKaigYAEhAACAAAAAAAAA//t0xAAAjvlHEyMkzwn9rCJkZJm4ACAAABJ5IAzp8HWfcJLAYabONDLEXOR2SkZkgc9gPHoEhPBUYKk0Mikgk3RNdA13PMWkx7JpJZxZz4s2Q2soSmQKMZPDE/uJIx6+Qhz2Xu5ddDH8/69eG3NxvN+NeJWrTzlacWkRXX99OLRYaA9FJdG+ZbvVO4/xhQQAqwSeKcbSUmA9SgUTMNFh8UGipYaYSZaZYTEwiBkcouSo3lYiYSJUQPiy6HGT7J1CkPEKF4yLUwhEqSsSTBsIayveQcUq28YmyGX9LYm9oZH+XBsZrbN2FqeDI/N1teNmy0k6Wg73hM3PjIBdMRGxT5vX6lWlA60BjDNP9CYgpqKBgASEAAIAAAAAAAAAAAAA//t0xAAADhVFF4MYb8IvqWGgxJtQTMJBJAAtdRMITsiSRPVpSHCJ4zEVHBBosbDnzdIgqBpxWhdL/lIhHqToIn7q9iHKwgWTLInm21WswwZMNxxY5h3s44HAVRwQAIDMWRVWNAioIK+yaRQdKOH+g7AAauPwhgDzFH+VHEQdD6x5Z6CPOVgGAAAR84lRLaMoaC06PDyEySDwrLB1GZyWkNW4xKah2uQDccbLwv3Va5GiRh/ZWYjrC6+R1zRkjmWIjEkRG2p4kOqqIEkBYYIzo0yQmIio4iYIu2SnWNgjt5qXskdDchR3lj5f5VV2L2d/v17UJG5MaWVCeEyvzaVRmlXJkPBUaG0kjtCqwEltl+pGhMQU1FAwAJCAAEAAAAAA//t0xAABjq0lEgfg2EIEKyNkjJrRgTzWvEo+vbT2ePeuc0VBAZqPUfGiS1at2hTRNSwr+8Q5Rj1pTHEBC1HZAIy+ZbNj8YnqS3Yj0CfLdFAxDBRM5wlqOW6kXJogZeXrlmeAjDuu2cu8v7jUz6j4fGvdh2Z8ykIf3319hvBTCBoWonBI2wNtORrtUggDwgqyXCpdyiDWV0PAgGkNF1uUFKhD8UwdOLUUTWHBp5unpZA0MyRwSabKqhyBIRti1Zwns5Vsbxu0HLvpL2/U2PEGjvqRsIZBBPtCS7PptyPU9rqIMx+1tEYTv/x3JntH3Pv16bZbLt8LVk7szetEth++4Zs2ZLTMV4DTvkq/aYgpqKBgASEAAIAAAAAAAAAAAAAA//t0xAAAjj0rKaRktoo3H2PkPbHx7buaAIAABdgjEJSukmqSIkD2S5eROCCTNRLTH/W5XDd2ddxiBlIJzMJUIkBhiA0As0UPGxIUTM5sstgFl6Irj2Of/rqfPZzOpw4RFvgIOPqyGRikvcq7kYbFznO5WeipWiMYrKi0EBRsPgDloIMR/7+o3KAADEOYInEmohUEZ13pH3SVQujOdSHL07HWz2+VavcqqU6g2dIzsEHxmCGHDCFBe4KgxxQEpi9QVDRAWB2uYKDqDO7LmeCoWBjJxKuHV+HLd2aycn5bspgLCxkzJAtVMb+/c7LUBVXdiuCOX2U/WTZEj+GvxZeD2b/nLP+WL9yUDpJTEQ1BWToVEZO5KmIKaigYAEhAACAA//t0xAAATp07MaHlD4oUoCcgnCXwireoABAAAWETNYW1FCVYF2fYcBe89/5/9e93n4d1/HUwp4ovMBvo/wfMtGJi5VKk0VYhbJlbxK4SErtGdazSXwUDn/nn/u8JwoA8APa0SjpSECl6pcvpDMnNtRnbigh21cCg5+P4+Ox6JFqtLaOvj9xoo48v4AAAMbUikAQGJ0Fw2jRyiTgoSvYFRgaaNjSYPsXZfSTNPKL2dTWG5I6lI4D8OSfBPMwxcrZW2e5cjPCtA29/h4Tc4stRQJdrT2XuEFw+b//k3DP/4HUICg9m0dA3Uc1NfFzbBQUvvbWQY/hRGUQtwXGUQoIhxGiWPKNCvuCYvYNWUWyhLkxBTUUDAAkIAAQAAAAAAAAA//t0xAABDx0DTOyxGhIBG2nVvC4owAAAQXRqxT8gBlDePGoOkhOSumlEtUzWUXQQTqbmFgRQ09y9AceceGHka2/9aUWJXRU7O4AltIkeAk4AXPI5BCI2rtsDogKJhVhJ65t16Jwypv3r0//quK97Pos9qxcp4Me0gXPSH/9BZhYXLccYEDj4/amqOyMcLIAJ81MTrYJ0qgDTQIHPWjGj2tRqhcwDDAgCEBph56Mh5wryDTi31TFqDtoswv4ZWttobJVmtFYnZdwDAUGLAzIgVECEiomvGUb3M0CL6xjsDJ9Q8wd+L2e24buUrf9OPh823ssfMSO/kdJ4PA3i0QRw0ODYtEK3by2bOGPgiDTWJiCmooGABIQAAgAAAAAAAAAA//t0xAABDcz9ZUeVOtIwn6otoSeA9AAAABkzjTHRXQna9REyskrQ1tRf4AT4ioGmIMD/Gooj8MJSJUWcfmYq+u4TmoCAl7JKKoiFGF4X1QnUcLDp/e4qAo053YY12fsUgx1QSJ6U4MPCMTdGaLEMQTlnX/uiA8+BE2WF8aS8znuhYqKwAAAJm7va+oW8TZmRTjC5Y0FF9iCIoiFmAVGRSi7Y0jIyowMdPsHBwoELkkA4WDggarh21h3HYquoCh1rhDVLYSJS8KojhWRk+BxacQkFLIytgLehgFFlYSFvXKqLKXzsptf0ldChmI7GTu3BUkDZG2DY+S4iGDCPgYJA2RFRIXV//5dZlQlYMJEUmrTEFNRQMACQgABAAAAAAAAA//t0xAABjsj5V4yVOkoOHmmhrKYhfAAAAAADBqOS52Lk/AMZcLUijUsfKbJgkCzaDK2iIswVWBqWvKzpv1MS+YNDA1ao3ylsCW7crQQuUGVr9DhTM6TuZBg/8kdqGKXlIBAGEjlZyl/+9FRRNllnJf/tFj5VIuUYwKsRJUSK0i9s7c/6PeSemVD7Q0gAn269psDQpRbQxkc7GoiOgl7IWGRUncemhnGpCmgMAoRGdrCogQSChWpkFoCOJhlaL6C48bBbDBAkZJ5VCMssCFnOsBZjyKNpEEngIOOgkQLkQtrQSbFDr6ZjK3////30KEWItaz1/5mNHWmRIIiNGJQRyQiq9LkR1urjnjH2ytgUiTEFNRQMACQgABAAAAAAAAAA//t0xAADz5T5SC1g+AoBnyiBrZ7KATcdlb1Q+2eAJYwK89rY3VfcQAB76ZKmkncJk5pmIYVglpCaiS6nUwZQKCkjgpAK1yKH3PUADAhKhBRYyhQIBjn4cXG1BgAJDASBSrQ0E0fcAiDkHrakUH0/9xLJDh43V0I82NheGxFEgoXHCgjiS5YXi04Hyt/NNzscOF1lVElhZjEEW2HTqzZU1FO2VqXFSIHoDBHgACUbVwCQBQDl7oKUP8l8rwyoILFyQQtIvMBRY8Eiqlo0hiIwJiwxMCFiQ1ZnOzWQMui0mShY0QigOh4gNjEeEoWHPqEpikEf/mokljylM8WCIIoTiOKAnOHx4mWUkxAgg5+b2ocpZkxBTUUDAAkIAAQAAAAA//t0xAADj1D7TE0VGloFHilFrCMDAAINQM2MDN3HU5uxloTsQc/i+ggCYiEcAGSDBoInfNlplM43L3bXhBjpKblAZKl6HdbM0dpbBDHHy3RhYLBh9OYc2c8SPB2MsAeCHkqaV/6dzB2dxMCUIOnO/90GtwTUWY6CCEogA1PDyjziCJHFo+9VE/4sfoiLQ15iXVUSqJCgiQJNNqzOHmr07TzCHiy53WIckDAAqTZsjAgLUWVDTJyoVroZggIEmwVBA5gDhi0VBMC3JiB5loIVLkyM2A0EhDXlggpqOCUhQCgpZcWhSyNXADCYk0GoSm0Ss1X/yqDoxh+WVT44QR4CYmFBQuxl6qqr/7x6cmjCuw9pMQU1FAwAJCAAEAAAAAAA//t0xAABjRj5WGwM2toKpytdkRtLAARUA+ITJMFaDbuu3dk6oHofNGoKpUCMaYuiAmnVcZ4KSU3aZ6GisXNo1KQ45d9vqCoyEYgn2CsAjRdI4RVE9KsDbba2u9y53W4s5lP/ifvrsv10boNjs1I4wF9cZgZHz4X76B1Mai0GBO8ZU9A8rXpKs6CYNXA7UTbINOkFZwgIcwcCvZvZK7rny2VNdo4sj7DcTS9ShdiRZwSoChCaSZMmCiAEXQpjqzpnSh5WeRuKQ25BGqv1zUmpQC3hY9+XGoSma2N7A5ImHbicdoR/mN7iD7EyXSBQZ7aHZ///ues3c2LMPQPdjaQkYqmIKaigYAEhAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAABDmEFX0wNOlHDH6rdoSNLQgAAABuYDVitZnGGS5pL0NrIZM0ZLMyARyX8xuairswzlTSqxVkk2TAU6bO02rrO4o0so5INTiLSqqiUhaQ2eBHWhux/iRQnTjfp1/7ZQESLqFokdNQW0yjWmzKUuxmLtplqrc///7orYhOTJBUNmXIpoYAAEnQMqfKMStNqBIWi9TSV50OBaIHM07uqVZwhoccr3I/ST1Ok8EDVJrmfWRzEpfJJYKQDIjRqmXYWkaEY15pjBGgqVNvS41QF/mbS6+lCByoeZFFshcCout/9qNPkLBwUe91Hz+wNwbnKWorYgYHpMQU1FAwAJCAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAAADVzvUmzsrZnKoKvo/C7CAAJUA3cm6SPCNVnK9i5bxSZOgxplfqWNKdhElgbSazjUsgvPhuVvmW7TWVvstCuqVuAFAUxyGNHO0IRYEMAFzMAtJgiCFdRGvljzRBMzf+qaO85ROOMKINUQDIudv854kQqP3HmyGHmiDUXAAKAByXgQkNRasYhml7iHBCbjjB1EJPfK8ypBv04teoMKTsqLmOR05Ms8Ydc2hAE2vp2pOu24MjlsPboBOcanf2ucdW7/lVFFypSXtx+D+YZCn6NQIWFvU/sg6TQSSYqyO1UpOHn2NhsgPxONFjjZ6qUUxBTUUDAAkIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADDZkFVG0M2lHSHurNphsbACKdA+/My9RQwFQSOPuRDltRFYhhpL+ISo++jV4nEa8Loc85vkgtNHdd26R56Z9oyx42TMwqEHGB0YMFUMmwNvIbWv1d01//sGM/4hVEsE7zgBVWAyMWTkCf//7ijoGznz3C/23mEiMXVx9/MADTlAsWbrzxo2NcsC1XhgFmDsIAQIEJg9uIVm+hm7YnLOXKterKWku08TRoegxO7FW4G0DKLxpAX1EAVb4Zikn3/8TVg+9JpPZU8pPzTJ5mze5CwtIgG/Y0xTqVq9+lpnunZVBIn1vTKmSPfMqLRTYkXDNjkxBTUUDAAkIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAAADEz1X0yVGJpCoKgN3iF5QAJgARu8D5nCkaKcUI09Di6mZaVeuaLWY9dn5VVvUer+v/va9ivMZbvu8xEGkookSCbTpucAw4f6zIYz2zgWMF/EY7H5gcClQ5LFB+19fkGILqWyX3HTU/Ki4oSLoaeNhdHAAAPgS6ZHAgHAbMMhUMLO2MNQgMAgfMJh9MEhIHAbMKAcTHVeXTi78qtduBGOvLT02oCppYlQ9IkCUBqRzVyECCACgIDGJxKYylZjcomiAGYfE5hoZgoMRNjisUYvWcr/Vif/1E9y3s6IKmMJ/4EMOw2QUc/H94TA3DoaFkHJfDrzd0mxAtAnEMPBOIdu8j2lTEFNRQMACQgABAAAAAAAAAAAAAAAAAAA//t0xAAADIT9X0y9adpbnqaJ3i15wAZwBOTcClzjkaXucKJWY5yjUEOLKktvHbyWDCis19RcfVrRIVN5UulYM0f6pOVTo0bSSJlrWuv//+OE2K/qIF5tU1tk6uGsMl+3/yYSESMkXHDY96EQyItJpc1i8j3TWHjNvoABhXTIEgPEQhmUwtnJ24mBQ/mFYSGUo0mEIqCxkGCIAGCQYnQoDJlyJBJSCMBPYtWU3HWhUFyckAIyGhIJgARiAKBwXCA2MAFGQxUATTu+LKGGRWahOwqU0JqCcu8RBZcrVXfdZr9q9v/pGxCqh/NDz5THpZRrNiA8GwsPgjgFm5oZvif9E6WuRqYb89P/bzN1ZJ4bxUJMQU1FAwAJCAAEAAAAAAAA//t0xAAADLkFV0yJOJI/oOcJtqdbQQrgAVO8DKHat9AAFqkzmgN6+j5fTSiLXrNNF5JR29bz3/akxCp6SVqW1JKIVLhLQ0+IZnzAvfeDbrBgIIId9kZS5onDYAbJwExduH///gbKvV2q/r7//DTxdOhAQ7TZ4ipNh5KwABwpC1wBIyqRGliJ5ImGYAOUDM3YxckInUoGRGNzTlK3uo+kWa1LeWJXIb8FOMPBw8SDxeNHAiEl7AYOBoopaAg85pqMLLzURY6cjBxiZaCL0LfiQC40uZ7Sv7lr/YpkYaB6Gy1pEuXJeTWmaFMWwEGC/k8TkxoK/okIvrNHVsur3ZLCQ+A0hdQmWZ8e6WciYgpqKBgASEAAIAAAAAAAAAAAAAAA//t0xAACDfD9SO0pGFown2cJt5saAcAETKBcdVyQgOJIzNV5Es0cQsmFjCYbMYXjjfkHxi3T47y+pZkDhOs38qjUpz4osHVyqDEkZiADIIfGoTXRv/yxMLhrjTRRR22hD2HxCAiKAYFCCXm//pzSg8R772k+r8lTbD8SiWnEI4VoClc9gAAgjQ8RkgoZ2VmfEBu3waWHGAjZiNUZMGC2KFQxNQu0kxg/7TZ2QvXJ4bt524lTQGMAzxF9oymmytTcwQaMJJTUjgzQoMVKjVm8DHZgwAD4C0KOdXIZBf2//+/bEdgUa5Y106a0PWWpczSbzBTziTgd5gFph/im86/+w9lhZWf99363/c9EwicpNk9yYgpqKBgASEAAIAAAAAAA//t0xAACDvzNOk2FOgH7IKjdoLNDAAMIZLgCMYIA0z4RE1czALj5iyqZSzmcDYwAhUwby6vluMmf12ZXMWMq8up46vYVGW6srQWe8uwhJAwESG5mj4eiWggZaaY+IhyOBhFmy57V18odtf5BzmSxExrS7IeOsS28eh5yIaNzrP//7WUaaaH0O/phAoaYYAFKUDTY4eS5Kq8CF3EYkKSgqfFhj1QqBcLOorAUvv0tzLXL1Zoqhb4VaSGaNei/RgGWBodsAQkSAoyp3wh1Kfd2XYf4V/IjaAlHP1UUpeBydPSEP4gl9OTnrV6ZmdrGKhUTEY9G56vvV2FzV/ytRxvFdHpViubFUdSo4/cD2mIKaigYAEhAACAAAAAAAAAAAAAA//t0xAACi/j9TOwtGBIRoCgprDF7AIAEjKBualrXxXhbSOwKRbKNJ8r9p6e3vC/f1n///M5qDUqK/JDrCXUi8QhspUFd2MREWJJPqW3y//3I1UY3uoozn/3YPjbqv//tksSmycd8WkRMo9ToQiiwghKQDxKsGE7Bi6JIAUxNwrRVUEL+mQkmZBBjIiRvq50MdwmYY1enq9Sj3qVRwzDg6SNynn0Yez53QZQ1RMR2qJJQWpi/sUt45Wrvn7vTMy85PlptT8sq8e+p8xOpT8ugr78/V20z20jV0WLUbcBzVr2X4X5rjZPMH46JC8aiA2+fuh1BQyX7P/vOpiCmooGABIQAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADjnj5Mk0UeoHnnyVJrBl5AAcKFCUYMUQqj7yB4uXyVO/ZqxRnwgCAA5AqunC92qCUxqDL/d0GVt+aYI1K2pmrmVuT7W8guqEmDHThJEOQDArJC2Rf5wnndWBobpuoRqocxVULFWksd6o5hl3Cw44sh/sgtARmzBr6RGX7BamjIYIc76mgqGKJjhExzExJQ97QwgBl5rZYRuNsdL5p7AkkdUm/sNNIkT85X+xmW9a01sUGhruAnybZSlTN7FImSQPCW/EAUVTYla7ttihiB5DD1Y8jO927PVztlR5M4Y1nk2hQsYuWb425+akEOcNlFdvv1l6Ip92Nc2HMmK/XQmIKaigYAEhAACAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADDmDvKE1gy8oIHiPBrBl4AGoKYwoAlAjQ4PgjjdW4SHGGCmZDAaYYcwu500NaCMwLN0lHa/8N02TCwNWQt7SPi4tnNepwqmA6rXhSKcTY38cagrZxa3qApL845Ld8Ql5d9iHrOslJIkVuI16t3vzeYHUl6pJ4ny16RfTYBjlWODheen4DJKNBoYx/SYVxIXULDzntDbHzRFQDkQBSAizM0Si9aFbjcz3EpJOv2zRDNfimyxqNizvJerBmmQ80YMBojqRMAFAmREZa5Tju9IboESSyET0OyaZlQgnv3UWSrDMi1bnd9+7K9S02freIh7XKGfJa8KFjAWQWcMsk0svi1z51nY1MQU1FAwAJCAAEAAAAAAAAAAAAAAAA//t0xAABDlD7KEwYekIJn2aphidAAAYIKFlqpK7CxDuRuEDhdqwiKgGHApatab6KRM4SbEDzzTOdu3JqJwCWVW7B0bibXKF0l3iE6iCfzSkMSE7LwKFzqFp83hZthB4D3Ym4LIhdn017/r3/RaOOgcyHCEk7yRytru+HEW+EIO4RE7RbvA1pcDAAAl1i7GKCLLtQ4sVeGRPuyNwE6UiAcEtGASo9QsDUTBj/O4VqlO9RiM4coetuEnd2BHtWQvhLSIlioNCCQMqZlGZI3CCZY5FQTMuuf8/GlJI1FIVEkP4Zc/S5aJGWZZbk1UY76/YFcnmKXZ854rdNLLRLIBQZXgiFm6JOC7QQPdSYgpqKBgASEAAIAAAAAAAAAAAAAAAA//t0xAABjpD7OUfhFoIVn6ZpliOIQgAAAAFwDL3Gn47ozgfiRVh/7HrFwE1BlgqxTAGmtNTUd0ynglRts6eZmo7MI4hLX2+a0BoAqSCkbqF3FAEncH7lk2xKC5+nm23h+xhFQjHEjyQ7Pe+pvlWYicUM9r5qpemW7PJ+BpRFMlKgy6YUTFDBUxkTAAIh9q5ZfhQV14gsWVwElYxARiixxQKUEImv0nRDbX5ugsN1kMOuiTBPrNS94ph/X/i6Qpc6lGjhFOehwATEjgEiGRlnyYt3oCUHYXgmAz55F9QJGPj78jKBUXIlsZgwSLtwTpTfPigmSHDt9cy/t3z32b6j3r4TgWFagp5IB8OxpMX6kJiCmooGABIQAAgAAAAAAAAA//t0xAABjvz9NyflFooBn6bJlJvAIQAAAAwznzWhOMsRVqFeNcGjGElO4BqHU9js9XXa3qsjjlMVVpZl24xhRoLmuOrG1wEQDJ8hLxiM4qgDrqRYQLAdpGelZWs2UvU2F4oFkrXw6DBgRvuWXY8QifhpHECdHPLmZkpR62yWs3T8/LjZ5EKX0GitD80oPn5Z1JiNRj2vRpTJRdganBmEvuxBjzT6aKRLOxbqwzyNMPZtDFJP7fVYB1FllvYBDAQYoYFDczFSCt6myw80mmk3DswmA29rj1UMOzVl2GzV1fyJ8MYMsYVHk52Nk5GrFJRaI+ob7ftTHPM2L03QLe8u9RMJXS0ClWGY4KJu//oTEFNRQMACQgABAAAAAAAAAAAA//t0xAAAjyD5Okww3BHan+fdhhtIAAYP/dyiTofKYdyVPinUnABpuK7cMMhrR+Gqv/q7Z5beZdUOyDGVydxnbL3AxiOSy0rEKE7VbTAoIGXEYeUBUAgtXDOp/v1oGZBA7iNaCoiiaoPDkzODExM5mgVYQemiBkQ3/rPmCTHuF/48f69Wv/uouksIa8+LakBCXD+7ztSLCYcd2ogvBXSPwkF1H7lUNS/s9W3rHWModGKy2MzU5g5UTYi4D6qQZiAltaERQAJn0MwhrbcZQCgjGDFHCAICIuqR95DXLHqHCda1Pbd0y0jiWfP2bdEoBOkDv7gvf0X+//mn3ZOFIdMRfWXfVT9KYgpqKBgASEAAIAAAAAAAAAAAAAAAAAAAAAAA//t0xAABjjDtOyww2knqH6bNhhtIYAAAACw/HWdxp8rrOo/kCsZlzpNdWPBy1k13AYlZ7zveciTUXIn5+pbg+ltv40Z2mvqwjVAV1ZoANC01nGbxWGB6AUfBiTzk0LDw8CQdtKSz5CN03/CZNujE23psdbq/75zNNve7QXO31/z/hul6IvGQ7B9zdaWwI59ZlWU0sxniGhd1sbXl7lrWcqVtpUwpPv1meqGrUjU+8sFUrsugvtn8DrDAwBCl32PNOiLxqRgZ+YAKVA9JAHh/eJLuQPGcRNJqFbDqq6zEaSjpheHJTetv8OYROTT8tVMlRnf7ZoR+FQvSjjSY55/rvxVMQU1FAwAJCAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAABjrD9N0w80Un/nqVFnRm6MAAAAAGYD6t6rkorF66dsOs/UQU+nCjkRDclPQ0qUcZrVKaVeJGw/yepbTPGlfXjJQm5BznP8WRfGSiT+0rG08Y6pfMkt4ESl4MJ5EnomGPv7TpEkeUWRyloJPueYNJkEqmXt0u82/q2MshZZWkw0EkVGqsA0mocUAbwymEpnShxcokMsCbPwQwQRAJOSFny2Rsr5wgCy2SwTlL4Fddu7jg1IgdGrbY3/bq6zbL5ayzR/QuPd5SYIAITGponMGRcbu2zA3qfrTwwxDsPRq/iOXYMpRIRFXRi9sspOkWW8Wlz4uKn3mt+X3/0/CqTQbtpwfMiRHJJiCmooGABIQAAgAAAAAAAAAAAAAAA//t0xAADjgT1LkyYegoTn2TJrC4hABcJh4VspcrJAR7auwMtwaroaESrR8MM4IbNFdGw0cgPgmipdDtHlahNQLglQRQiLUDLWiUMag9rzKHwep4Ez22ZJLIIhqhjD5UZAOSsscdVvQIVh1qbZbnVp8Etl90+TQu7QtjKPCahStMTFJU/9LwQ08yzTBgVsjp9e6ZwObJYgQK1Mxr8OhonmJFGLYkW04902g5N5b7EpXeiClTQy1UqDmNsvpgzCVqpDPwnY0xDEaMYQhLxCBZsAMaJhKkFQpERseB4J1YrLXQw/Tkg9r0sbe3t2cQo2HqXxMS98TMUVnzN1cwsbTKVprQbOd7Z9b7RdhZMQU1FAwAJCAAEAAAAAAAAAAAAAAAA//t0xAADDoDHJC1lC9HyH6VJnRnpAhRUBHgROAqM2rg16oiFDgIHSiIoCQ6QJkXnigNLG6KxEX/OIhRMwxoVQvFUa2qxVhRQbQbH3ckMNMjZjBMAsJEhV7o8POODmUSqqiC4t1mD+wz0MiwfRB6+Mmoqx6k+1Tf9wOgeNXnah2rw5sBIHjoVCG4AawYSuUQpBwpgSAol14fIiHUS5LsAY4z7BJwSzRQDEzsnyZRi8ECS+kdllyfQwCJB5ISf9/H3ciHm9XWno8aP7LFBQuMEIGmfWHHAZ/T1Ysekdlev37c7YiP8ye8lBtKQM+O7yxZ+dz02yM3tmbF7EOTTCBGe5fp3kWtL1MQU1FAwAJCAAEAAAAAAAAAAAAAAAAAAAAAA//t0xAADDnDxMmyI2snpn2XJoQ9CAAbUAmDEMCzx4UDIx2EEQjO0rHoUUbgZxxwbHMsaxCA0eALBKNMpWfKKkghtW9cjAJapTGqWwwR35iNvWAkwaClcMBHIYd0hrniw8PUCvOUFkMLX/GiCXZ9vDKlwREJDgJACrrW23RaCqhRuTyIGqbCkkXAEYCAkigaBMdwweZ0DyqOAhH2TDg4IAAsarntxmkZr8W4rcMhAgY/MHyyelcTaE5S+FTOZAMEsUoVbk1mypQmOEGLGF5SUArgw8cIgGNAtfks279uSFQW5fpT3rPs3eFW4FIav5zNhJCC3+vokWsSUiBCAZlhKfeuHlJiCmooGABIQAAgAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADjhD5PG0I2snonyeNvJWwAAbnAb4FJx5kYIwYAie8e0FwE0G5LwTkGgp1mxNpRXqvmvt74fhypLJ5YRhberfLcMpdqlzmr9M+zVC7jJ1giqVDkZpiBKAaa58w8MillMx/+P33+gQjIVynkoqMdmZfWyzrOiuHWWMOSNY/wHz2IdStAwAhgkZAPmEhhlCOJoYCE13JVTClTZjMZcxEaDFwtQzZO16VmySeh12GhCEOJOKWvJQUCDJZ2n7uWWy2BuhpHmOIKonh4Z3bYFwM6k6nnhgXaCb/7LX6+5CBw5TEmRWEBNMimOjbm4wokHDqDAUpjnOHQ8ArUfX/WmIKaigYAEhAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADDvDxOk3lDYn9HmeFuScSAEIF4mUAxgrYMsplTqZc3AgUplaoDR+CoGZRtjaciaITUxl+x5W1yKK3G2YjgarxYQuQCTlXL/73NrsiWkMWHUuHkmAMORGXYEGGMEXeZoyhq0ux+Acj//j96/9PiqGkDjCPmxpBlNNWox7e5PP+XvmcejC5Y/egEZUFhEx9pMAnTYVc9ISHpUwoCDCQwgKTuCgUQpp6oiLF4WAgUFrnAwGzxejuUrDmUImN1S4WvIi2y8KGJS2ej5fcxsLXgDlwy0XMfGASiAOwF4ABEFpPDiNklOj3/qQ/TPddGX8JbXIydGTqGHZKpdRH///WQJzras4tIBORJTEFNRQMACQgABAAAAAAAAAAAAAA//t0xAAADtTzSi5oa8HqoGwpgqcTAR23SL8KBmUDycRSJEOB0DFYQAQrDAIKBQzuc97I3RAyiJYqmJWSiCq74tPdeBICbxyGXAAG9yp8WUVWCPIo0MzzcoDvHgwsIgYCLK0p1p1R+kw33//n/vCL/sL0eoEEggDp2RoFNEeMrJBB/4gKHR2IQEBs6KQAAQAG29w/zxX5hVMfA8T4M1HjP3DZJEaAHSUPa3Ox2zBLP9RKSYWb83hL62qm/1pD0uyBUl9WpRoDiBL+l3hMvmcs1S0VnTUJ1hhEAsV0kC6KbM5pWi63oouZhk7a0o054NnmCMDYhclPFvAGIiv/jk2aCwipPX/5sVMQU1FAwAJCAAEAAAAAAAAAAAAAAAAAAAAA//t0xAADjqj7Tm3E2In+HujNsCdJACAVAuTa8U4zBBI3YgMKPy15jw8RLQqBL7BC2ZoXnBDJqSkIxEoCCILIgNPBW/BqFPavRpMRZTc1mQzAL7Msd9UoXIQIXmNAwIcpRGAX47UTx5kf6n///7uWeCxu5W5/6Qv/7HPmYqS5KNlyB6YIs8fZCw3WwYBKlnNIGR0wiSM8SzL34UKSwlDyOZkBoXiFvAQAFRg6ECMsY1pmunJihMVCoMCS4DgN7A6gjGHbYsAANQF9GeM6ZcyVHYxwXMLWzWDQ5B/MoAYJIgZ1YLpqbfP79TJCqIMmxXmNPlfQIG9hHx8a30KmVWVBJIOxgoBYBBMZQiExBTUUDAAkIAAQAAAAAAAAAAAAAAAA//t0xAADDvz3Tk0oeJHtnapNpo8QAAHJdxYMGBzAoj7gzMNTBDhAcByoWNqVmAJgEWClZ4PIyaN2BKzoVLiMKluu9WqhWjViCl023ONXH/ktEsxW0kPBRqZKEe1mY0UmUAkNBwf2o0/////sABEdD8G1kShEZDI3/gW5/TNqAoQdLv8SAgCAIcEAQBM2AGAp9qilqyASLBZ42pgFEgICX+qtUlosaSSMLOHWh5USLaKyYLd3XfjkNwe6rTYhBLXJbRQXJ5DaLhAJKPQDLKmPryB/E3My83kwy6SSSSX///gJUI8kpfYBKpiSJP9JCNXHBOHhcEgS/BUFQV4lBYGgaywNA0/waJeJUxBTUUDAAkIAAQAAAAAAAAAAAAAAAAAA//t0xAADj0T1Rg5k8QoSnqiFzJ4gyYumsOAowGdTHg0NmEsLhcw8NoWAhi8IXAACIQCFIJQYEMRq9CHMgaCRmSihONLnBYjslo17orNLggaYgJuzhxqwgJbiJ2ARM5ZzmLBwRRenMrdT97/+hrf//p9BuLAQHWHywlgXG5R5xxlDdUfuqIWFAkjc2NVEg1CRurLgYCyURDIJOcA446CjBY5AA4DAYAg2vBipZoSFRjYQGDTEIg2bnIQjKRjMdD0MsHopS35fISSETKYA4UtVEmWNHT5R0Cxhc8/DAPsdBSGpwmhCTNMnt5+qTAkM6Ef//+cVHSgjA/EU8Tg4cjHCI3HDnUu39jROxQHymg+GQWjo0bUhMQU1FAwAJCAAEAAA//t0xAADjzDpSC3k8RoSnmiBzUE4Ai8xQYDguGGKPh7BqdkdCIWGSwIAVLmYBQKaMiQPJQhKk0wKJAoVNRVzCFAKKQU4KAFQQDDobFu1HFpMqU1eGEIsRExIzwcINghU4LAQWgooPGZZl+pds1+Tbm//bzxoVLFVGg3HgcvQoce41MZmcznkIpHFcRxgkXgJYMEgcFA8wxHAxQmAzmYHAxhwjBwdCGAMFr6L4CxsxgBVACExbEB25rAgAFGNXhxZ2HuDgxnSYGPGKOCMqvdKhlZKKgadFQxMjPfIC3Az7AjqGHBAajNClCGb/y6/0G/3fUkUzU0PFcgR5JO6BixhY1MjZmOnU1pOkyWbl9lGJudBudSmIKaigYAEhAACAAAA//t0xAADD3z3SE3pC8nTH6pNpScQAEMILViAQAQhZU8h6DNhEASVgUYS6UtaoIRLXIbZ9KjMDX9RYECE1KYDADQgXUkZhDY4JQ2Az0uQZwq6TWmrNq3iwJhyp0gxin5rwxihIc1A1hmFNSd//////9v/1xjtUVA25EqhCsJ+x4kGXy//a1C42uBaHMNPMOCHUgAVygVYERXJCIJ7HZHmKBF7FMmXQ/Nuzblb6tiZS1FEdCcjusKUMouyNWlIlR0MNrHUIW+pKG7zZlqokCx4wgsMDF0SqDBwKIKf//+eZs7IeVtGX1NYleIVGUT//IwBttGrlqb/NtAVyROhRDjRRlyaNvbdcmIKaigYAEhAACAAAAAAAAAAAAAAAAAAAAAA//t0xAADDnz7TG3g8sIlnqiJzaF5ABZEAjytAkKJmGHwgPmyQHROkDF1rSdOymlzLnGU3VTXoxAGBaHcIapax0QKIHqlNyg4LlLDww06symEKwnrIOab5FkzeJDN9ZXP5/hzZ5DMb+WRq2qyeeQJD4yLh4kNfYoKUO6Nx0Wtzjwyeij4+XF5OtYAhAwou2NGoKGowY/ge7wMVjBgTEQJSyVEUABDdpFxwXcLZJOoRGHjJgaEZFTER0Bg5N0IVyAjj5oBCPH5kIIvEcDSIOflwRkCFAoDSZkaoORRp4AYIBiIUAQEXsenDU00SVBKf7Nf/zTfzfK1XxRzDZ0Hj5/Ik5xuQY0GDVyHt5LNDkmEs6EsClMQU1FAwAJCAAEAAAAA//t0xAADDdz1UG0JGkILnafNvJV5ACsmAj6mw0lKE4xwD5SWD4ODHXQiLixfkglU6sDFkJ5fQMHwBDyxWxKXRdM5cokNd1ksXikZguHkM28WBSlEBUHAXinYP1hhzwRP/2MvqBDjfLQ+eFfU/hB4oDQg9Jgp4lRCEywa3g2JkSFAuV8YAASYAIg8xweOZqThnIanwsVAkNLaAIXUOLyFul0F6oNUpbo746GlaFjASCIJwMWreRPgaw1s35BTgKWFUVaVzLaUKXUrlGdlBwoHrOL5HnMebZoiAQO0+iD0P2ft/++XGEibI9wFEnHZEJM4CiIAnRZiCws8Bg6HjrioINCoZwSEjKExBTUUDAAkIAAQAAAAAAAAAAAAAAAAAAAA//t0xAADjyz5Pm3oq8nynmfNzI15AAIVASUNWMzHKwXOzG/cwQbV+w8WCFhmiJvNfSBZYqRJx7kfERFVFKxkKNBhQKAUJzTRmDRgyReVCADF1SLuWPlaoy8qAwtmIh4CsBjUGkTABEN4zEWv9z9H/+jL8Ud01YxRRnpXqUREw1+Q1SjHaW7mdhURIJmTd6TABULEwVNfIE0kTTF0RMmh0uipBVVIRaamqRpaViMeScEhQcORWsQKhoFECFh401hw0YHwmcEHYmsCMhrECDwwNXcIf9noJhOfU9eTlVixqALqUyZ21+D6P8jFfC/+ddr4REMcvYHwEWd2JBCIo4obKT+0rPwMSZuKEQ97TEFNRQMACQgABAAAAAAAAAAAAAAA//t0xAADDpTzTE3kq8oRHikJzSF6AsYIaEjYzkEFEggBTiU0IHggJGhstWvp94s5t+KP0yDBLksuYDx1XIBWdkwZijAk8QCBQkyRTCEHAWrpgSd0kwDBBBKx5GAvAX3MR4takgwOBMLeczD4gfdW9OVltOKA7dT37KO0AQOAgot7/d+p3RQ+PDioEggh6UBcDGAxeCDHk4NJhIiQxEEVtCEBR1a1CzVtlbXIbKOA0cSy5tiB2aICVMMEA1CIxJ8xAgPDGKDmZMjwUVAjTymgIucYYeYueZzcFZB4UYQNDMzKn1ZDhvBbE6HZ5q3P///kt68z422hI2UP/crUFAi2N/RL5Mv/uwsHQLADhwhSmIKaigYAEhAACAAAAAAAAAAA//t0xAADDszvTk2FOloPHumJs7NQAgAFHS0AhEzEAIzWAMeMBo6Y4PCCVMJrO+zmYbPPshWivFeQGLzRFYWO4iobLlZm1Q4mEDQKFi6ocIAoHguBE7wIKmHkxYCTF2oz0iacv5/4hLOfcl3swC/7/1/rrnDMmVIZDPo2UxG/P/TVZ0y+z+6XjOzYuOBpYQwGFJh4kLBZkuWY4KBBUkWh3LrMifi25steVTtyF0tAHgAkFA6WSBEhssqX0MCA1A0TjBzorEDDgEaQVAkjFRBAKGEIABAEzmgMYXKx0OQXQ6NvLKPdyHMSbP/7+v+pAeUoxZiQi7j4EQSDUdmD/+uX3LX6qX/qdGI98yNjpKtgziYgpqKBgASEAAIAAAAAAAAA//t0xAADD1zxTk2JOkIOnilFvSF5AAYEXkfShJMKEzHLs0cST6TzLXMpdeGIaiPH2jEGLhhxQ0gHTCm9CpDZnBggCKhQWDGSGCjBoIOhUHE1ZDsikzAQhIgMTHmEQDRloesCJB0HsecXDVNH74gr////6wjLo2oR1M5GNqiIVg6P3HPJ//W2p6l6RkkJqk4sFiiwQZg5XMJSDXJo3suGQdNYaJHoSncJs7Z7zcVgncVA1lWIwhAzhUSrvwBixQbMUJMWOCqIw68/rQOPmWVpUq0sbCAxjygJuGonGH6GjLl+CZagEl6cs5tgDQcgVGX///FfxX8fypTlW49jDopjhwqFQ/R4pxa/GCMI9EEkksYMMF1UxBTUUDAAkIAAQAAA//t0xAADT1jrSi5o68omnqkBzS1wGBDuChUYiCwGKYitBiAGBxvTxQlJLJ2pjLHaU/0Ua076aLxCocKIgieA1w0CWKKsy+6AM3JU0gAzF0xZwueZ8M7gsUJipbY6h05YE1eoSJDxgaIrSad3DczG7c//mGP/MPToQQuUQ5TycaKKAwJIPz7NdH3KpR6FTSkIqAkwgFjCY7MdBIz3IAN1BI/iwPBAJTTS9U+rE7cTdt+omPB3RAgMxJAVKjJRSlEszi8ywMwRQ6qoya81Uwx5IxpUiOv2g+YIAIGhzkQiQGy1jhUwIEC4EY/l7kA8AYJJHd1//2pP//zf58qyWqn20PaCNJLE4Po/LGNIKwqdzGziB1ZyiFrlqS0JiCmooAAA//t0xAADD7zxSi3pa4n7HmmNzSF4AR8A49AJsI2Q0VrPkLRYmLsEocku3WVssbo/EceZ3lLKZYBBYWbnONq5GDIIAmKBgIabhObR6ZegBnhnRY1RCoNRVURiyxm1pso5irwQOBQYCQsN6hIAoC66N///qtf//Nd/y9Z6dxlyCNGy4eSoby5qE//quW4Qckfs1PTMAKAEAm8hzFA6YRLIJiZnAOgYSJPlQBxJl8AQzAMQyrWmHxJF4v+HEjThZeIApgQosYAQkSTAyMAqxrBJiRidYYQTALfBx43K4yvodnG2GBxseHqcQ/KP3MxzgupZv/4xab//4/yTy5Fzz8JBlpKlFgKrC1el8jSrl2okYSrFMmIKaigYAEhAACAAAAAA//t0xAAADDj1X00dOJJ9nmgFzb14ACUAABt0C2x9W4uaII7lqtoJRSX4pF7ndW7NzOap20kNuyw9/4XGyqCg2SuLBMPTV11UGX6RwJhDYgkI0//88n9v/+wdO3JnnCq76OB2xQYy15JqQ95rWKVBYRhQUm8PS6AEGBaBAcY6PZgyNAzzgbDGFxaYKDIUDSFSo1hQgRZkziQS1S4VCHgZ6SjhkrKY5AGNBSCUaVTMiQwo4GikUKDrxAxEgMSlAIGBUfMsEjBCswBwMgKTLGgG7Jo62puEGqfzzQ9I6kBtfnolM////1bmHxcRM6/xT/Nl033aKqJ4XATNDko3sAqkan2JoccQoVrbw+V8aNtw93zi5Rtsx3SmIKaigYAEhAAA//t0xAADD1zrSC3k68oMHWjFsSdJARoAY6A1QMzVDVKMBLRjYAAQZZCXdM27rcnX5mJW3BgjHQICZwhshFaBaIdJeppifB3PmwcIDDlMFpRUND0lAOF40vTYFO/o0IkJYO0lDE6WcykrqS8s3/VnfN/4mKg6FZolDUoPDhs8uDsHAHWaOkehpcclTzTxYe4aIA6KDoyCWUyWzNCfzfiIiQSEHUvQrsQ4slt34duJQdGGSMXAoQAVAVIgMaqpJMjxCLCIY3GBiRiIcBCAwsAKF5aRfMRhBm4WAvYzmaMYKDjAwBGYVBRkJeSXXr+LtbL/6jmIr6f90B4jis8A5ONHlVBRoN2A4rXY+qMf7SLIMRjSPBKYgpqKBgASEAAIAAAA//t0xAADD4DnRg5o68HpoKlJvKF6Q5mXQIY4MwEb4YMjlgyMUhEqgFdY0HmArklDzvpGNSOBWlLTTsTZIpzJRCInwhiWkX6GOgFRUfWwCjYGGjJAADBExFBJ7I4h3mWEgIUCQSbEGu9a73n//noPea32SGxZEoHyjysw4OABBMDyo2cwamzTmDy6FyZM8NEtCwIDBBkzAYM5CzFH03FKOYLTKgJQJSagUAPo+VBRZUkXd+ONqoAAQRAGPJMyBQbDgYEjCIQiL5LxLQtsj4k+X2HCx601SgBqgPBxRaFlVNd/PON9P+v/5mnj+r+L/U816OCos448jHMh4TDT0Hk18qh3dD9YhdG+GUkdCYgpqKBgASEAAIAAAAAAAAAAAAAA//t0xAACDVjvXOw9Kdo9n2gJzSV5AwAe28A+CCUGJHThLiJ7jVaOQ1apmh7aAtPczGQAunYY8E8MIQb7YlmQ3knHdqdDDgbFUh6SBYsSz9lF+lFMl8f7pmG/+G3f3//sldcqiYRqvRrFPY6wPIJpP+f1BCtlM7wQDCSWYCeKBZwBHBEc2CKjCj+MGH05mGTCxIC47AIDMOgcFD+H0dkEqTb2suWiDAABHJHrsHjJjViCYVEGcIlB4gDhQgZ0kOBzCASyIUYIFDAsEkQceEYwiXGNSGVkHDRIbBUCwvO1q9Upvz/////alkfF/jHfm4RLpw2osKF875O0NCgVk0k2YZSIiIRS718NlcjcsjBt2SYgpqKBgASEAAIAAAAAAAAA//t0xAADDszzRG2I2koSH6dJzK07ACZUAFBU1gyN1RzLkYfEjcgkgBE60ckVrCZTLVLmtN1ZClogazV0G2cFYVCsMGyYdfdgiejJ0oU00fVrMsVVShQSgkGeNDJ0kbn0dly62L/655f/YqBSxNVEK2oLSLiK2ogdHFsCkSKR3jfP7Rn/tZ3eOWaJ2sAAwCAaGplOcKd5leZG/wiYjHoOByvQUCg4UpHEKwNEPYYqGq6VkRxBQTZEP3DhZhOgDUnyOc5DuSKMHCgKNbO1JK8Yk3r2Fz1gBAIDjiIEoCAwI4AhMQLjN3///7oqY2XN9fpUYmy9y63Ep6hs6mnyaQ9nbRX/h1fFuWaTZLJKUnJPSgqYgpqKBgASEAAIAAAAAAAA//t0xAADDhj7Qm2I2kIlHyaFzRl6ADbeAYkRmxi/8MURzoiShhdddKVaZcFpkKYmAhaDElaVTLB0DcWsssGQNOIHDAWG687DC9aOGmhtiiL+Tz0qwNbjUZf9llSM2MYx3X/vrpBkUWMWZ/zkpajyNKa1yXJpaIRCNN/+37N/Be4OUvkUWlgEEBZN+Mo5jwTQEgPem80EJQgeOFBgkGi/ABFRhAJgNTqC0ACDQQMU7VrWOY8CYpqIQ4YoLF8IQHIMCy5AwyIIHBAwQIASwqhbD0qhkGtQiNlQC6o0XElsFrCxWmj8pg/v//1f739dFnKytuX5boFOYf9TLoh3ML0MWopv/++67Xu2hWDhLOopCExBTUUDAAkIAAQAAAAAAAAA//t0xAACDIz/VOy9Jdo4n2bJzRl4AIALJcAwgwizMXLxE5a911CPuKmEQtBjp964qVIX3FXayUhEaKTPx0W1GGE14EUy4bE+1n37/vzzQZ4er75TVu5VDfTLF+MPFh93L2uuKRMqcjldJ2yilOdU2q+SMSCk5Ik/fSBAYGCwqehNRjztAJ5AefmKRNJRACSsUu6DQoEAUXxGU5GEhhUCsOMIhGAroDXRQEhBY0aMQ9AcoO0HBQwwoYeEAIeYgUnXGgwevpFFwTNEQoUBAYDJzUITJtxIamiy6BGktouvJ/3eD87mo9l+/rY9L+k7xXQ3pDBY/8u0Bia3Z9j7+8309gqGXAgtZlaUxBTUUDAAkIAAQAAAAAAAAAAAAAAAAAAA//t0xAADDfD3Qm3ga8nkn2dNt5npAFRVABgOdkmGbnBnwKaGUJ7pmI8uRDtkwIHKigS1EFL5mkDrBTNSHZe5bAis5IMSK71yHmDMTbDQv+5Kqrm21P2GDJFRNUMByWrfnqP0+//EQiqXax5lUsfo8uTw3IEg6qrKX98yraCATjgAsNsxUARF0AArhkNKZBVmIPJoamYmCoClM3OYKkakSDiVL4WFwUCoUoPO9pKgmRmmqIcGmfSYaF0dg/kWjkakkPPg/jKVLpWp8OknUKyFRY2cze8XvtP0KvHSvs2fwnkJtOovnL8RZIJFkhJHMFbHcitFy0BlBbhoPfCcIOJiCmooGABIQAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADDPkBRm0xJQJaoKWF3LF6AOtuAEY0/LAQKEkw7UtIFVg8IJmPovHMWjJ+A/OaFVGuFycjgYbFzKBKUpQY6rJkpE/aM8zn8fvYY/YZyS4nI1chqyzH6UMPYnNJ3bVje97cEaMsSTgj/9Lz6bmky5vraSJBgopFN6gEMUC5PXisMOxXAILGioUGBgVpBINpiMjDAdLJj2R2BAxhBkkUJh37RLZ+00RorREiQxwKgoPIbl9ltobEAD4Ok1peLXF8t3Xa6r+ISkJbWF7QNfafYmO370fLx0co32x0jMi4ebadbpto6ryXDz4/2PYiMW/Kr5ffuVoVtT4/npqXo47q2IQmMkJAKg/ri6aiLe1G7u1piCmooGABIQAAgAAA//t0xAADj5kBME4xNIH0ICWN0ydZAAMDB6UMo10yEKyESmjxcGFtONqLsqwugFgWg6huySLsqVqd+LVnCaYzRtV0uywJ0mdA8NYBAP0cXJxxCUQol4oMFI6IoSOQhIj977ELMbsfKLo1TKyBfzn/vjPlmCbY+DSle0sURbP0nef9mMU3rRiDsw8TiZFiEymm9iwYABQ3OK0iMVQ+DgcDFPBICEQHFwHvVtkmLwhwJJAN1SETj6/9R21eP8zpMxGpkT/yhvG7uA976yyI3GfssjN6ZgplV5/blWHZTP3TSt905LcMuQ4EOJPb1//6kGyCRWfnFotiIoPIKZjG4a3mt5s4kSuStw2SOV8WpL6xlTEFNRQMACQgABAAAAAAAAAA//t0xAADDvT7Ji7gy8IcIqTN3CT4AQwmFE+YNAxoJslB0ypAYSChqJABKrF/kIAJ4prA4r0KRdYmQpQpa1RS+GHOQkMwYjTL3dOGGHOG8r+utuL0cVkU9I7isHKk5WrTsBVD5/eEt/OSLprIpFxuX/hAfGbVq7mYny6W3RNS2M7/NnvuVprkYiNLR1yYARBgBg+LRxTD5geFJhAFZiENQXB8OBZJwt4lqF2O2XtCGrZYQiCCSuurmHYzA0FJ/F4mEqHJyKDyl1HCrUEBliopLGNWgE4Q26KCdAhMfxKhb/1RU8E5JmFZtbfrpppH6YarPCEqkWNI4c/WZJWeWobtmFNMjoIilgQiJU+DDU3x8J+9jqVKYgpqKBgASEAAIAAA//t0xAADT4zzIC7hJ8IAH2NF1JrICAqmWaHbkYBreaSGUZuhmIwUMEwKa+s0YGOnR0QcBSgFVTxfYSG58InofeRyg4Cmzr2Hsaczlnzzwl4qa2GSVYiSLAaXRLauqQIUpfJo1f/9Sb3pLZ1ve/k0Zzgvrq7Vx806LKLoVY6jTzYOqMIXJe6+NCgNmrL83u73c6Iw8KExk8EwuZoy2IQw1GQLgwLCyOBCBhNaDFxCBRafMIAp/2HF0lXq6wbgtRizCmtRZhBfpBpWKpEZFLI0FTJ56iMysGVWWbOkL3sp9NtHXKfXRNR5K8mfTYWGfOmq8NVVzJrEUShvPQecLlcXOFO7eKPMLWiJm7sbdYSdTxGxaYgpqKBgASEAAIAAAAAA//t0xAADDWS/IG29LQJGpaHB3Jl5AbkRAMHYTR/snRTHEsAlBEL3VBUN4Aae+SDSayokKYSbkKNXaKWDiLJInBMxmAo07WQ6mdJY+0tmlWGiuYROWWSdDXsET5v1iCZEtFJbdjcIomw/ONKnfFeDCbckRoKxIBSN7gqZWl1NJLeYUJ2eWOeaYIyYHhoYUg2YvgwhAnaNBwDg7CwDJigFgIZJszkKQQJIlBaeMoVSJhlku0/zaumjynM8aP7HkfZNQS6Ks2fiRz1eWyqN55U1hu0b8kchqnK9akXLmkChtya0J8s7DowajRZor6a4kUbUdcM3/bbv1jS1s+61fbuH+o6j/u49d8mdLetl9JtD3QH2WTEFNRQMACQgABAAAAAA//t0xAADDKC1Hmy9JUpXKGHFlg7pDWrRAlho5G6smAXzacgw7SoFOM9VBcBon6PFCDcLaeGzoKDqEBj4HyMtGBYobcHypLEPzKJQVV1TaH3kAKljZYsWe6B2Srj56QoEUuolccZqcMzL/Ntt2gH6NcAbYmWw1en6ftwUIyARg5td6EJtdhhZCkYrIMSYih8ZCZgBmAEuVkIkK2sbykraCU6CoiRatA8dm2Ur8ct2m+sl7UMrQLVTzb6OP3k0CZDUIOsMl91txD+V6xaD6AxltfU6paRnbqQ8TrOLB6dKELk7DR2WHYZgdlhGqOrfGetcRsMLwjCQ7ClxQzk7vBRRvPxMl3rk4ZxJBQG5mIV2q/UxBTUUDAAkIAAQAAAAAAAA//t0xAACDrC1ECwxNBnZl+Kph6ZAEB6UlQ4KmpMcGQChXgR9RoQ0DskJW/Y03rEVNoMp6z6MOQgYAm81W3NRsaRjvnTguwqOtokMUE2+pNCKWSOjW2hMucki9JbxkGanDndv77S7UrTgw1KHFwFPxLYxaUl33QtD/cCK6BBSfCBF7g6j/Im7X/3fsIy3IgAMG9aaFikQkgnvWO/L9ION3Q8SLRxpkPF3tYYHSSq2IRPYSM8k6Qp2FzwokySCBQjA4jiKBYhapy0GRUvxgfkLyfcJPPIgZeSiuZLKY8ToworlZNioUPrnXQVp6wIwcTLwmKhV4hKT5Q26s6uONr+Gt1iYgpqKBgASEAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAACDgDpF0wwb8IwqeGBh5nwAACApRogDKILDig37GTsnjCmUOv9Lm7s5TBphlV8GyI6ZkAp2QlEy0JDSJGt91nykPyeFWkgtjL1vjOWTVUtS0xU3yeiNbdNZ5uqb2G8c6geFQQphamc0JjGnC7Be6Ph8AOEBOfFE2KTCF8yUUpFiaFDkbwCEYkc4kb9K9cyIaE9zEklhk1i/wNUX4NSVe0fBLhkhWk13NeY1JcGG3xGlcNg+T7u3PYsZ4yMLZeJdZr6xb+DPeTizUAYfMUWisk52JxyBeUUMPAuRcRJCVHtaZ6cI39cqFobYAIj1WRpAghTZ3WQ0+7KL7nY/zS2u5Xu5pX9TiEmxUYyyG30JiCmooGABIQAAgAAAAAA//t0xAADzvk5ECwwzwINoyFBhhpZEDcQlEujbJ06k7mVgrzLiICPqSxOZ9RGRnY5Bi4eqExmTT0mjs24Ddd61p1ZPloy/Ek2jDfL1iB8lmX7KaTdlFEzyy4q/nQjSPZNmTxzcJGOdjuUdeMxeQiunElJLRk0rWmqelZZL/N1BreveVrafjJFWi2FUrcmWw2GJdBX5yEgIACVZxCRXSEYraDFQs7QAhcjAYy/Kj12B4sQQ9E1SWB+C5arqnWL/8godF5wbLKuPyytBlDMJDT00kZNAhWEoP0sUnbcQuLy9O0vVsu8JHoFEn2Y7Ge9OuPJaq+S8xVXH1ulVl0Vz/XBAEt4paxsmQgFyXEzvW7/na0mIKaigYAEhAACAAAAAAAA//t0xAADTsEzDCwwc4IVqSEBhI7pECrAzKV1rjHjKBMPfpFmXKgcAOPI3nWHHgWHJlqjUZ3NwA3NozUJTV1CUJGECNeozOVWvNOeil55xusag6aYbp9V+Na3D+LcdZxlc0jYxnq+lzKQWZSbSTL+w1Nx2Zjs2KXbpRY9JShh3+kYghcQvHKz1DzSaIFZKu5pAYxFASi3wWdmQvDJhiEQRp88QFkiajetMehPF36dlEm5JYPpIbguxDr1CsmBJACQuiGypC9bhZ5Yh9rRTmxUkDD0DLdSb8Em7gnPDknkcm+q30R5tRIc8aye7i86yu6G9KUoNxKuriqebCnPKNqjDHbDvebADth8qRaLwqC7jPgJiCmooGABIQAAgAAAAAAA//t0xAACDgjBFOexLMIanyVJvJm4AECXGQA2TEvELhgNBggGbSHkQNyHQEkczMeSOVyJGfgzMCwOZkH6RajFbDpDYGFiDOVA2MDpIfJLprKDI4NoFmMX5YgIqCJ0HBxgnakNCpYkbRtIzaqS7XR9Cq0dXqpKRc4+Izl2QqUJ1j9/WQL6ukAEgBgWEIZmS4blDHJTxwCcEIDWGIM7eByKsbrUkYsSRQRsJKEbTRMQ0NzW+QDoPqLA4QQigY9p8TWHRQZaBRwhMwmh6RLI1tDwIAChpGGIIa1x9XGsMYwicDW4E5nnG7+GucPTMCHt////3rXrNaHTPrLT7tJDCkIQ/7RHe7Aa0+x5NM81IJiCmooGABIQAAgAAAAAAAAAAAAA//t0xAACjwT5Pu1ha8oQH2dFvL14AgAAAoAzA1So0qY1Bc66EzxNEllUPWakuv02P1sf2pjABpirQ4bOmpOK268lGSJiXSqEPtYhllafEFg6QPSr87sQGiE60FIhgmbKVNKjIEBzuWL/wWMe/n////enLskEi7trrTMC0dbzc//ai/T7lpu1A2OnWQcGkEYgAWk0/pMtUTgxwABCJksilHDk7lRcuz9WHovCFHyq2GM6QrWHVjYCBBTbREokBSPbcHGrS0s8DmDAJOMs22jmOP0w2gDLGBVKEk6Rwu6VAKF7XN9//HsqpXFWarP///6+u9YuzZbnw7Z9s7A+q1NiFq57G/+qXjxtVvfwp8yy2z7TJiCmooGABIQAAgAAAAAA//t0xAACDsT7QM1hFkIboChdvK15AgAAYJTg8Mf7IKTT0mRaQivTwLftVabOxyzG4GeFcyHrcwcAgCEsiut0TRMEFNoeTARKSPgKmk8eLiPESAZyHpUsAyo+kKwAcEIQGFCKAhwY//4wK06mxN/V/69TFmEhGIR8Vmn0YJDtv+Y3rcfGwgtBawKEyCAACDAEnTRBA4UcFkQ38cW2WgmZfjJL1S/PSmrDLqwSjswo0EQ4dgSDQgBT9ZUAASX4GjhYAKCLWobsfUeXY6RAMEBvUPAhQcgPzeZO8dMLtPaDgnuv/+y6eS/i2PtS+GfdpEpdMYAlGx+Txka0UHVq//bJKcYoFB8UB3EEZkknmhBOJtpLikxBTUUDAAkIAAQAAAAA//t0xAAADbj5UUylFlosHugdzSV4ACQAANJwB6i4JwSgjIFXDwbB7Exycu6qYZ1KTPLNSsLkwfFH9YWwx8RYtEaBmmZxOjhAwVAsVjwoYiJG1h8dNWaAMd3pXwbciJdxFe8rUwjaxkiMxhGtUIAnFQTEnX/KUoq9nIS40kORKDVThvAQABImAMSBTrMvsQhgg8dBZVkIMcdjEjgaWbjWMSgOWtjXqg8NKQRXA04vOJEzEAzMFBwubZQcACQHysctZxl8taLwFw0pCqbM6ZKC4EDq8Z4zV1k5m+GgSYkZLSnnEDLv6lpkhJJbn/T3+nM7SU6s0TEsIGl5CBwScfzP8nrcIXPGiZCqStoVNpWpMQU1FAwAJCAAEAAAAAAAAAAA//t0xAADDmTtRm1kq8n8nyhJvKF4ACRVAIA5lxRhsoVVHiDgUAAA+LSpPRy+W1spDKJuH2CAAIcWMTIPDYSMGjDQUMVefAJk5AolBOyeVVJTjEBEmv4xywE0NNPKmmnRADDJxncH2le85W0IQYhW+/9yizIPccOZHkDwHDCl+x1ZuMGRuBngGYDDgrCBsAxyWMdhzmCFKQw8EbAlRD05KH0lFNLm5NZQXbY4SSHULtFFZQSCiACsACC0Z9uhYIO4bIHGudS+vFLVIdWofrBjRqTiwS6RC2mmrsDDkIkSfw9H0Sb4YcQgoIkDq/7/reTzy1VvQlOTwuTHL/wYb6cB0Kjw/e5G3SOTEFNRQMACQgABAAAAAAAAAAAAAAAAAAAA//t0xAAADaz7UU0JOkI/nyhJvKW4ADQAABTcBRYLhTInRSGHLcGuxt/H45WpqDnK9R3muF8VvOX22qgqZCgaLuCpB/YPf7OnpIYsT0UTERdVy/liy28RjDc3yzAycP8WhwN///VRbbImPjkUMKz8Zj5M90Y4nCOR3+fIHquLp+DpvUAAwDIWb6IGjAZgOSCng0oUCoUku/ClsxCIw16BX6S3TkFgSYALpNjRtg9eadwFCDhzUTMJ8MlCakrnWbM11sLPocQjQHg1Z1CuAcNCoIXHFjjBCTdfsEi0jaqWMoYg8i7HAnrGFUiEawAAMEmVWZ/+pExNQRzRriIUEZG2XLW0hWa///ys/xfIo1W9dLpvYpMQU1FAwAJCAAEAAAAA//t0xAACj4D5TMyxHEIaHylVh7OIBAAAYIMnUAY6RgXhgBoEsRdmko9S3Ka7ZvMQaikFEJfWxpbjgP4nMyOCVZqkORTCV9lMQfR0pYriMKQUfRHCxSQIFDEj3PBoKnW5596zOLV7dJFCPB023FM7NOmeFYEAYOMwHZXLTxPzz5t5MM/l2Ss+XgyKH0WGBxLDioAT8NkU2EeQbBXzzV6C9zHDWepK19oiqUSmMuzcbhhwobf9rTBZ+PxncodiKrTeRZ0jaoPRl4AY2Ui8Dgu4PGi4MGriT3IFbC3WC5fi8QuKPHWPMXiqjx9XhIWZDJtqE7NRnzARDdhCTlPyKewvUJeAoMAH+5655lbxiR47ZNFizXEy+KFt9MQU1FAwAJCA//t0xAAAzwzxUofh+AoYHyngzD7gACFgAB3Aci/nK/SzKy41A8tL/EBagv4k/rnb2BlPQZ73Z3yQNkLxQKaFupBoYRSRsGNmLCVOH7JYT5QuzdDUJVZt8GcsmgdLCwpaNn3jsc0NPnugxQZiogeBoaLCXiIdBTIQqF5Wjha6elM79nDfxp9G20OD1VkUQF0AYB6pfWuWWS1ase58xrT5l311m/YE5CHxUmLjZWvtyjif8VXE1B+muNDZiXaBJgzifQMI2ZYBeSr8XZTbabRZ/2tF3zbDATXncx/GZkDtW6jCobRpJwq6sMLf1iEbUghJlSlsEJymgpRUrlWU21F3ePJmU0DlWqQ3Rc1KhJoMRfjIgx6JiCmooGABIQAAgAAA//t0xAAAz0EBUoNh9IITn6nQbD6RAL1qBD5V2hiU1htdU0QSav2p9YQSp4rJJXVo9Prcb+G2lwAypSl6Glv4a3I+umijUWCUvVo0gwjkVtsQU8wl5VNXx47+NUiUkONajh/NB8l6O6ArRS0kQouLIfhpHMS0vpiU9r5Y0Svs8KPWryhmtyLJ4pV/B3Pt+acAJRgAcaxYbfvbMtWNBI+f0bgshAhd2QU12Nw1qXwJBbgM/iKGZWVIxEkEgPVUIztJJFa4+C4qQfxbA0mwXjPqumI16TTqm3xdMK1xWRbDDLiEjR5LQ6oKGE6BGThH8xgPIjZcFoQETdHQt/9WnWeagJpH/cyjJ+dR0juBLDNcYCMQ+cbMmIKaigYAEhAACAAA//t0xAAAzzEBUIRh9kIYIKm4bD6oSTtpIEDySUPWtnIXGwVRUI3jBr1IPmMzFm0+NIKBSHTCXOoavYGWTQUkayjIi/a9mPj+OUg6WJAGEP3Ub/xCs28cMx/jMZm23MxfyAhcnabpniuo02D0Nsp2d6csBPEpGCQa2f/5kiLfG92M/12+clYwR7QFIpMWf3MoN1AQAPkloBVZhnjt8rnqLhMpiRiBFVFPX33i+408zogZBWFnAsk7oftoSACUsycVPdcCly8WvRJ+neYU1inv8/dSI9lW5A81rnIKtawxqsjHiM9isebay5btxGVLurPojDeJaX06p97a0LpCRJCjizHN2MxEiPmGH2cC4WDuPOMpnk7btMQU1FAwAJCAAEAA//t0xAABzvEBSIG9lUoGoCgg8zz7QC6AAFFwHDhiAjOoYOgqhqqHqgEoNHvP4/meChhQkFQpxyiRbU4CpkIoQooC/HUXo9YCgmQ1kaklPDiVP5WTQ20+lmbyJ+IwPUbU6VQJZa3DhPywub+tmcGBqXQpatZYpW9APQ6vHZ0LkpQNzEQooS8JUZW2WriQGFISQv9lQn9x7JthAg23tp9Mmm7GoOZYSK0C0chD4ywU5FkGEsYZOA3wvgWZ2MY9A3hrD7FtJytqg23lkWqU6UaqXBxRkYhba5RlaqlGnyuUpxpgoiTk9MQublhRO0LSpuNJfi4skJwjvmKNh4xqg1XnhQllPKd4zqQ96ysm9xqYJiCmooGABIQAAgAAAAAAAAAA//t0xAACj8z5Qqyx6cHvICiNrDC5AQADnGLybZpjrHQUgRKw4ZfuymJh0CCklxmZgr9SlXMpwAxgkWdE2WmvJdnCWRxxCUvPC4II6wjwuaLL10OMAmSWYzIj5puAkI1tqnaliNrhZtfNk76sqNWG+I5s0p0pPF2xyRx0LtdHKod//FrTPrsOIT2isULCyN+21ZtApVAKg80oo2GsDKzaKQi9NuSybKHGJHJi3Wkueyumh2/btXY0MhAjh4b2q23ymMbmyc4IZV8sh4WRDHdIkHZDLonaxKS8Ra2T5/tnMMrKVpJcv0wzVksrCqcmS+h8ieolWnEMDMiVYSctScpMP/M/BG4Hx0BVK/dYtYx7hiYgpqKBgASEAAIAAAAAAAAA//t0xAADDxzpPC281MoPHyeNvCZZAwCC5zQQZryAXZMIfRqLFgYdCGTQUoQBiw2tCJjCA3UXYnoxvKHGsQmNgESRPMYF36XUvQG6NyZ2ljbQizMYTGdJeQf6FzVSanN58hskKIhsSsWXH+HNRKboZc93iyJHYJRRz81PkrKHAK1DSG4pf+7/6+Hg8ECpJAAFOgFUqMqKTRNM16HNVlwhHRELavkvcEAhM2nFOIEG0Z01LZbtJiJ0rC0a0bgARMmDbk9UXWtv7Ud60+jhw9F4GIIO5D5cZSpwnwcl4WxW49OWJtLGbhef/4vXmhz1CM/ZrYssXTyJJFcUllm5ITpQolUpze9GOzapFJIVMlZ5zSwcqmIKaigYAEhAACAAAAAA//t0xAACCiz3ZUY9AzqKH6cNzSW5AACAAuNwBojAkVBDzeSjlVkkcB1o/dzYbU/mTiHVKHmOhbbjCRcZUGXdrFyokc5Yv+I7FA/Mderk8h+ret1jv/aCpMPn/mmaKtLphYjMex9gwAARgAyLzHIoNFFcAoQLfE28vDUS3M3BI06HTHoqMjFcwyZzi5BORSgKA0tSZo8YsmPEhoyXoIhZkCosWTGCQJmwwIMMJMUDBT4IOtAATMtAoOx0wJg60M+K42C0SphB1P5OVnDD3/qULD3HpnYbi2CCZqjwsf/1Gb1dW+b3TwsHyZ7OwZLeKNdZOpzSYnOFrxfcpxf1IyYw0fEBKIkK4md7rJiCmooGABIQAAgAAAAAAAAAAAAAAAAA//t0xAADD1jzRk1tC5oenieFzaGqAFYEbQhIPQwqbM9NMvCJ9QC8nIJCCaBUpm3ZlI0a5DmYIw4NDAkxEiA4cVlXisA0NHZFVA1BsdC39QiBQu9iRKSU5ACDBhpUYwqmBiRioK7cCALGHHZVqhQijimW6/9BkWP/lYf2huSClMZ4h6am7mv+on/TxENhjRQ0BCAJGTAqZeDhh4MGNksZzCxtsTGTRaaLIplRTDQKMWmkWBx3s1GxSuYApkBEYcECSUXyQRAwKGBgdAVsMGEZIYeSg01L0gQHFRZBwEiky9bAR5PMDhzIlEwkiODBWMAYvADr1XPA0JZUWRa//VVrr/+hjFpQntHVnhf5mU9JGcw2r30aljSVyYgpqKBgASEA//t0xAADDkTrSG1grUodHieFvJaTAAilAQ7FAcwJUxYYk6ChQS5Bis0CY4pEEIAuNCjEMqHuCC2EEalgkN9E5WhqNM4cloJdVAQWFkg06CtktViezjkqyluDlQ0eMJF0tEAIoqIBxuNfqn1F8abu06oxpVIOYTdGZnkPIq0IdzKLTPcT5SORgIrGbmCmJrRiySaPfHpAB/KeusRsZhyeY6oGAHJkS0b9Ih+WIzYxFFMeIguONgCgcWfKwJmiVpcgwgyFRYAHprYweEJ82mGmadoIBTFGAA6UxCzFDN147UAQayF5bFeVS+znn0UCgtAOIC4Z7Eao1u/zoNiCMRSi5qEGRcaarSLblfYeHCqgSYgpqKBgASEAAIAAAAAAAAAA//t0xAAADsz3Rm1kycniH+ro9LLbAIKkAJRYXEGgJjg42+03khBCYUUY8AYQcEBCgIEYGhz2JMw8GEqYQI8087EnghiceURBwZjbkLggTIUkPRIhm7SU1k1lBs0tGXp9SqI+fAWoZlIOXmf/+z0z//+//9OVy7Pn5VtrjXp4fHvXa8Q+880S8l+JXQAEMgBLcgBmgpBc08J2AYoSgG4nyNZnJ6Xo9lXOuOrGLbk5SRJj9LyRskren4TkG1YkZ49afR7FGA4NqWjpiI2RgmTz3wQAwSHG5/PGmILFY9BudsswHBgshvRjqlt9y3wwmAiOpNTr1C0zP2nA7Pk4hqmEBI9NF+CYgpqKBgASEAAIAAAAAAAAAAAAAAAAAAAAAAAA//t0xAAADsEBVUehPAoqH6kVh6eJACBAABJQBEhKCxRjnGYmmFUPVmOzNKNUMNVLvDZl94TIlmM3STqwDURIcCpVyHjEQJ0GksVYG5TqZhcU6nEYjEarFCxujHYFHb8hgVnipL3xXPVLCQiMEic4CHUewcoykgv/wTuEZzf05LYoo2FA8QsEMvSs5hAAJVDeRyHownG5TzZSGxPyVczzacHcDz25hvIZj7h2275yVKUGLXi19jUodN43Hay7jovSCBiwUETN3RVjbimK8aEbdHATCYEVDLnYldmr3l3TLOfplolqphsZb4iN6HqNaYi4IEqzDbGBUHVHUTDDtxBGbaSgKIBEKVdRUVyMUKFIHCEVtdcjbXTEFNRQMACQgABA//t0xAABzoj5VwZhmEpCoKnAzD8gImAAAEIRUb5eIza6+x3ZiU+5alNY+8plD0BuTRHTEUHyRCteucwGwCqeYnqGUNhAI4ZZG8021eLyBHiCKCpSQ+sKhBA1cfipE836lVFsUBufQHoB1bb6xXtjCJMsWaibtRYnJavsJCht+EnpHLPp5M1913aaSdYcC1GzA99li2O66q2692hilsfgdQgJCY0XnQzJgNCSuOw8Eg1OZ6ip4Dc9RVBIhi8rXnTC4HaKk0k2AqppFN/N+4RaKskCppHYzBry00y5fJu1DqCJTVFVw0RGo7VRbkknADck5M1TwKzxSl/LNRbbtvqBCKaR2WLvXbSS1lTGjDEnRp6CwFziPaX1FxH0mIKaigAA//t0xAAAzzD5VoMl9EorICoQZ+KhLLMKIHVOEinp2g4us1KVLxWKZZL2IEw+SRms6mDNHliKCu4h+IlWhI0gr296VqmUJfw7yTK214CPYAjuC3MDIsddLtKzSpJzUguCYfhFrDCX5IFtbD/Ic+J8WJCRXH+6k+Mg0wqVCeikOCBrFjrVxhKZPvmqqrq0PUPpQIAD0YFpZtF5lNprGHDkEUH5poWWqtqBGIlwXCE5YzmSMFXousF6aRFnID8LcQwyjzKU/xalyHChJkzvIhdQ4DtMhQk1M57hTKI1krK5th8PCYmMvuXfyYe3VlN9TKRJ9pHLCIBX4R7lc3Lk+Fspyiol+PJ8nd3OYnMIU4kDqKrucekYp39QRoNTEFNRQAAA//t0xAAAz0kDVoGx8oIXoGp4bD6ZvilYAFLRlhAzgLcqaADgeHcvf2qMHGFC9wuOulvIWmThmT7PlWHsBOk3R5ln+RalQAtiHwluPZteI1Hsq7VOsfwXsVdoc/VZ5p9lcyxq9CUeLgb7chReSfHQ5I1xukDlMw4xtJBIqjeG0yi4k/HQaasNFufv01P8VzEOAACAAAPbpvWH0gq5v5YsaTAQWAMAaY0BkSUbTotSyal8em37sS6G4HfimfVYF6lpMmRjSbZi/6WrrMyAh2vuI1qSd+DKciLgb1DT9Pe+0yTk7DqdD0vhEicGkhwRoWN6pgcrGvHIrA5rJg1GaZwGiwq4xIkkIvN2tdOS6NaFAb9W+I02BqYgpqKBgASEAAIA//t0xAABz6D5UITh9Aoen+iAzD3ZsABAAFuQGCM0b82YNnHT6HBkTqqsowy1HCAUiAiQN/OGuv2CM3NlTReMb8+1wHadYmRav1avn+cyMLscpzprf7CxM6dpmVSK+I9YLznwdR7lScxYo6SNJ4dZpiwqAr2lXHC9Qc2GKduRKcczxQ+tMrUY/0owJ1ULMa1nnAWja+ImAzMk92eVqnVykBS5/FCn7e7s/GKaXR2NSQxiLXN9W7hdi1DdpAt1bvoZysAxnqnPdJEoHSAvAoBFQggOUmjz8+VfVqXR0lAoLOJcD/NGZlbUQ7RUA3Ejo0Q3SMrlT0K0eldE3UyGpBnPFiURCUN2xHaiDnRplMzI3th/l228amZniwUCYgpqKAAA//t0xAACDuz9TSexMUnyICppliXJABkkgAwYjQG4LYEMAYBwLMRTOL9zXauixVKQA43M7XrYqrElUxTLDntvI2vqjwus3Ou4e2iEd3OAtJAsGoPBSXB/PMSJFkQNKSNEk22BMHlgzM8KEBwcJ0aooreSLISivKLH22SEoc90gWRbQujCYcGMRiW0W3KgQCA08Az8MCDiEzzMMNOEu07KPDOIBpXCb2CpSnIjuKRGO2AnTGB0sTAIAB4GhKfd5ECaRIR5nIYwJoERkWNlQiQJBoDT/VyLHVB3CFAHjrcDFvBYVLamQmS7Eajhw2aFQ+XSetRUoEhIIxxC5Sl25iEmEQTaBpZBCKyDrpiCmooGABIQAAgAAAAAAAAAAAAAAAAA//t0xAADT8TxSC3gzcoBHiiFvK3hAQcDzBBYwcFDiQyFWMAgzOSAMKCscTVV5OkQGW9uAlCsp8kfDI/GMaSKHaDoNcwQmJDL8SdLYGNqgLAodaepQFTrkTSTFh6OP7uJSmDJ/KQvLPP08LXZiIw7SXc++8ooVqkRwry8seoqP9LlDUqMhouZbv/EvcO87XKbqdEHBSpMyCzRQAHGZlg+btzGQk6K5aFdCBikDHhFJAhDAETGPn5qSSZSaAcuinWLJKys3jAQKBJUTRrMVuTnSFFhFjqUFzwNAYaQwi5KMbJYsbN3H0gxMBKAILy0d5Uk47V6ELLHf1n38Q2HWrR2jzlenTpOalxalqwo+r4vk+2VLL0piCmooGABIQAAgAAA//t0xAADDwD7SG0ceEIQHSeFvQ27AATVARcM8PBAAWRnPOH//gMoMl2yq4exhjzLcWFRRMMdMdMR5MCHTpUnDMjcp3jEljFFiQUAgBYBPy0BGlgDSWxDzYkVgYSsNFr+XmBQFwuLANLiWZOL/AR72Gv/EFg6BBqW2ZV4wIg2ZFJ+j2g1ZgkAAGiColWIAQlQAUsnNAJtgOelWnKxRtYQKERg4UYAHs8FQAw8ISqLtC1s1oQ/bEEpgwU8EuaMoWSA2QG8WnBGBxsCBw6uSqwsAMKNDBhgQxUgkj07rw4ZgFHqDnP1NQ6yZpTY56BnanJrKW3qmqbWJHSns3/VL1JSORl8cwZFItj9XJSQVMdFPENUTEFNRQMACQgABAAAAAAA//t0xAADDzDdQG1ky8oIHmgNoo+BAASlAIHAImBOgFrTdIQMqHnL9OksLagBW5XSaaT44GdOiElklddyVDpKYwKAAzDQCwobeXpLZTQIBCwCGgUfDJzvFCQhIOQ1MfjEMQw7E3D9NKAgODhZO58f//XiMvN/fV7mfdamb4+Yd0nR2qPzfKelRYSPAUMAAnAABUAFXhkcwACg+CSEThIQUbEAN/0xHpe9si6Gwqrkq8eFojvyyGG4BfaXLbMCBCxRuYkKKoFC1JhHCFrMd8BhwHjHuZmTSfzSZ60os3kpZmzh+HFLzmLAvK/hfcHA1L5fUinP5QelEf8wlcOL6hGeWuRKZwIQRbzFsZqGYAIXPbekxBTUUDAAkIAAQAAAAAAA//t0xAAADLj7XaexKdpSnWaFza17AAUAKABLtwCSEKDCJ8+Vaqo0sCs6dq3566bxUfZdX3ujQaqTGJcvMWTQbANAa781ltxiRNmRVxUjME1xz/7/DPv//8CZc2eFS6G4RTXmeKrOWRAkVHcuc35/7nCKbLXSmiPkqrIgBBAZjYLuN+tY76KDosJOmlkxOADCAeFgYDgQjDFRYuMOADBh0xE1NDvzSwQwEBa6XqWKlSxmHkEpjauagzGUDwjBTNQEOQkEhEQKaoXGPjRxrgP5QtxgbyAIBEYXKlNqxcJi6RLqN9aIgDIAo3goaD9H/BuxF9Qlb9t/ZyXJqRSlvahtfap+K7PUlFf2+ZN1CgQGb0mIKaigYAEhAACAAAAAAAAA//t0xAADjxD5Qm2kuEH/n2hNvKG5AAJUAHQQxUaEkcw0XMRdQOZmVkZgAAh44SxE92Qr4ZYIwMwtbM/C0dEJsMwA6jv0ilEYAouYYEItLbFg5nqNi7Xpl6MhEJpLpNsThyXkZ4nooYbDwsCZ0hAuaDL/6GFyOujbLzO9jv2b0BDK5KqjHRkK6uIluQ46smAIeGMlBZZ/jA7c4KHB12OgoBEEw2xLRRpVXAoCLfAFQs8PPKAsslr/uNLVUhCIewqlwsgAhkT11s5UJc4wgFLAw8UDVmL3w/H4xLoMg9ckYd1Y5mjjoDBotrfaWp3///aueJi/8dAykF33cIzx5+ebzVWrxadXEmivqNuRRM9JiCmooGABIQAAgAAAAAAAAAAA//t0xAADDwz5RG3kTcoRnqdFvIm6AASMARcHQ4Rgw4FAQVNWljGxABCIFAXekr+iw2kmVA09iUvAUyyvshbR3rsy0hRwkph8MTfRCpSmHF6dSWAoxnkBxQGDRkXG/r30samrkYcqTFAgGNymqLn4Yc//6t9OhWjEI4EhSOJEuhtDHNRXc52YwagZ7CTRQCDhUZGgEwMZGQEqsf+rGUHpo40BkMaKEBAcDmRCKujQmEKhDB482rHNF+HsWg9DP6dawWiNdA1xjILTNTNU1S4lqEAGEKDwUcA6guEDgFmIxsYSrZSkUxRiSFAgqgpTXV7/oJfe//2MV+KbZylhDuBNggRgoUKHRlKy50mawIMYQojWQTEFNRQMACQgABAAAAAA//t0xAADDVTxSG0cugpIHeYBzRm5AAUeAT+VSTBGQJUHm2ugUoWZUmJA7anMwasQIwiaayFC4BtyXkTnp9usSKodEyAXlZDTNZuSuXwA9q5C66/7zjXpTSR2ajMMNoxoDAGBs3//26iehHYimMLt0WpKGujmNM7KyB4g+CnK1rChGMKg0rKBgoWmPi4bp7xmVbiIcGBQ+YpBqaYQDx5MmWRkHAoxLIwppN57XSgRLVqzvK9DgqWIAVmUJCSZTIwpAMHI9IVSgQgwQeMMlNpfNYOM6cSYYkTBGoJfua2q5QIDFiAWAgUstJynisYf//rL9t7ayKJHQp673m0Wr5jUiDE0WLSulHP+ZM70UdyegZwa2mIKaigYAEhAACAAAAAA//t0xAADDnT7Nk1IegoXn6XNvBm5AFcCVEZAGCBCcQJcnGontqGNLCQsZHA4O+JjTA6AXQsGTCZH8un+0kDPzJofTBLqo4KL0zbQ63B04jSrQEgVKvJx3jaa/1uMy+B2Q1FbQS0NVC4ioearvl/tsQNQR/ahsK3x9cyqsRtnoWXGlVVijBSzBSAAJGABcuM+FzFAEFAYFITlh4ygBLvmGgYhCG2UCfIzIbCA9ag9FQdlkLh/Cij1p03rSCOGXLQmO3AKHkNWGypkO2WdEOHeVqfu7DLu0sshp348zotw8jsSF7736pe8NYSGQ/G++OKrUsyZaGu6kkkWzHFzXbunmIqlZMZ1CakIBkw6ApM+ZMQU1FAwAJCAAEAAAAAAAAAA//t0xAACDAD9R0ekz9piHqPpvDG5AADghm2UBJIbVImGPhUMKsUjIjj5OFHLUbKuFVFop3FhY0WDUJJS6+J0xtVIUGhsEhWFwdCMZ///c6jwyvDxgxvU3yRVX0+VTKqeVGyjj1V627h2Ja76cFFGmLOxzFvECAABWIAGoSYJKDGEApmC6Y5bmaE4UOiFKNWITXhscDAhHMYHzBhItU/tBIYRTxGdoHTgJ5h0bGGnuTMgR6Yq8dOizBzGoOoPFTjaTTMbpYtSNbdxhIkGKOku5ny1n+lT1RqxaKwNVEdHF5ePcpGx9cXGNaGKgKVbI9Ln4V5lWVRURNtHrZNcMifGhyhPGJWv2TMLoTG/b6cUxBTUUDAAkIAAQAAAAAAAAAAA//t0xAACC4jdOaekz9J5ouHBt5sQAAABiAKcsYDcoBHHExiwEiJo8LumoymZsPYswlpEXIlS6k7M7isI/DgbciG3QleKXNCsQpAZUI8EZJSi5mhtc543Xt0Osk6R9XlCkiz3VGfHwn8yznlbs5hRofpC5cbcGmiOoANTQqUydsWGEq4ykINkgRwIBgqAkgVCTKjUoKBUAbVv8acvImo5TzZKDtNf9uRe1UKehdNk7tcZJG2emKCoYIx97HaKGMtzKEpTebCvfGUiUW5Rh/LRKlTRPruaBrMj7cSDK8JUlcm0ySmJQjR9WxRrCKJUs4SRPGNqZKRqZSzXj2it/vbcbn06wxMi4ZsLEDDigVS+n1JiCmooGABIQAAgAAAAAAAA//t0xAACDXDBHUyx7cpOp+FBt6G4AADUpOxECBg3Nr7hMTHFGABQhH5JFJJx3VnYAFw/Ml+kAlEKBcmTHWLBKSnQPe1U+YKgDCil+mzO44XC0Yn1Tf2TEUmLxyexJjpbXUj6V9aatpJYrn9+9bb02RoUW0PSBuULpftc93q57/5gYSnGKRiAEWzAgeHVpfMw0BBxeYAXGRgRYCgEPKGLBgxBbUEXRjdGiOmZ0mTlR0W5PTRSJ5tj66+wlvAyRrvmHULcGkKAjIxkrkt50uMKJDhVHOofEkUojvzh0aKnKNolmVBcIdaqCB9ll0QO3ocMdhKslpYuwkt2GupfFwW1rcjH3GKtL+8X3oxMgM8HxWwEW311JiCmooGABIQAAgAA//t0xAAADWi/FUwwzcIvqCDFl5m5ACBUJxoABZCYbsFqoGCFFqlcOSWaU0bZKqGoHQQLI3XGqCUfLoljP5AA4/L1f5jiCFsDcCyr2NNrzjJJoaj6eRKCUhD0qiIhdWNAypk/VUicWlny3L9r5zhobOgJJ6BTwkjDyYaosq0WMboUAZAOhomjBIAQ+cIIIEa0GEBSNAYkcFgZa4yfQJwNFUqUKmZmaiCitasDXLDMrkKlq9fHedaddJ17iLRzhsbgwqmUw0QacWC+Y22LWh4GSmvV0lYxsORY9Cr9IKcLXBmO3jfFTy/LWRernNw05/Eartf15LynupiTjsZr+y+Qt8UzKlMV5fk38vrXR6YgpqKBgASEAAIAAAAAAAAAAAAA//t0xAACT1zhDSw9J8IHHqDFh5mxAAAKqQAUSBK36FFSEKBUyY8UgKVpJqTZETIRWzbWAtKyA5PI13StN4b1HOFdEjQgZFBfkKFVtIUbgnGS1ADA+SJDqhPNNvm208nfnS0fBu9QWonlyZkruq623PwtvUFfvUYcGDwfFy7XgsAyhw4QPhoezFUwzdYL/btSTMA2eUlIDBO2TaGjzQy5Ael0RRd6yUjmhdHIyz3QbA/W2OKcgNgH4W94spyK6sThTs5niZtSEK5ngKuO+Y1CbSMOZlpNbWIvCh3DAh7w8WeQ1SEkKt40FRewU01fiSIKrM7uzZlY2nMl5blOidq/xZoAw6G4VMTOh0BduV+7+/r/6mIKaigYAEhAACAAAAAA//t0xAACTxzVEC0YekIPHCIVpI9ICCOspa+ke7Sh4kOBACHV8LbZ0si1E2wrimp6fpmjJEQh91GkxGDJgMrNLZDMZkkgGaMPdyGi/j6mJdm7DhARsIKJrXbGuums26e3ko+GLHlIH9OuqARCzUndcenHOmermhLXdEK/wIQnawPiASIAAveu29DvT1cx1kHNuNDyfClyB4GCqC06CGeu1ZZDLVmjTsvxoYBeWWs5h1eSCrcGJGaknqoiiY2swWPstbmlQX+EAc1T04yUGFjWlkknRzhiHoHjMmlvRXp01BuNCY6nbDUpY5lREl8pu52jeUF/DB4xa1TYzISMCQFBktOqBUUjRYk8og+StLiiH6F/WmIKaigYAEhAACAAAAAA//t0xAACDtTBEMexOEHxF2EY95m5AUF8ANYmq0ECPwaJcjbY1a4yObBEOaqg3Lqc6HJzfncnI7EO49XgswsTakxwzrBgj1DlLQfCkbOVBqYHziU7dQySG2F1kzJTy+nA02SRmjCptFBJTWZSg1JV00EJbqZBQoeD8koYljwSYJ6UitLXutRr0aR6bnCG0AGxmsyngRhDSUmsejGaY/F9dnSnVWkk25ncQhPNLe8eqLBRK8upMGzStT1kPG8VyuYY7apVS/hqFpUyXRce43UcqZkLYWbonSjakXEFWHOR2nwtztMSf6oHTpCu/6EvF5VhU8DG4+1/ZVnNCP/m3/67ez+3+/ux0//4mIKaigYAEhAACAAAAAAAAAAAAAAAAAAA//t0xAADT0EnBiww0oITqKBJhg45ID45YdO8IUIUJjq6V6gjQBE2JiVMwd91sncuuAvWM6MDDPgHPnl4+rFD+PBgeFqArCHDJBKxqBBeAJaaOJs81TFS5IHbrc5NZb/j1E7cpF8cjvnceC6LojjO1Tv7YvO/8axWvcb5h03++2lYmc4RYDWSFQ2uH3xEy2skLMoqtBf8RvI4SVz3LTtXAwdsjxJbqWqPwNJYWbEiGMcRx2BASpjoCq0kq8C4JR3MCWT1UKGm5AVLzpbRcxDSl6dpieVmuHOOFm6m7p60rltch7kNH8XxNuMgdDnUNYEtOiRnO9heTdEpHl5qjQlIUyuRGpGaKyk1DFO/M9FGyc/Rp5QumIKaigYAEhAACAAA//t0xAACTwUNBCwkc4oKJ2DZlg5xQCrmxZL5oIiGPSTUgG9KkVV9RSNqyJUtCnmVS1kliG7bSFUP6WG7WgU0MQLG8IzG/7Rss5BJc409HSyra3Q42lA03BpuDMtmmm2Wcv13oMvIWGJSJ1NIpmls+9MleIIdjvJaC6+px49ECv9IPM/SZgj90H6ANid4hCS3twXXS+JFCoGoemIkAi+NniMFvmcI6mMBGXlhh5F7rgiMiH4zUUTSdOH4FISejOTstqY3h6NjwvI01KMurEbnL33+Zhx6tl33u9XoU++6ofmNvsfr6zlzPmLhGqKNDhHwjKEvPO5pTkOk4Y9aZvytjhCtcyB8B0iifL+YHjLc/9piCmooGABIQAAgAAAAAAAA//t0xAADTzDpCEwwcwoMJSBFhhpRBgAN6h+BIOQlIyM3chmBfUAjQylLwNuX9kEbwl61YPmrax9Y8WC40KjA1OD4tXZPE7itasOn3Uq51g/VKT105KR6fLSqsFmJcY38ZRjmwCSiSoVVcYzVWKsVpm8kMujmivrGGWpa53d3Uujd1Rj608wRl/XXd//3/nRjxujbzgkBZDQ4NeIOSU5JoL9eMHWTWVHC5usnVPxCywgiEqMgu0RyahhmKgPmCoqDnxfBSrRDEjQUkkMeCThAbhqP+n2tZEnMLKvTDbwkFI6kgjp5EZtlO2ya+QV5Rop++O7NbiNumxremzXL+NRfbWgvE7eWZkmOG/Pa/z1F6XrfxMQU1FAwAJCAAEAAAAAA//t0xAADTzUPBEekc0oPKl/BhhpRWQAJNrg3Ukni+EuVhmn8QMYo6S8qRJoUsLchIzFnbUMUjkAGiCJDASjRACg8KllzblTRFZYG201S+qwRSbJe96SB08Yz3u4aZQBAQYDF0IGU1WB8uvOWqv5HkQUKYJu2w2WyEgbiTAg2A8F6k75Xt4r5OfDpY/Dyd+ZSyfemhYbAkJizTBg7lkoZ5aqTUvvU8boFhWI9mzwPrjwHohEQhP1OObLrRyrXqjWSBqMxABLHWQY8iaHRCz3nUYTg6zR6aR74sEW5qqOZAxw0Upvvl33UyouL2G50GQlnLKyo2sxsx31ClpTerN21n6fhzMvotu9tyCyJUgvZLtvIxKmIKaigYAEhAACAAAAA//t0xAADzy0nAAekc4orLF+Bhhphy5JSqOOB+twCCqQvRZQS8g0FyaZcnE/kONZrYSEgg0eAcCU0yU6WsqNQIzQnPoZKQWOOGizibMucpoRpBBghLeT14I11U8nrb28QTSirsG+5CDjheuSOx5q9JrKI46iEkjGe+piuN9sG6+NEYrUbZOrVcJ6tHNKsX1EqSJy5f4cZXFG6bKEyWlMFaJBthjqfdNOU6+2SxKnLw4j4yOo5CEbOombMpVI1qPLheKy6x2nNEysxOXR/O4WjCdTw/Eoux4CJcIIHpJlGkjIRwgg+FtpSNKhBTRr4+odHfpb28zhLts2ouft6dCyuXiDVeW5cWd3VEc/zJ7Mo+mdFv8IJL8idsvOmIKaigAAA//t0xAADzvF5AAeYd0ITrx/Bhg54izxUifILsil451Ag1Oh6UOAwCYMxwps8DNT2XzCrfLFYoTko4NQw0wAaQrmEJL1r+Ay8WmHNTPR3IWIj2LqMZyz0iBSEHQX8PQi01gaa216Vk23+2Xu8jgeoivPhZg3IpbdklgM+7yOeRfOF6Oy2kxIZpmZLcQiq+cxOxYVJIn/dpyZMxeLtIlTZmILIbVzYm9d+Wy8ZRl4mL33U9HhBWrcefPCYl8vnMDCPbE30r+UOGbH2H55Zd9a7WHnjqJmlEilbpNMatVZ5t1Y4hxs0iZ61622dv2/a11ItiPOtXDugM+JViDor+RMiGZUVaecaoZAs2ag4Wue7CjBR6YgpqKBgASEAAIAAAAAA//t0xAADT2lQ/Aekc4oBrZ/E9I4xcIFDRLsSNvVyhO8sKdLwwMoX8JCXyKqlGstz4KqtCuLaAEwigKNiYhDoYx7FPVaZup7A2uFyQz0Ij2MEEVU5o0EbZKlCjWEGTbhaewm32burjohqWdTBsSdHxZUtGEBd80yLW2kzEZLygpua+6aqhVyFt6kOyxL4HyCa4RmI5m8ex5qBUF7JJowCuZzqUYda6UjKimSgrLEKMPkLiMBwGB2IyiZaGUJkPrmk76F44TjyJkmWkpKJFqiJUo1jEFpNnJrHUdmHJXEiKwSiLQy2ScFj7OjZn5IdNTUh1Emp2JTiuSQLFNRTEhHcjINIaI6srUqlM2GhwJCl6cRCYgpqKBgASEAAIAAAAAAA//t0xAADTzFs/gYkb8oOrV+E9I5xZW8cF5DBUd+JJXEkDg73CI/BqChOwquFzTjJRECY/FoUMSGCZNAJDDzh1O0L5RjJtlGpikpBp+NC3QS/n2DkzSdDCQoJkDrIgQPj0CWDkYU44xSCM6gzLhI5IzmxbC47Yi2nwySOlPfKs13WjmybpUR1J6Q3iOuorpRDY8Ky68mDAH+5qokgk6rFsfYLYVR1NraeD1OEDBcRLgwzpOJRlAwhSEdiUk3M5tMqPSTIwu2Oskri6ySgXTPPOGZw1VWBtHU5EVl6QQRkfXnCg4EiBCQRygYUctEPybR8wmVem8SoL6RDxBPXdfBAgfwjIYGshKr1DWhWjmgqAAwSjSYgpqKBgASEAAIAAAAA//t0xAADT3l5AMYkeEHYKqBIww+BAC2gARnvmDoBgYDUBZVSAFimESQegGsCe0iLSOg+LlK05ElV5eet4giw3EAtF81DRMRkZOPE7IUUUaMpB47AyZaDQDlwQIEZUM54AlDIDZmgY6oI3dqCXMWR6lZI2Se7VJeFke9PYlJf+rc/Q1sX+Uz2IyLTY263HlHWUvmOV9B5IxJPo4ClQ3QxgJJ6dBRCiiuVHGrQJB3I6Edl9YDYcxFEADgCj0IiydlrnFZUHIwBQrHC5Mdo0OjjL4GXm5trPNf1QdPBm5kZx6+4mzdHIQzHbk6ckvyfun5PHln57U2vX71CN97ua08c/o+bi1lljmUxBTUUDAAkIAAQAAAAAAAAAAAAAAAAAAAA//t0xAADTyWNACeYeMIKrt+A8w7pwC7czvh7iwvHrisMeEJZC6KhKocT+aDAeytamMVi2jo0zEnm5yeqxXJaZTZUhxb7JQUenKdMlPq6QSgsoqzTzzU7LiDCMk/tGyqa1qtHOx7XQ2Uz+u5ACuXpgyt8uJUnoRcvCY3KO2zdhw/NoVJPtdiJ6Uxi755EQz5hVdzcCTG8baiJ08YWZiVB/nKYxYU6wruGqaGcS85m2tHsRWJ1zAIMfCwMkBYGc4LPYJJngwmXWOlwJwkkpBIdKycHGBRGQCnAEFW0OqlZ0HTMDPJUWXjvjolR8NMyQlFwF90zQMxwDUCgCXFYEHWCGJq5E2fOhn+w0bWQj8YmYV2dMQU1FAwAJCAAEAAAAAAA//t0xAADTyVU/iekb8oYLJ+E9iH5ICRz0nDkOJhkJg9UyomJsSM1irHssJjwkQyhAowkcSJkzMxUImirVlkVD5EuFrQpMmNXVXXsw8kNIJSgiEicJoI1HwQdTdSUnkF2MgoOTr4scypG+w10BvbxTDndm4RuPmynkZGrFRcjlCMhZy93wU8AvhTBhkmx8yJlTARKKLbIjrIhEoiOwmwTgRUnxJA0zUDxiJzwimRYwpnJytLJ7GWGeFxJfaQyq/eD2DSMvJ2BPXUKRjFFC+uW8jajdlGeJHauYGjkKYpmxa3WOGoc8zZTuIF11c00j0nIHPeMRB9FzFyVMDcZCM5b1JqXLHbylw1Gy9dM0sk5Z96BNOf5piCmooGABIQAAgAA//t0xAADz8V4/gekc8oWNB/A9I44hPj3NMhh/qBCDkqpLTL7CcJvuR25QaWVs6VBsFabDaaJINuTLsjSEU2frUIughGJGuoJGxs1hCRqHKRkDOFyiqOGopY0iTuWa3v2u/3C4don3FWbnCEfG3Q26YlwA0sh9TJUrvjzBBNG3nCY0i3BfbFQ8yCU2xlG5j7rYDKsx5m9feI5ZJW3E3XMZrZDkWnS6PMy0MaWEOAKAOBUHAMmloIzRIMMvTTVI8STSn/iciY2yyJ2mYDKWpLQWxTZ1UV1NGFdgktWIl6bjroRKoXdYb4q8puq2JXlNwLdHR+UVgyIhDGmgyhwgfWG/hoIQODYQHoJQlWrAvg72HMb0nUPhF6voApiCmooAAAA//t0xAADTujdAiewy8oes1/A9hn48C8q4Y0WIFWEgoMFSAOYXEpo5K6U0ELD1NC43EiQlzpimSG5LSnhdbYxejqaprOOpg6QcCArJipUhCsGGlrBOXZMjUHp/qqYjEZ3n3WpoWXEzbPynK99/vET6ZbRE7lLvfOgF/UqjvGrVaXC/WvlZkYBOc3QAeU1EXTUoRCcqaCPlGMC+jkcQ1LnOQjdgsQtUPuJx1GlLLqMY+ea6sTwKoqxckgOW2LLfSJj8f1lWWLobPHTdUJSTu3oqlMYrxkN/duVKbOeGQZPX6uury5e4ZAuUCacR5n1zul3AjpNiov6ljx3aJ+lyq++MzdUa731yvGaKpnRmMfxmfZZ/WWemIKaigYAEhAACAAA//t0xAACTwVtAASYfEnDFSDYlhk5b0SkwnEUQKEoEmCcQEIqAOJEY0F5hYhHzgqYDyETmVhhPxmZxN6OC8jdNNylGEcTHbIF5RLsHzpZJIiiCpXLUNJSu5u/v2nzeIXBE7NoX5sR4iYxW+B/M2dJbH5oRydeLkkyyDTpOEZ9SMqWshYKjP4k+fXHvJM0D75eR7eRpWQB4RH1KoqoJ4maekUl4/Yd45WRsGLidUVEfVqTY06oiNIFgzEDwoAICCgkyjBtoObW0EjgrkB4IJGF7KeJwJ0bHfIUZ0qceP7q4iJ+iKQZXTZVyoYsSkc6sQLV1sixTjptVlFo93/fuDKYgpqKBgASEAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//t0xAADT62ZAAeYdsn/NCAEww9C1fXglI6VjkiSYq0/rGjMnH6uYYERWO6QIkN0jbuFoDOqdI6eAdC3ezXXPVqPTFmwnRKdgkhyjqss02m5C0AFUnJkqZETSmwddmpUiY1zkFIbi1drCWBrCSlXFGzscjGzqKVoGHJVc9psZUNiQUyaim4rCbUNmQkUoHIqLoQMbwpHvNn480IoKGZTPlZMLo7XufCcnXvQHy2q5J7+L1spm8OC2Wjto3TLWy2ejiaFzulCahJEeq4XCwIJgtZkowfDUmeLhWxmIScFFUOQIfEZV5Ip1SovxjZwcqmWUQ1bE5G+IBDYSNYxIjEiEyIC02tZDjYZLg8Pz86KConiw6YgpqKBgASEAAIAAAAA//t0xAADz42ZAAYYeIoQs5/A9JnZosrcnLi2TjZCG5CQ/RjsmXIb9aLXI2GXOZrVVRcvLSFX2mM37R0SbuHmJFo1mkzzaYw1Fihi2U+PQ4MJQ5DUX1f6EQgawgQSMdyKsP4anKIYlso5cBY3FiEllOuADEL3CgMVSGHIzIoo8YhSmzRsSE1eCkTFhwSbPcaBZXuNiG2kya0yeCjHwvuKqglojsqmumqQhMlTRvRCE2iRr5CyMtZAnpN9vQai8TrvFHMuKQR6qSt4EzO4sambQefhcM8I4U9+IV2xkXkymzsUX7tTVroVVQ5pjJQ6OxLU5HTzGJlIkGFl/cQ5nM2tk2vG/1ZbEb32z2Ve/Treb3qKDkHgmUTEFNRQMACQgABA//t0xAADTymS9CYkcwIVMAeEkZvQ8DVp6cgiB09JI6jyanUZypOlW286EoQgbHyJqKGAJGlia/1WYoWa1DNnJIiILBpEqz/JEiFRMhExjZtWAgJm9Vb6X0tVCgICql8P/oYCAgJjUsMK/6pVVI6QYCX+ATNs1WUBJs6v/7Cm/Kev9X1VS1VYxsx4UBAgIdCIhLFThcojPBkLCEaD4wIyAVtuldXUViIhEQyHhsgIyQShoQjQfGBGIC66SaSaU4NExCRFThcoRoHNRpOrSTVWVWTSDoLFAIYKCBhA6If/yq1llQ2VrLHQmWWWX//2ZWLKLi1InGnFlHmXf//+USInGlFmE0EUjTiyjzCyyjSiyj4WSIikxBTUUDAAkIAAQAAA
+            mimeType: audio/mpeg
+        role: user
+      tools:
+        functionDeclarations:
+        - description: "Convert Celsius to Fahrenheit.\n\n    Args:\n        celsius: Temperature in Celsius\n\n    Returns:\n
+            \       Temperature in Fahrenheit\n    "
+          name: celsius_to_fahrenheit
+          parameters:
+            properties:
+              celsius:
+                type: number
+            required:
+            - celsius
+            type: object
+        - description: "Get the weather forecast for a location.\n\n    Args:\n        location: The location to get the weather
+            forecast for.\n\n    Returns:\n        The weather forecast for the location.\n    "
+          name: get_weather_forecast
+          parameters:
+            properties:
+              location:
+                type: string
+            required:
+            - location
+            type: object
+        - description: ''
+          name: get_image_resource
+        - description: ''
+          name: get_audio_resource
+        - description: ''
+          name: get_product_name
+        - description: ''
+          name: get_image
+        - description: ''
+          name: get_dict
+        - description: ''
+          name: get_error
+          parameters:
+            properties:
+              value:
+                type: boolean
+            type: object
+        - description: ''
+          name: get_none
+        - description: ''
+          name: get_multiple_items
+        - description: "Get the current log level.\n\n    Returns:\n        The current log level.\n    "
+          name: get_log_level
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro-preview-03-25:generateContent
+  response:
+    headers:
+      alt-svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      content-length:
+      - '679'
+      content-type:
+      - application/json; charset=UTF-8
+      server-timing:
+      - gfet4t7; dur=1756
+      transfer-encoding:
+      - chunked
+      vary:
+      - Origin
+      - X-Origin
+      - Referer
+    parsed_body:
+      candidates:
+      - content:
+          parts:
+          - text: The audio resource contains a voice saying "Hello, my name is Marcelo."
+          role: model
+        finishReason: STOP
+        index: 0
+      modelVersion: models/gemini-2.5-pro-preview-05-06
+      responseId: ONBKaP3rKvqP28oPqLnEkAQ
+      usageMetadata:
+        candidatesTokenCount: 15
+        promptTokenCount: 575
+        promptTokensDetails:
+        - modality: TEXT
+          tokenCount: 431
+        - modality: AUDIO
+          tokenCount: 144
+        totalTokenCount: 590
+    status:
+      code: 200
+      message: OK
+version: 1
diff --git a/tests/mcp_server.py b/tests/mcp_server.py
index 787a520bd3..fde819b4e8 100644
--- a/tests/mcp_server.py
+++ b/tests/mcp_server.py
@@ -4,6 +4,7 @@
 
 from mcp.server.fastmcp import Context, FastMCP, Image
 from mcp.types import BlobResourceContents, EmbeddedResource, TextResourceContents
+from pydantic import AnyUrl
 
 mcp = FastMCP('PydanticAI MCP Server')
 log_level = 'unset'
@@ -48,6 +49,19 @@ async def get_image_resource() -> EmbeddedResource:
     )
 
 
+@mcp.tool()
+async def get_audio_resource() -> EmbeddedResource:
+    data = Path(__file__).parent.joinpath('assets/marcelo.mp3').read_bytes()
+    return EmbeddedResource(
+        type='resource',
+        resource=BlobResourceContents(
+            uri=AnyUrl('resource://marcelo.mp3'),
+            blob=base64.b64encode(data).decode('utf-8'),
+            mimeType='audio/mpeg',
+        ),
+    )
+
+
 @mcp.tool()
 async def get_product_name() -> EmbeddedResource:
     return EmbeddedResource(
diff --git a/tests/test_mcp.py b/tests/test_mcp.py
index 2f79d86600..2681955eaf 100644
--- a/tests/test_mcp.py
+++ b/tests/test_mcp.py
@@ -20,7 +20,7 @@
 )
 from pydantic_ai.usage import Usage
 
-from .conftest import IsDatetime, try_import
+from .conftest import IsDatetime, IsStr, try_import
 
 with try_import() as imports_successful:
     from pydantic_ai.mcp import MCPServerSSE, MCPServerStdio
@@ -46,7 +46,7 @@ async def test_stdio_server():
     server = MCPServerStdio('python', ['-m', 'tests.mcp_server'])
     async with server:
         tools = await server.list_tools()
-        assert len(tools) == 10
+        assert len(tools) == 11
         assert tools[0].name == 'celsius_to_fahrenheit'
         assert tools[0].description.startswith('Convert Celsius to Fahrenheit.')
 
@@ -67,7 +67,7 @@ async def test_stdio_server_with_cwd():
     server = MCPServerStdio('python', ['mcp_server.py'], cwd=test_dir)
     async with server:
         tools = await server.list_tools()
-        assert len(tools) == 10
+        assert len(tools) == snapshot(11)
 
 
 def test_sse_server():
@@ -212,8 +212,8 @@ async def test_log_level_unset():
     assert server._get_log_level() is None  # pyright: ignore[reportPrivateUsage]
     async with server:
         tools = await server.list_tools()
-        assert len(tools) == 10
-        assert tools[9].name == 'get_log_level'
+        assert len(tools) == snapshot(11)
+        assert tools[10].name == 'get_log_level'
 
         result = await server.call_tool('get_log_level', {})
         assert result == snapshot('unset')
@@ -429,13 +429,7 @@ async def test_tool_returning_image_resource(allow_model_requests: None, agent:
                             tool_call_id='call_nFsDHYDZigO0rOHqmChZ3pmt',
                             timestamp=IsDatetime(),
                         ),
-                        UserPromptPart(
-                            content=[
-                                'This is file 1c8566:',
-                                image_content,
-                            ],
-                            timestamp=IsDatetime(),
-                        ),
+                        UserPromptPart(content=['This is file 1c8566:', image_content], timestamp=IsDatetime()),
                     ]
                 ),
                 ModelResponse(
@@ -465,6 +459,61 @@ async def test_tool_returning_image_resource(allow_model_requests: None, agent:
         )
 
 
+@pytest.mark.vcr()
+async def test_tool_returning_audio_resource(allow_model_requests: None, agent: Agent, audio_content: BinaryContent):
+    async with agent.run_mcp_servers():
+        result = await agent.run(
+            "What's the content of the audio resource?", model='google-gla:gemini-2.5-pro-preview-03-25'
+        )
+        assert result.output == snapshot('The audio resource contains a voice saying "Hello, my name is Marcelo."')
+        assert result.all_messages() == snapshot(
+            [
+                ModelRequest(
+                    parts=[UserPromptPart(content="What's the content of the audio resource?", timestamp=IsDatetime())]
+                ),
+                ModelResponse(
+                    parts=[ToolCallPart(tool_name='get_audio_resource', args={}, tool_call_id=IsStr())],
+                    usage=Usage(
+                        requests=1,
+                        request_tokens=383,
+                        response_tokens=12,
+                        total_tokens=520,
+                        details={'thoughts_tokens': 125, 'text_prompt_tokens': 383},
+                    ),
+                    model_name='models/gemini-2.5-pro-preview-05-06',
+                    timestamp=IsDatetime(),
+                    vendor_details={'finish_reason': 'STOP'},
+                    vendor_id='NtBKaNyJNuzRvdIPls2XuQc',
+                ),
+                ModelRequest(
+                    parts=[
+                        ToolReturnPart(
+                            tool_name='get_audio_resource',
+                            content='See file 2d36ae',
+                            tool_call_id=IsStr(),
+                            timestamp=IsDatetime(),
+                        ),
+                        UserPromptPart(content=['This is file 2d36ae:', audio_content], timestamp=IsDatetime()),
+                    ]
+                ),
+                ModelResponse(
+                    parts=[TextPart(content='The audio resource contains a voice saying "Hello, my name is Marcelo."')],
+                    usage=Usage(
+                        requests=1,
+                        request_tokens=575,
+                        response_tokens=15,
+                        total_tokens=590,
+                        details={'text_prompt_tokens': 431, 'audio_prompt_tokens': 144},
+                    ),
+                    model_name='models/gemini-2.5-pro-preview-05-06',
+                    timestamp=IsDatetime(),
+                    vendor_details={'finish_reason': 'STOP'},
+                    vendor_id='ONBKaP3rKvqP28oPqLnEkAQ',
+                ),
+            ]
+        )
+
+
 @pytest.mark.vcr()
 async def test_tool_returning_image(allow_model_requests: None, agent: Agent, image_content: BinaryContent):
     async with agent.run_mcp_servers():

From 80f65bb434883e8d680ff6a36d3ee27a30c688e7 Mon Sep 17 00:00:00 2001
From: Marcelo Trylesinski <marcelotryle@gmail.com>
Date: Thu, 12 Jun 2025 15:37:02 +0200
Subject: [PATCH 4/6] Add GoogleModel

---
 tests/test_mcp.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/tests/test_mcp.py b/tests/test_mcp.py
index 2681955eaf..7a48f061a4 100644
--- a/tests/test_mcp.py
+++ b/tests/test_mcp.py
@@ -24,7 +24,9 @@
 
 with try_import() as imports_successful:
     from pydantic_ai.mcp import MCPServerSSE, MCPServerStdio
+    from pydantic_ai.models.google import GoogleModel
     from pydantic_ai.models.openai import OpenAIModel
+    from pydantic_ai.providers.google import GoogleProvider
     from pydantic_ai.providers.openai import OpenAIProvider
 
 
@@ -460,11 +462,12 @@ async def test_tool_returning_image_resource(allow_model_requests: None, agent:
 
 
 @pytest.mark.vcr()
-async def test_tool_returning_audio_resource(allow_model_requests: None, agent: Agent, audio_content: BinaryContent):
+async def test_tool_returning_audio_resource(
+    allow_model_requests: None, agent: Agent, audio_content: BinaryContent, gemini_api_key: str
+):
+    model = GoogleModel('gemini-2.5-pro-preview-03-25', provider=GoogleProvider(api_key=gemini_api_key))
     async with agent.run_mcp_servers():
-        result = await agent.run(
-            "What's the content of the audio resource?", model='google-gla:gemini-2.5-pro-preview-03-25'
-        )
+        result = await agent.run("What's the content of the audio resource?", model=model)
         assert result.output == snapshot('The audio resource contains a voice saying "Hello, my name is Marcelo."')
         assert result.all_messages() == snapshot(
             [

From 4776acf52960cf50c0f42b7a1798d75bdb5d49ee Mon Sep 17 00:00:00 2001
From: Marcelo Trylesinski <marcelotryle@gmail.com>
Date: Thu, 12 Jun 2025 15:41:50 +0200
Subject: [PATCH 5/6] fix test

---
 tests/test_mcp.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/test_mcp.py b/tests/test_mcp.py
index 7a48f061a4..ffea0cb79d 100644
--- a/tests/test_mcp.py
+++ b/tests/test_mcp.py
@@ -486,7 +486,6 @@ async def test_tool_returning_audio_resource(
                     model_name='models/gemini-2.5-pro-preview-05-06',
                     timestamp=IsDatetime(),
                     vendor_details={'finish_reason': 'STOP'},
-                    vendor_id='NtBKaNyJNuzRvdIPls2XuQc',
                 ),
                 ModelRequest(
                     parts=[
@@ -511,7 +510,6 @@ async def test_tool_returning_audio_resource(
                     model_name='models/gemini-2.5-pro-preview-05-06',
                     timestamp=IsDatetime(),
                     vendor_details={'finish_reason': 'STOP'},
-                    vendor_id='ONBKaP3rKvqP28oPqLnEkAQ',
                 ),
             ]
         )

From 685a7fd8355d9bbc12a5188bf2b9837ec6004133 Mon Sep 17 00:00:00 2001
From: Marcelo Trylesinski <marcelotryle@gmail.com>
Date: Fri, 13 Jun 2025 10:28:12 +0200
Subject: [PATCH 6/6] Add coverage comment

---
 pydantic_ai_slim/pydantic_ai/mcp.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/pydantic_ai_slim/pydantic_ai/mcp.py b/pydantic_ai_slim/pydantic_ai/mcp.py
index 2b5c205fbc..5c30de315c 100644
--- a/pydantic_ai_slim/pydantic_ai/mcp.py
+++ b/pydantic_ai_slim/pydantic_ai/mcp.py
@@ -177,7 +177,9 @@ def _map_tool_result_part(self, part: Content) -> str | BinaryContent | dict[str
         elif isinstance(part, ImageContent):
             return BinaryContent(data=base64.b64decode(part.data), media_type=part.mimeType)
         elif isinstance(part, AudioContent):
-            return BinaryContent(data=base64.b64decode(part.data), media_type=part.mimeType)
+            # NOTE: The FastMCP server doesn't support audio content.
+            # See <https://github.com/modelcontextprotocol/python-sdk/issues/952> for more details.
+            return BinaryContent(data=base64.b64decode(part.data), media_type=part.mimeType)  # pragma: no cover
         elif isinstance(part, EmbeddedResource):
             resource = part.resource
             if isinstance(resource, TextResourceContents):